feat(cli): implement CLI improvements from open PRs (#181)

This commit implements improvements from multiple CLI-related PRs:

1. PR #137: Use consistent provider name casing in models output
   - Removed .to_uppercase() call to keep provider names in lowercase

2. PR #135: Add --log-level flag for granular log verbosity control
   - Added LogLevel enum with error, warn, info, debug, trace levels
   - Support for FABRIC_LOG_LEVEL environment variable
   - Deprecated --debug flag (still works for backward compatibility)

3. PR #147: Display timestamps with timezone suffix
   - Sessions list now shows timestamps in "YYYY-MM-DD HH:MM:SS UTC" format
   - Makes timezone unambiguous for team collaboration

4. PR #153: Emit valid JSONL with full event data in streaming mode
   - Serialize full event using serde with proper type tags
   - Include complete event payload data (text deltas, tool call info)

5. PR #138: Add model alias shortcuts for common models
   - Added ModelAlias struct and MODEL_ALIASES constant
   - resolve_model_alias() function for short name resolution
   - Supported aliases: sonnet, opus, haiku, gpt4, gpt, o1, o3, codex,
     gemini, deepseek, r1, llama
   - Case-insensitive matching

6. PR #139: Pass CLI temperature override to session
   - Added temperature field to Config and ConfigOverrides
   - Modified session.rs to use config.temperature instead of hardcoded 0.7
   - Temperature can be set via cortex run --temperature flag

Also includes formatting improvements from cargo fmt.

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

cortex-cli/src/login.rs

@@ -148,7 +148,9 @@ pub async fn run_logout(config_overrides: CliConfigOverrides) -> ! {
         Ok(Some(_)) => {
             // User is logged in, ask for confirmation if terminal is interactive
             if std::io::stdin().is_terminal() {
-                eprint!("Are you sure you want to log out? This will remove your stored credentials. [y/N]: ");
+                eprint!(
+                    "Are you sure you want to log out? This will remove your stored credentials. [y/N]: "
+                );
                 let _ = std::io::Write::flush(&mut std::io::stderr());
 
                 let mut input = String::new();

cortex-cli/src/main.rs

@@ -9,7 +9,7 @@
 //! - Debug sandbox commands
 //! - Shell completions
 
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::{Args, CommandFactory, Parser, Subcommand};
 use clap_complete::{Shell, generate};
 use std::io;
@@ -36,6 +36,50 @@ use cortex_cli::upgrade_cmd::UpgradeCli;
 use cortex_cli::{LandlockCommand, SeatbeltCommand, WindowsCommand};
 use cortex_common::CliConfigOverrides;
 
+/// Log verbosity level for CLI output.
+///
+/// Controls the amount of logging detail shown. Can also be set via
+/// the FABRIC_LOG_LEVEL environment variable.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, clap::ValueEnum)]
+pub enum LogLevel {
+    /// Only show errors
+    Error,
+    /// Show warnings and errors
+    Warn,
+    /// Show informational messages, warnings, and errors (default)
+    #[default]
+    Info,
+    /// Show debug messages and above
+    Debug,
+    /// Show all messages including trace-level details
+    Trace,
+}
+
+impl LogLevel {
+    /// Convert to tracing filter string
+    fn as_filter_str(&self) -> &'static str {
+        match self {
+            LogLevel::Error => "error",
+            LogLevel::Warn => "warn",
+            LogLevel::Info => "info",
+            LogLevel::Debug => "debug",
+            LogLevel::Trace => "trace",
+        }
+    }
+
+    /// Parse from string (case-insensitive)
+    fn from_str_loose(s: &str) -> Option<LogLevel> {
+        match s.to_lowercase().as_str() {
+            "error" => Some(LogLevel::Error),
+            "warn" | "warning" => Some(LogLevel::Warn),
+            "info" => Some(LogLevel::Info),
+            "debug" => Some(LogLevel::Debug),
+            "trace" => Some(LogLevel::Trace),
+            _ => None,
+        }
+    }
+}
+
 /// Cortex CLI - AI Coding Agent
 ///
 /// If no subcommand is specified, starts the interactive TUI.
@@ -131,8 +175,13 @@ struct InteractiveArgs {
     #[arg(long = "image", short = 'i', value_delimiter = ',', num_args = 1..)]
     images: Vec<PathBuf>,
 
-    /// Working directory
-    #[arg(long)]
+    /// Set log verbosity level (error, warn, info, debug, trace)
+    /// Can also be set via FABRIC_LOG_LEVEL environment variable
+    #[arg(long = "log-level", short = 'L', value_enum, default_value = "info")]
+    log_level: LogLevel,
+
+    /// Enable debug logging (deprecated: use --log-level debug instead)
+    #[arg(long, hide = true)]
     debug: bool,
 
     /// Initial prompt (if no subcommand)
@@ -449,12 +498,19 @@ async fn main() -> Result<()> {
     // Initialize logging only for non-TUI commands
     // TUI mode has its own file-based logging to avoid stdout pollution
     if cli.command.is_some() {
+        // Determine log level with precedence: --debug flag > --log-level > FABRIC_LOG_LEVEL env > default (info)
         let log_level = if cli.interactive.debug {
-            "debug"
+            // Deprecated --debug flag takes precedence for backward compatibility
+            LogLevel::Debug
+        } else if let Ok(env_level) = std::env::var("FABRIC_LOG_LEVEL") {
+            // Check environment variable
+            LogLevel::from_str_loose(&env_level).unwrap_or(cli.interactive.log_level)
         } else {
-            "info"
+            cli.interactive.log_level
         };
-        tracing_subscriber::fmt().with_env_filter(log_level).init();
+        tracing_subscriber::fmt()
+            .with_env_filter(log_level.as_filter_str())
+            .init();
     }
 
     // Background update check (non-blocking, runs in parallel with command execution)
@@ -514,7 +570,9 @@ async fn main() -> Result<()> {
         Some(Commands::Mcp(mcp_cli)) => mcp_cli.run().await,
         Some(Commands::Agent(agent_cli)) => agent_cli.run().await,
         Some(Commands::McpServer) => {
-            bail!("MCP server mode is not yet implemented. Use 'cortex mcp' for MCP server management.");
+            bail!(
+                "MCP server mode is not yet implemented. Use 'cortex mcp' for MCP server management."
+            );
         }
         Some(Commands::Completion(completion_cli)) => {
             generate_completions(completion_cli.shell);
@@ -562,8 +620,15 @@ async fn main() -> Result<()> {
 }
 
 async fn run_tui(initial_prompt: Option<String>, args: &InteractiveArgs) -> Result<()> {
+    use cortex_common::resolve_model_alias;
+
     let mut config = cortex_engine::Config::default();
 
+    // Apply model override if specified, resolving alias (e.g., "sonnet" -> "anthropic/claude-sonnet-4-20250514")
+    if let Some(ref model) = args.model {
+        config.model = resolve_model_alias(model).to_string();
+    }
+
     // Apply working directory override if specified
     if let Some(ref cwd) = args.cwd {
         let cwd_path = if cwd.is_absolute() {
@@ -982,9 +1047,15 @@ async fn list_sessions(
 
     for session in display_sessions.iter().take(15) {
         let model = session.model.as_deref().unwrap_or("unknown");
-        let date = if session.timestamp.len() >= 19 {
-            session.timestamp[..19].replace('T', " ")
+        // Display timestamp in ISO8601 format with UTC timezone suffix for clarity
+        let date = if let Ok(parsed) = chrono::DateTime::parse_from_rfc3339(&session.timestamp) {
+            // Format as "YYYY-MM-DD HH:MM:SS UTC" for unambiguous timezone
+            parsed
+                .with_timezone(&chrono::Utc)
+                .format("%Y-%m-%d %H:%M:%S UTC")
+                .to_string()
         } else {
+            // Fallback: use raw timestamp (already includes timezone info)
             session.timestamp.clone()
         };
 

cortex-cli/src/models_cmd.rs

@@ -361,7 +361,7 @@ async fn run_list(provider_filter: Option<String>, json: bool) -> Result<()> {
     println!("{}", "=".repeat(80));
 
     for (provider, models) in by_provider {
-        println!("\n{} ({} models)", provider.to_uppercase(), models.len());
+        println!("\n{} ({} models)", provider, models.len());
         println!("{}", "-".repeat(40));
         println!(
             "{:<35} {:^6} {:^6} {:^8} {:^6}",

cortex-cli/src/run_cmd.rs

@@ -30,6 +30,7 @@ use std::time::Duration;
 /// Maximum file size for attachments (10MB)
 const MAX_FILE_SIZE: u64 = 10 * 1024 * 1024;
 
+use cortex_common::resolve_model_alias;
 use cortex_engine::rollout::get_rollout_path;
 use cortex_engine::{Session, list_sessions};
 use cortex_protocol::{ConversationId, EventMsg, Op, Submission, UserInput};
@@ -476,6 +477,16 @@ impl RunCli {
             config.current_agent = Some(agent_name.clone());
         }
 
+        // Resolve model alias if provided (e.g., "sonnet" -> "anthropic/claude-sonnet-4-20250514")
+        if let Some(ref model) = self.model {
+            config.model = resolve_model_alias(model).to_string();
+        }
+
+        // Apply temperature override if provided
+        if let Some(temp) = self.temperature {
+            config.temperature = Some(temp);
+        }
+
         // Initialize custom command registry if not already initialized
         let project_root = self.cwd.clone().or_else(|| std::env::current_dir().ok());
         let _custom_registry = cortex_engine::init_custom_command_registry(
@@ -622,24 +633,19 @@ impl RunCli {
 
             event_count += 1;
 
-            // Output JSON event if in JSON mode
+            // Output JSON event if in JSON mode (JSONL format with full event data)
             if is_json {
+                // Serialize the full event using serde, which properly includes all data
+                // and uses the correct type tags from the EventMsg enum's serde attributes
                 let event_json = serde_json::json!({
-                    "type": format!("{:?}", event.msg).split('(').next().unwrap_or("Unknown"),
                     "event_id": event_count,
                     "session_id": session_id,
                     "timestamp": chrono::Utc::now().to_rfc3339(),
+                    "event": event.msg,
                 });
 
-                match self.format {
-                    OutputFormat::Json => {
-                        eprintln!("{}", serde_json::to_string(&event_json)?);
-                    }
-                    OutputFormat::Jsonl => {
-                        eprintln!("{}", serde_json::to_string(&event_json)?);
-                    }
-                    _ => {}
-                }
+                // Output as a single JSON line (JSONL format)
+                println!("{}", serde_json::to_string(&event_json)?);
             }
 
             match &event.msg {

cortex-common/src/model_presets.rs

@@ -1048,3 +1048,147 @@ pub fn get_models_for_provider(provider: &str) -> Vec<&'static ModelPreset> {
         .filter(|m| m.provider == provider)
         .collect()
 }
+
+/// Model alias entry mapping a short name to a full model identifier.
+#[derive(Debug, Clone, Copy)]
+pub struct ModelAlias {
+    /// Short alias (e.g., "sonnet").
+    pub alias: &'static str,
+    /// Full model identifier (e.g., "anthropic/claude-sonnet-4-20250514").
+    pub model: &'static str,
+}
+
+/// Built-in model aliases for common shortcuts.
+pub const MODEL_ALIASES: &[ModelAlias] = &[
+    // Claude models
+    ModelAlias {
+        alias: "claude",
+        model: "anthropic/claude-opus-4.5",
+    },
+    ModelAlias {
+        alias: "opus",
+        model: "anthropic/claude-opus-4.5",
+    },
+    ModelAlias {
+        alias: "sonnet",
+        model: "anthropic/claude-sonnet-4-20250514",
+    },
+    ModelAlias {
+        alias: "haiku",
+        model: "anthropic/claude-haiku-4.5",
+    },
+    // OpenAI models
+    ModelAlias {
+        alias: "gpt4",
+        model: "openai/gpt-4o",
+    },
+    ModelAlias {
+        alias: "gpt",
+        model: "openai/gpt-4o",
+    },
+    ModelAlias {
+        alias: "o1",
+        model: "openai/o1",
+    },
+    ModelAlias {
+        alias: "o3",
+        model: "openai/o3",
+    },
+    ModelAlias {
+        alias: "codex",
+        model: "openai/gpt-5.2-codex",
+    },
+    // Google models
+    ModelAlias {
+        alias: "gemini",
+        model: "google/gemini-2.5-pro-preview-06-05",
+    },
+    // DeepSeek models
+    ModelAlias {
+        alias: "deepseek",
+        model: "deepseek/deepseek-chat",
+    },
+    ModelAlias {
+        alias: "r1",
+        model: "deepseek/deepseek-r1",
+    },
+    // Meta models
+    ModelAlias {
+        alias: "llama",
+        model: "meta-llama/llama-3.3-70b-instruct",
+    },
+];
+
+/// Resolves a model alias to its full model identifier.
+///
+/// If the input matches a known alias, returns the corresponding full model name.
+/// Otherwise, returns the input unchanged.
+///
+/// # Examples
+///
+/// ```
+/// use cortex_common::resolve_model_alias;
+///
+/// assert_eq!(resolve_model_alias("sonnet"), "anthropic/claude-sonnet-4-20250514");
+/// assert_eq!(resolve_model_alias("gpt4"), "openai/gpt-4o");
+/// assert_eq!(resolve_model_alias("unknown-model"), "unknown-model");
+/// ```
+pub fn resolve_model_alias(model: &str) -> &str {
+    MODEL_ALIASES
+        .iter()
+        .find(|a| a.alias.eq_ignore_ascii_case(model))
+        .map(|a| a.model)
+        .unwrap_or(model)
+}
+
+/// Returns a list of all available model aliases.
+pub fn list_model_aliases() -> &'static [ModelAlias] {
+    MODEL_ALIASES
+}
+
+#[cfg(test)]
+mod alias_tests {
+    use super::*;
+
+    #[test]
+    fn test_resolve_model_alias_known() {
+        assert_eq!(
+            resolve_model_alias("sonnet"),
+            "anthropic/claude-sonnet-4-20250514"
+        );
+        assert_eq!(resolve_model_alias("opus"), "anthropic/claude-opus-4.5");
+        assert_eq!(resolve_model_alias("gpt4"), "openai/gpt-4o");
+        assert_eq!(resolve_model_alias("haiku"), "anthropic/claude-haiku-4.5");
+        assert_eq!(resolve_model_alias("codex"), "openai/gpt-5.2-codex");
+        assert_eq!(resolve_model_alias("r1"), "deepseek/deepseek-r1");
+    }
+
+    #[test]
+    fn test_resolve_model_alias_case_insensitive() {
+        assert_eq!(
+            resolve_model_alias("SONNET"),
+            "anthropic/claude-sonnet-4-20250514"
+        );
+        assert_eq!(
+            resolve_model_alias("Sonnet"),
+            "anthropic/claude-sonnet-4-20250514"
+        );
+        assert_eq!(resolve_model_alias("GPT4"), "openai/gpt-4o");
+    }
+
+    #[test]
+    fn test_resolve_model_alias_unknown() {
+        assert_eq!(resolve_model_alias("unknown-model"), "unknown-model");
+        assert_eq!(
+            resolve_model_alias("anthropic/claude-3-opus"),
+            "anthropic/claude-3-opus"
+        );
+    }
+
+    #[test]
+    fn test_list_model_aliases() {
+        let aliases = list_model_aliases();
+        assert!(!aliases.is_empty());
+        assert!(aliases.iter().any(|a| a.alias == "sonnet"));
+    }
+}