feat(config): persist settings in ~/.cortex on Linux/macOS

Updated the configuration directory to use ~/.cortex on Linux/macOS
instead of ~/.config/cortex to match the convention used throughout
the codebase. This makes it easier for users to find and manage their
settings.

Changes:
- CortexConfig::config_dir() now uses ~/.cortex on Linux/macOS
- AppDirs now uses ~/.cortex as the primary location
- Added CORTEX_HOME environment variable override support
- Updated legacy path detection to handle migration from XDG paths
- Windows still uses %APPDATA%\cortex

The last_model and last_provider are already persisted via the
save_last_model() function whenever a model is changed.

Author: factorydroid

cortex-common/src/dirs.rs

@@ -1,34 +1,33 @@
 //! Cross-platform application directories for Cortex CLI.
 //!
 //! Provides unified directory management following platform conventions:
-//! - Linux: XDG Base Directory Specification (~/.config/cortex, ~/.local/share/cortex, ~/.cache/cortex)
-//! - macOS: XDG-style for CLI tools (~/.config/cortex) - matches gh, aws, cargo behavior
-//! - Windows: %APPDATA%\cortex
+//! - Linux/macOS: `~/.cortex` (simple, easy to find)
+//! - Windows: `%APPDATA%\cortex`
+//!
+//! Can be overridden with `CORTEX_HOME` environment variable.
 
 use std::path::PathBuf;
 
 /// Application name for directory paths
 pub const APP_NAME: &str = "cortex";
 
-/// Legacy directory name (for migration)
-pub const LEGACY_APP_NAME: &str = ".cortex";
+/// Primary home directory name on Linux/macOS
+pub const HOME_DIR_NAME: &str = ".cortex";
 
-/// Old cortex directory name (for migration)
-pub const CORTEX_LEGACY_NAME: &str = ".cortex";
+/// Legacy directory name (for migration from XDG paths)
+pub const LEGACY_XDG_NAME: &str = ".config/cortex";
 
 /// Application directories structure
 #[derive(Debug, Clone)]
 pub struct AppDirs {
-    /// Configuration directory (~/.config/cortex on Linux/macOS, %APPDATA%\cortex on Windows)
+    /// Configuration directory (~/.cortex on Linux/macOS, %APPDATA%\cortex on Windows)
     pub config_dir: PathBuf,
-    /// Data directory (~/.local/share/cortex on Linux/macOS, %APPDATA%\cortex on Windows)
+    /// Data directory (same as config_dir for simplicity)
     pub data_dir: PathBuf,
-    /// Cache directory (~/.cache/cortex on Linux/macOS, %LOCALAPPDATA%\cortex on Windows)
+    /// Cache directory (~/.cortex/cache on Linux/macOS, %LOCALAPPDATA%\cortex on Windows)
     pub cache_dir: PathBuf,
-    /// Legacy home directory (~/.cortex) for migration
-    pub legacy_home: PathBuf,
-    /// Old cortex directory (~/.cortex) for migration
-    pub cortex_legacy: PathBuf,
+    /// Legacy XDG home directory (~/.config/cortex) for migration
+    pub legacy_xdg_home: PathBuf,
 }
 
 impl AppDirs {
@@ -40,20 +39,19 @@ impl AppDirs {
     /// - `CORTEX_DATA_DIR`: Override data directory only
     /// - `CORTEX_CACHE_DIR`: Override cache directory only
     pub fn new() -> Option<Self> {
+        let home_dir = dirs::home_dir()?;
+
         // Check for CORTEX_HOME override first
         if let Ok(home) = std::env::var("CORTEX_HOME") {
             let home = PathBuf::from(home);
             return Some(Self {
                 config_dir: home.clone(),
                 data_dir: home.clone(),
-                cache_dir: home.clone(),
-                legacy_home: dirs::home_dir()?.join(LEGACY_APP_NAME),
-                cortex_legacy: dirs::home_dir()?.join(CORTEX_LEGACY_NAME),
+                cache_dir: home.join("cache"),
+                legacy_xdg_home: home_dir.join(LEGACY_XDG_NAME),
             });
         }
 
-        let home_dir = dirs::home_dir()?;
-
         // Platform-specific defaults
         #[cfg(target_os = "windows")]
         let (config_dir, data_dir, cache_dir) = {
@@ -68,20 +66,12 @@ impl AppDirs {
 
         #[cfg(not(target_os = "windows"))]
         let (config_dir, data_dir, cache_dir) = {
-            // XDG-style for both Linux and macOS (CLI convention)
-            let xdg_config = std::env::var("XDG_CONFIG_HOME")
-                .map(PathBuf::from)
-                .unwrap_or_else(|_| home_dir.join(".config"));
-            let xdg_data = std::env::var("XDG_DATA_HOME")
-                .map(PathBuf::from)
-                .unwrap_or_else(|_| home_dir.join(".local").join("share"));
-            let xdg_cache = std::env::var("XDG_CACHE_HOME")
-                .map(PathBuf::from)
-                .unwrap_or_else(|_| home_dir.join(".cache"));
+            // Use ~/.cortex for Linux/macOS (simple, easy to find)
+            let cortex_home = home_dir.join(HOME_DIR_NAME);
             (
-                xdg_config.join(APP_NAME),
-                xdg_data.join(APP_NAME),
-                xdg_cache.join(APP_NAME),
+                cortex_home.clone(),
+                cortex_home.clone(),
+                cortex_home.join("cache"),
             )
         };
 
@@ -100,8 +90,7 @@ impl AppDirs {
             config_dir,
             data_dir,
             cache_dir,
-            legacy_home: home_dir.join(LEGACY_APP_NAME),
-            cortex_legacy: home_dir.join(CORTEX_LEGACY_NAME),
+            legacy_xdg_home: home_dir.join(LEGACY_XDG_NAME),
         })
     }
 
@@ -145,20 +134,18 @@ impl AppDirs {
         Ok(())
     }
 
-    /// Check if legacy directories exist and need migration
+    /// Check if legacy XDG directories exist and need migration
     pub fn has_legacy_data(&self) -> bool {
-        self.legacy_home.exists() || self.cortex_legacy.exists()
+        self.legacy_xdg_home.exists()
     }
 
     /// Get the effective home directory (for backward compatibility)
-    /// Prefers new XDG location, falls back to legacy if it exists
+    /// Prefers new ~/.cortex location, falls back to legacy XDG if it exists
     pub fn effective_home(&self) -> PathBuf {
         if self.config_dir.exists() {
             self.config_dir.clone()
-        } else if self.legacy_home.exists() {
-            self.legacy_home.clone()
-        } else if self.cortex_legacy.exists() {
-            self.cortex_legacy.clone()
+        } else if self.legacy_xdg_home.exists() {
+            self.legacy_xdg_home.clone()
         } else {
             self.config_dir.clone()
         }

cortex-tui/src/providers/config.rs

@@ -207,16 +207,28 @@ impl Default for CortexConfig {
 
 impl CortexConfig {
     /// Gets the Cortex configuration directory.
+    ///
+    /// Uses platform-specific conventions:
+    /// - Linux/macOS: `~/.cortex`
+    /// - Windows: `%APPDATA%\cortex`
+    ///
+    /// Can be overridden with the `CORTEX_HOME` environment variable.
     pub fn config_dir() -> Result<PathBuf> {
+        // Check for CORTEX_HOME override first
+        if let Ok(home) = std::env::var("CORTEX_HOME") {
+            return Ok(PathBuf::from(home));
+        }
+
         let config_dir = if cfg!(windows) {
+            // Windows: %APPDATA%\cortex
             dirs::config_dir()
                 .context("Could not find config directory")?
                 .join("cortex")
         } else {
+            // Linux/macOS: ~/.cortex
             dirs::home_dir()
                 .context("Could not find home directory")?
-                .join(".config")
-                .join("cortex")
+                .join(".cortex")
         };
         Ok(config_dir)
     }