Dev/refactor 0414

crates/cli/Cargo.toml

@@ -13,6 +13,7 @@ path = "src/main.rs"
 clawcr-core = { workspace = true }
 clawcr-tools = { workspace = true }
 clawcr-provider = { workspace = true }
+clawcr-protocol = { workspace = true }
 clawcr-safety = { workspace = true }
 clawcr-tasks = { workspace = true }
 clawcr-utils = { workspace = true }

crates/cli/src/agent.rs

@@ -1,19 +1,18 @@
-use anyhow::Result;
-use clawcr_core::{PresetModelCatalog, load_config, resolve_provider_settings};
-use clawcr_provider::ProviderFamily;
+use anyhow::{Context, Result};
+use clawcr_core::{
+    ModelCatalog, PresetModelCatalog, ProviderConfigFile, ResolvedProviderSettings, load_config,
+    resolve_provider_settings,
+};
+use clawcr_protocol::ProviderFamily;
 use clawcr_tui::{InteractiveTuiConfig, SavedModelEntry, TerminalMode, run_interactive_tui};
 
 /// Runs the interactive coding-agent entrypoint.
 pub async fn run_agent(force_onboarding: bool, no_alt_screen: bool) -> Result<()> {
     let cwd = std::env::current_dir()?;
     let model_catalog = PresetModelCatalog::load()?;
     let stored_config = load_config().unwrap_or_default();
-    let onboarding_mode = force_onboarding
-        || (stored_config.anthropic.is_empty()
-            && stored_config.openai.is_empty()
-            && stored_config.ollama.is_empty());
-
-    let resolved = resolve_initial_provider_settings();
+    let (onboarding_mode, resolved) =
+        resolve_initial_provider_settings(force_onboarding, &stored_config, &model_catalog)?;
     let saved_models = [
         (ProviderFamily::Anthropic, &stored_config.anthropic.models),
         (ProviderFamily::OpenAI, &stored_config.openai.models),
@@ -55,9 +54,30 @@ pub async fn run_agent(force_onboarding: bool, no_alt_screen: bool) -> Result<()
     .map(|_| ())
 }
 
-fn resolve_initial_provider_settings() -> clawcr_core::ResolvedProviderSettings {
-    resolve_provider_settings()
-        .unwrap_or_else(|err| panic!("failed to resolve provider settings: {err}"))
+fn resolve_initial_provider_settings(
+    force_onboarding: bool,
+    stored_config: &ProviderConfigFile,
+    model_catalog: &PresetModelCatalog,
+) -> Result<(bool, ResolvedProviderSettings)> {
+    let onboarding_mode = force_onboarding
+        || (stored_config.anthropic.is_empty()
+            && stored_config.openai.is_empty()
+            && stored_config.ollama.is_empty());
+    let resolved = if onboarding_mode {
+        let fallback_model = model_catalog
+            .resolve_for_turn(None)
+            .context("builtin model catalog does not contain a visible onboarding model")?;
+        ResolvedProviderSettings {
+            provider: fallback_model.provider_family,
+            model: fallback_model.slug.clone(),
+            base_url: None,
+            api_key: None,
+        }
+    } else {
+        resolve_provider_settings()
+            .with_context(|| "failed to resolve provider settings outside onboarding mode")?
+    };
+    Ok((onboarding_mode, resolved))
 }
 
 fn server_env_overrides(resolved: &clawcr_core::ResolvedProviderSettings) -> Vec<(String, String)> {
@@ -76,3 +96,36 @@ fn server_env_overrides(resolved: &clawcr_core::ResolvedProviderSettings) -> Vec
     }
     env
 }
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::resolve_initial_provider_settings;
+    use clawcr_core::{Model, PresetModelCatalog, ProviderConfigFile};
+    use clawcr_protocol::ProviderFamily;
+
+    fn test_catalog() -> PresetModelCatalog {
+        PresetModelCatalog::new(vec![Model {
+            slug: "test-onboard-model".to_string(),
+            provider_family: ProviderFamily::OpenAI,
+            ..Model::default()
+        }])
+    }
+
+    #[test]
+    fn resolve_initial_provider_settings_uses_catalog_fallback_during_onboarding() {
+        let (onboarding_mode, resolved) = resolve_initial_provider_settings(
+            false,
+            &ProviderConfigFile::default(),
+            &test_catalog(),
+        )
+        .expect("resolve initial provider settings");
+
+        assert!(onboarding_mode);
+        assert_eq!(resolved.provider, ProviderFamily::OpenAI);
+        assert_eq!(resolved.model, "test-onboard-model");
+        assert_eq!(resolved.base_url, None);
+        assert_eq!(resolved.api_key, None);
+    }
+}

crates/cli/src/main.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use clap::{Parser, Subcommand};
+use clap::{Parser, Subcommand, ValueEnum};
 use clawcr_core::{
     AppConfig, AppConfigLoader, FileSystemAppConfigLoader, LoggingBootstrap, LoggingRuntime,
 };
@@ -21,6 +21,10 @@ struct Cli {
     /// Keep the UI in the main terminal buffer instead of switching to the alternate screen.
     #[arg(long = "no-alt-screen", default_value_t = false)]
     no_alt_screen: bool,
+
+    /// Override the logging level for this process.
+    #[arg(long = "log-level", global = true, value_enum)]
+    log_level: Option<LogLevel>,
 }
 
 #[tokio::main]
@@ -30,19 +34,23 @@ async fn main() -> Result<()> {
 
     match cli.command {
         Some(Command::Server(args)) => run_server_process(args).await,
+        Some(Command::Onboard) => run_agent(true, cli.no_alt_screen).await,
         None => run_agent(false, cli.no_alt_screen).await,
     }
 }
 
 #[derive(Debug, Subcommand)]
 enum Command {
+    /// Launch the interactive onboarding flow to configure a model provider.
+    Onboard,
     /// Start the transport-facing server runtime.
     Server(ServerProcessArgs),
 }
 
 fn install_logging(cli: &Cli) -> Result<LoggingRuntime> {
     let home_dir = find_clawcr_home()?;
-    let loader = FileSystemAppConfigLoader::new(home_dir.clone());
+    let loader = FileSystemAppConfigLoader::new(home_dir.clone())
+        .with_cli_overrides(cli_logging_overrides(cli));
     let current_dir = std::env::current_dir()?;
     let workspace_root = match &cli.command {
         Some(Command::Server(args)) => args.working_root.as_deref(),
@@ -61,18 +69,56 @@ fn install_logging(cli: &Cli) -> Result<LoggingRuntime> {
     .map_err(Into::into)
 }
 
+fn cli_logging_overrides(cli: &Cli) -> toml::Value {
+    let Some(log_level) = cli.log_level else {
+        return toml::Value::Table(Default::default());
+    };
+
+    toml::Value::Table(toml::map::Map::from_iter([(
+        "logging".to_string(),
+        toml::Value::Table(toml::map::Map::from_iter([(
+            "level".to_string(),
+            toml::Value::String(log_level.as_str().to_string()),
+        )])),
+    )]))
+}
+
 fn logging_process_name(command: &Option<Command>) -> &'static str {
     match command {
+        Some(Command::Onboard) => "onboard",
         Some(Command::Server(_)) => "server",
         None => "cli",
     }
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
+enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl LogLevel {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Error => "error",
+            Self::Warn => "warn",
+            Self::Info => "info",
+            Self::Debug => "debug",
+            Self::Trace => "trace",
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use pretty_assertions::assert_eq;
 
-    use super::{Command, ServerProcessArgs, logging_process_name};
+    use super::{
+        Cli, Command, LogLevel, ServerProcessArgs, cli_logging_overrides, logging_process_name,
+    };
 
     #[test]
     fn logging_process_name_defaults_to_cli() {
@@ -88,4 +134,43 @@ mod tests {
             "server"
         );
     }
+
+    #[test]
+    fn logging_process_name_uses_onboard_for_onboard_subcommand() {
+        assert_eq!(logging_process_name(&Some(Command::Onboard)), "onboard");
+    }
+
+    #[test]
+    fn cli_logging_overrides_is_empty_without_log_level() {
+        let cli = Cli {
+            command: None,
+            no_alt_screen: false,
+            log_level: None,
+        };
+
+        assert_eq!(
+            cli_logging_overrides(&cli),
+            toml::Value::Table(Default::default())
+        );
+    }
+
+    #[test]
+    fn cli_logging_overrides_sets_logging_level() {
+        let cli = Cli {
+            command: None,
+            no_alt_screen: false,
+            log_level: Some(LogLevel::Debug),
+        };
+
+        assert_eq!(
+            cli_logging_overrides(&cli),
+            toml::Value::Table(toml::map::Map::from_iter([(
+                "logging".to_string(),
+                toml::Value::Table(toml::map::Map::from_iter([(
+                    "level".to_string(),
+                    toml::Value::String("debug".to_string()),
+                )])),
+            )]))
+        );
+    }
 }