Improve onboarding UX and several bugs & glitches (#115)

Author: stippi

crates/code_assistant/src/acp/ui.rs

@@ -821,6 +821,9 @@ impl UserInterface for ACPUserUI {
             UiEvent::PersistUiState => {
                 // GPUI-specific, not applicable to ACP UI
             }
+            UiEvent::ConfigChanged => {
+                // Config file changes not relevant in ACP mode
+            }
         }
         Ok(())
     }

crates/code_assistant/src/agent/runner.rs

@@ -1255,10 +1255,10 @@ impl Agent {
     fn read_guidance_files(&self) -> Vec<(String, String)> {
         let mut guidance_files = Vec::new();
 
-        if let Some(config_dir) = dirs::home_dir().map(|home| home.join(".config/code-assistant")) {
-            if let Some((_, content)) = Self::read_guidance_from_dir(&config_dir, &["AGENTS.md"]) {
-                guidance_files.push(("~/.config/code-assistant/AGENTS.md".to_string(), content));
-            }
+        let config_dir = crate::config_dir::config_dir();
+        if let Some((_, content)) = Self::read_guidance_from_dir(&config_dir, &["AGENTS.md"]) {
+            let label = format!("{}/AGENTS.md", config_dir.display());
+            guidance_files.push((label, content));
         }
 
         // Determine search root from effective_project_path (worktree or init_path),

crates/code_assistant/src/app/gpui.rs

@@ -18,16 +18,13 @@ pub fn run(config: AgentRunConfig) -> Result<()> {
     let (backend_event_rx, backend_response_tx) = gui.setup_backend_communication();
 
     // Setup dynamic types for MultiSessionManager
-    let root_path = config.path.canonicalize()?;
     let persistence = crate::persistence::FileSessionPersistence::new();
 
+    // In GPUI mode, don't use the current directory as default session path.
+    // Sessions are project-based and get their path from the sidebar/projects.json.
     let session_config_template = SessionConfig {
-        init_path: Some(root_path.clone()),
-        initial_project: root_path
-            .file_name()
-            .and_then(|name| name.to_str())
-            .unwrap_or("unknown")
-            .to_string(),
+        init_path: None,
+        initial_project: String::new(),
         tool_syntax: config.tool_syntax,
         use_diff_blocks: config.use_diff_format,
         sandbox_policy: config.sandbox_policy.clone(),
@@ -156,41 +153,10 @@ pub fn run(config: AgentRunConfig) -> Result<()> {
                         }
                     }
                 } else {
-                    info!("No existing sessions found - creating a new session automatically");
-
-                    // Create a new session automatically
-                    let new_session_id = {
-                        let mut manager = multi_session_manager.lock().await;
-                        manager
-                            .create_session_with_config(None, None, Some(base_model_config.clone()))
-                            .unwrap_or_else(|e| {
-                                error!("Failed to create new session: {}", e);
-                                // Return a fallback session ID if creation fails
-                                "fallback".to_string()
-                            })
-                    };
-
-                    if new_session_id != "fallback" {
-                        debug!("Created new session: {}", new_session_id);
-
-                        // Connect to the newly created session
-                        let ui_events = {
-                            let mut manager = multi_session_manager.lock().await;
-                            manager
-                                .set_active_session(new_session_id.clone())
-                                .await
-                                .unwrap_or_else(|e| {
-                                    error!("Failed to set active session: {}", e);
-                                    Vec::new()
-                                })
-                        };
-
-                        for event in ui_events {
-                            if let Err(e) = gui_for_thread.send_event(event).await {
-                                error!("Failed to send UI event: {}", e);
-                            }
-                        }
-                    }
+                    info!("No existing sessions found - showing empty state (no session view)");
+                    // In GPUI mode, don't auto-create a session. The user can
+                    // create one from the sidebar. The MessagesView will render
+                    // the "no session" hint since no session is connected.
                 }
             }
 

crates/code_assistant/src/cli.rs

@@ -71,6 +71,10 @@ pub struct Args {
     #[command(subcommand)]
     pub mode: Option<Mode>,
 
+    /// Override configuration directory (where models.json, providers.json, etc. live)
+    #[arg(long)]
+    pub config_dir: Option<PathBuf>,
+
     /// Path to the code directory to analyze
     #[arg(long, default_value = ".")]
     pub path: PathBuf,
@@ -138,6 +142,11 @@ impl Args {
     }
 
     /// Resolve a model name, ensuring it exists in the configuration and providing a fallback.
+    ///
+    /// Resolution order:
+    /// 1. Explicit `--model` CLI argument
+    /// 2. Persisted `default_model` from ui-settings.json
+    /// 3. First model alphabetically from models.json
     pub fn resolve_model_name(model: Option<String>) -> anyhow::Result<String> {
         let config = ConfigurationSystem::load()?;
 
@@ -170,14 +179,15 @@ impl Args {
             );
         }
 
-        // Look for common model names as defaults
-        let preferred_defaults = ["Claude Sonnet 4.5", "GPT-5", "Claude Opus 4", "GPT-4.1"];
-        for default in &preferred_defaults {
-            if models.iter().any(|entry| entry == default) {
-                return Ok(default.to_string());
+        // Check persisted default model from settings
+        let settings = crate::ui::gpui::settings::UiSettings::load();
+        if let Some(ref default_model) = settings.default_model {
+            if config.get_model(default_model).is_some() {
+                return Ok(default_model.clone());
             }
         }
 
+        // Fallback: first model alphabetically
         models.sort();
         Ok(models
             .first()

crates/code_assistant/src/config.rs

@@ -8,9 +8,7 @@ use std::sync::Arc;
 
 /// Get the path to the configuration file
 pub fn get_config_path() -> Result<PathBuf> {
-    let home =
-        dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
-    let config_dir = home.join(".config").join("code-assistant");
+    let config_dir = crate::config_dir::config_dir();
     std::fs::create_dir_all(&config_dir)?; // Ensure directory exists
     Ok(config_dir.join("projects.json"))
 }

crates/code_assistant/src/config_dir.rs

@@ -0,0 +1,37 @@
+//! Central configuration directory resolution.
+//!
+//! All config files (models.json, providers.json, tools.json, projects.json,
+//! ui-settings.json) live in a single directory determined by the following
+//! priority:
+//!
+//! 1. `--config-dir` CLI argument (sets `CODE_ASSISTANT_CONFIG_DIR` env var)
+//! 2. `CODE_ASSISTANT_CONFIG_DIR` environment variable
+//! 3. `$XDG_CONFIG_HOME/code-assistant`
+//! 4. `~/.config/code-assistant`
+
+use std::path::PathBuf;
+
+/// Returns the canonical configuration directory.
+///
+/// This is the single source of truth for where config files live.
+pub fn config_dir() -> PathBuf {
+    if let Ok(custom_dir) = std::env::var("CODE_ASSISTANT_CONFIG_DIR") {
+        return PathBuf::from(custom_dir);
+    }
+    if let Ok(xdg_config) = std::env::var("XDG_CONFIG_HOME") {
+        return PathBuf::from(xdg_config).join("code-assistant");
+    }
+    if let Some(home_dir) = dirs::home_dir() {
+        return home_dir.join(".config").join("code-assistant");
+    }
+    // Last resort fallback
+    PathBuf::from("code-assistant")
+}
+
+/// Apply the `--config-dir` override by setting the environment variable.
+///
+/// Must be called early in main, before any config loading happens.
+/// The env var is picked up by all config resolution code (including the `llm` crate).
+pub fn apply_override(path: &PathBuf) {
+    std::env::set_var("CODE_ASSISTANT_CONFIG_DIR", path);
+}

crates/code_assistant/src/main.rs

@@ -4,6 +4,7 @@ mod app;
 mod cli;
 mod codex_commands;
 mod config;
+mod config_dir;
 mod logging;
 mod mcp;
 mod permissions;
@@ -25,6 +26,11 @@ use anyhow::Result;
 async fn main() -> Result<()> {
     let args = Args::parse();
 
+    // Apply config-dir override before anything loads config files
+    if let Some(ref dir) = args.config_dir {
+        config_dir::apply_override(dir);
+    }
+
     // Handle list commands first
     if args.handle_list_commands()? {
         return Ok(());
@@ -87,7 +93,13 @@ async fn main() -> Result<()> {
                 anyhow::bail!("Path '{}' is not a directory", args.path.display());
             }
 
-            let model_name = args.get_model_name()?;
+            // In GUI mode, allow starting without a valid model config
+            // (the settings screen will guide the user through setup).
+            let model_name = if args.ui {
+                args.get_model_name().unwrap_or_default()
+            } else {
+                args.get_model_name()?
+            };
             let sandbox_policy = args.sandbox_policy();
 
             let config = app::AgentRunConfig {

crates/code_assistant/src/session/manager.rs

@@ -95,6 +95,11 @@ impl SessionManager {
         SessionModelConfig::new(self.default_model_name.clone())
     }
 
+    /// Update the default model name used for newly created sessions.
+    pub fn set_default_model_name(&mut self, model_name: String) {
+        self.default_model_name = model_name;
+    }
+
     /// Create a new session with optional model config and return its ID
     pub fn create_session_with_config(
         &mut self,

crates/code_assistant/src/session/watcher.rs

@@ -49,6 +49,7 @@ const DEBOUNCE_DURATION: Duration = Duration::from_millis(300);
 /// Dropping this stops the watcher.
 pub struct SessionWatcher {
     _watcher: RecommendedWatcher,
+    _config_watcher: Option<RecommendedWatcher>,
 }
 
 /// Categorised dirty-file set, accumulated between debounce flushes.
@@ -97,11 +98,82 @@ impl SessionWatcher {
         rt.spawn(flush_loop(
             dirty,
             sessions_dir,
-            event_tx,
+            event_tx.clone(),
             current_session_id,
         ));
 
-        Ok(Self { _watcher: watcher })
+        // --- config file watcher ---
+        let config_watcher = Self::start_config_watcher(event_tx, &rt);
+
+        Ok(Self {
+            _watcher: watcher,
+            _config_watcher: config_watcher,
+        })
+    }
+
+    /// Start a separate watcher for the config directory (providers.json, models.json).
+    fn start_config_watcher(
+        event_tx: async_channel::Sender<UiEvent>,
+        rt: &tokio::runtime::Handle,
+    ) -> Option<RecommendedWatcher> {
+        let config_path = llm::provider_config::ConfigurationSystem::providers_config_path();
+        let config_dir = config_path.parent()?.to_path_buf();
+
+        if !config_dir.exists() {
+            debug!("Config directory does not exist yet, skipping config watcher");
+            return None;
+        }
+
+        debug!("Starting config file watcher on {}", config_dir.display());
+
+        let config_dirty = Arc::new(Mutex::new(false));
+        let config_dirty_for_callback = config_dirty.clone();
+
+        let mut watcher =
+            match notify::recommended_watcher(move |res: Result<Event, notify::Error>| match res {
+                Ok(event) => {
+                    for path in &event.paths {
+                        if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                            if name == "providers.json" || name == "models.json" {
+                                trace!("Config watcher: {name} changed ({:?})", event.kind);
+                                *config_dirty_for_callback.lock().unwrap() = true;
+                            }
+                        }
+                    }
+                }
+                Err(e) => warn!("Config watcher error: {e}"),
+            }) {
+                Ok(w) => w,
+                Err(e) => {
+                    warn!("Failed to create config watcher: {e}");
+                    return None;
+                }
+            };
+
+        if let Err(e) = watcher.watch(&config_dir, RecursiveMode::NonRecursive) {
+            warn!("Failed to watch config directory: {e}");
+            return None;
+        }
+
+        // Debounce flush for config changes
+        let event_tx = event_tx.clone();
+        rt.spawn(async move {
+            loop {
+                tokio::time::sleep(DEBOUNCE_DURATION).await;
+                let dirty = {
+                    let mut flag = config_dirty.lock().unwrap();
+                    let was_dirty = *flag;
+                    *flag = false;
+                    was_dirty
+                };
+                if dirty {
+                    debug!("Config watcher flush: emitting ConfigChanged");
+                    let _ = event_tx.try_send(UiEvent::ConfigChanged);
+                }
+            }
+        });
+
+        Some(watcher)
     }
 }
 

crates/code_assistant/src/tools/core/config.rs

@@ -42,27 +42,7 @@ impl ToolsConfig {
 
     /// Get the path to the tools configuration file.
     pub fn config_path() -> Result<PathBuf> {
-        // Use the same config directory as other code-assistant configs
-        let config_dir = Self::config_directory()?;
-        Ok(config_dir.join("tools.json"))
-    }
-
-    /// Get the configuration directory.
-    fn config_directory() -> Result<PathBuf> {
-        // Check for custom config directory first
-        if let Ok(custom_dir) = std::env::var("CODE_ASSISTANT_CONFIG_DIR") {
-            return Ok(PathBuf::from(custom_dir));
-        }
-
-        // Check XDG_CONFIG_HOME
-        if let Ok(xdg_config) = std::env::var("XDG_CONFIG_HOME") {
-            return Ok(PathBuf::from(xdg_config).join("code-assistant"));
-        }
-
-        // Fall back to ~/.config/code-assistant
-        let home = dirs::home_dir()
-            .ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
-        Ok(home.join(".config").join("code-assistant"))
+        Ok(crate::config_dir::config_dir().join("tools.json"))
     }
 
     /// Substitute environment variables in configuration values.