feat(cortex-cli): implement 10 additional open PR features (#185) (#185)

This commit implements the following open PRs for cortex-cli:

1. PR #117 - Validate --days parameter range (1-3650)
   - Added value_parser to validate days is within 1-3650 range
   - Provides clear error messages for invalid values

2. PR #120 - Add pricing information to models --json output
   - Added input_cost_per_million and output_cost_per_million fields
   - Populated pricing for all cloud-hosted models
   - Local Ollama models show null (no API cost)

3. PR #121 - Add --compact flag for minified JSON config output
   - Added --compact flag to config command (requires --json)
   - Outputs single-line JSON instead of pretty-printed

4. PR #123 - Add explanation for Native field in agent show output
   - Changed from 'Native: true/false' to 'Native: yes/no (explanation)'
   - Shows 'built-in agent bundled with Cortex' or 'user-defined agent'

5. PR #125 - Add --diff flag to debug config command
   - Compares local project config with global config
   - Shows lines unique to each config and unified diff
   - Supports JSON output format

6. PR #128 - Display helpful error when running in non-TTY context
   - Checks for terminal support before starting TUI
   - Provides guidance to use 'cortex run <prompt>' for non-interactive use

7. PR #131 - Add help text explaining -- separator for mcp add command
   - Added after_help with examples showing correct usage
   - Explains the -- separator requirement for stdio servers

8. PR #132 - Defer success message until config write succeeds
   - Success messages now only print after std::fs::write() succeeds
   - Prevents misleading output when config write fails

9. PR #119 - Add OAuth authentication status column to mcp list output
   - Added 'Auth' column showing authentication status for HTTP servers
   - Stdio servers display 'N/A' (OAuth only applies to HTTP)

10. PR #116 - Return non-zero exit code when github status detects missing workflow
    - Now exits with code 1 if workflow is not installed
    - Works for both human-readable and JSON output modes

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

Author: echobt

cortex-cli/src/agent_cmd.rs

@@ -810,7 +810,15 @@ async fn run_show(args: ShowArgs) -> Result<()> {
 
     println!("Mode: {}", agent.mode);
     println!("Source: {}", agent.source);
-    println!("Native: {}", agent.native);
+    println!(
+        "Native: {} ({})",
+        if agent.native { "yes" } else { "no" },
+        if agent.native {
+            "built-in agent bundled with Cortex"
+        } else {
+            "user-defined agent"
+        }
+    );
     println!("Hidden: {}", agent.hidden);
     println!(
         "Can Delegate: {} ({})",

cortex-cli/src/debug_cmd.rs

@@ -75,6 +75,10 @@ pub struct ConfigArgs {
     /// Show environment variables related to Cortex.
     #[arg(long)]
     pub env: bool,
+
+    /// Show diff between local project config and global config.
+    #[arg(long)]
+    pub diff: bool,
 }
 
 /// Config debug output.
@@ -223,9 +227,176 @@ async fn run_config(args: ConfigArgs) -> Result<()> {
         }
     }
 
+    // Handle --diff flag: compare local and global configs
+    if args.diff {
+        println!();
+        println!("Config Diff (Global vs Local)");
+        println!("{}", "=".repeat(50));
+
+        let global_path = config.fabric_home.join("config.toml");
+        let local_path = std::env::current_dir()
+            .ok()
+            .map(|d| d.join(".cortex/config.toml"));
+
+        let global_content = if global_path.exists() {
+            std::fs::read_to_string(&global_path).ok()
+        } else {
+            None
+        };
+
+        let local_content = local_path.as_ref().and_then(|p| {
+            if p.exists() {
+                std::fs::read_to_string(p).ok()
+            } else {
+                None
+            }
+        });
+
+        match (global_content.as_ref(), local_content.as_ref()) {
+            (None, None) => {
+                println!("  No config files found.");
+            }
+            (Some(global), None) => {
+                println!("  Only global config exists.");
+                if args.json {
+                    let diff_output = serde_json::json!({
+                        "global_only": true,
+                        "local_only": false,
+                        "differences": [],
+                    });
+                    println!("{}", serde_json::to_string_pretty(&diff_output)?);
+                }
+            }
+            (None, Some(local)) => {
+                println!("  Only local config exists.");
+                if args.json {
+                    let diff_output = serde_json::json!({
+                        "global_only": false,
+                        "local_only": true,
+                        "differences": [],
+                    });
+                    println!("{}", serde_json::to_string_pretty(&diff_output)?);
+                }
+            }
+            (Some(global), Some(local)) => {
+                if global == local {
+                    println!("  Configs are identical.");
+                } else {
+                    let diff = compute_config_diff(global, local);
+                    if args.json {
+                        println!("{}", serde_json::to_string_pretty(&diff)?);
+                    } else {
+                        println!();
+                        if !diff.only_in_global.is_empty() {
+                            println!("Lines only in global config:");
+                            for line in &diff.only_in_global {
+                                println!("  - {}", line);
+                            }
+                            println!();
+                        }
+                        if !diff.only_in_local.is_empty() {
+                            println!("Lines only in local config:");
+                            for line in &diff.only_in_local {
+                                println!("  + {}", line);
+                            }
+                            println!();
+                        }
+                        if !diff.unified_diff.is_empty() {
+                            println!("Unified diff:");
+                            println!("{}", diff.unified_diff);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     Ok(())
 }
 
+/// Result of comparing two config files.
+#[derive(Debug, Serialize)]
+struct ConfigDiff {
+    only_in_global: Vec<String>,
+    only_in_local: Vec<String>,
+    unified_diff: String,
+}
+
+/// Compute diff between two config file contents.
+fn compute_config_diff(global: &str, local: &str) -> ConfigDiff {
+    use std::collections::HashSet;
+
+    let global_lines: HashSet<&str> = global.lines().filter(|l| !l.trim().is_empty()).collect();
+    let local_lines: HashSet<&str> = local.lines().filter(|l| !l.trim().is_empty()).collect();
+
+    let only_in_global: Vec<String> = global_lines
+        .difference(&local_lines)
+        .map(|s| s.to_string())
+        .collect();
+    let only_in_local: Vec<String> = local_lines
+        .difference(&global_lines)
+        .map(|s| s.to_string())
+        .collect();
+
+    // Generate a simple unified diff
+    let unified_diff = generate_unified_diff(global, local);
+
+    ConfigDiff {
+        only_in_global,
+        only_in_local,
+        unified_diff,
+    }
+}
+
+/// Generate a simple unified diff output.
+fn generate_unified_diff(old_content: &str, new_content: &str) -> String {
+    let old_lines: Vec<&str> = old_content.lines().collect();
+    let new_lines: Vec<&str> = new_content.lines().collect();
+
+    let mut diff_output = String::new();
+    diff_output.push_str("--- global/config.toml\n");
+    diff_output.push_str("+++ local/config.toml\n");
+
+    // Simple line-by-line comparison (not a proper LCS diff, but useful for config files)
+    let max_lines = old_lines.len().max(new_lines.len());
+    let mut has_changes = false;
+
+    for i in 0..max_lines {
+        let old_line = old_lines.get(i).copied();
+        let new_line = new_lines.get(i).copied();
+
+        match (old_line, new_line) {
+            (Some(o), Some(n)) if o == n => {
+                // Lines are the same, show context
+                diff_output.push_str(&format!(" {}\n", o));
+            }
+            (Some(o), Some(n)) => {
+                // Lines differ
+                has_changes = true;
+                diff_output.push_str(&format!("-{}\n", o));
+                diff_output.push_str(&format!("+{}\n", n));
+            }
+            (Some(o), None) => {
+                // Line only in old
+                has_changes = true;
+                diff_output.push_str(&format!("-{}\n", o));
+            }
+            (None, Some(n)) => {
+                // Line only in new
+                has_changes = true;
+                diff_output.push_str(&format!("+{}\n", n));
+            }
+            (None, None) => break,
+        }
+    }
+
+    if !has_changes {
+        String::new()
+    } else {
+        diff_output
+    }
+}
+
 // =============================================================================
 // File subcommand
 // =============================================================================

cortex-cli/src/github_cmd.rs

@@ -568,6 +568,10 @@ async fn run_status(args: StatusArgs) -> Result<()> {
     if args.json {
         let json = serde_json::to_string_pretty(&status)?;
         println!("{}", json);
+        // Return non-zero exit code if workflow is not installed
+        if !status.workflow_installed {
+            std::process::exit(1);
+        }
         return Ok(());
     }
 
@@ -578,13 +582,13 @@ async fn run_status(args: StatusArgs) -> Result<()> {
     if !status.is_git_repo {
         println!("⚠️  Not a git repository");
         println!("   Run this command from a git repository root.");
-        return Ok(());
+        std::process::exit(1);
     }
 
     if !status.github_dir_exists {
         println!("❌ .github directory not found");
         println!("   Run `cortex github install` to set up GitHub Actions.");
-        return Ok(());
+        std::process::exit(1);
     }
 
     if status.workflow_installed {
@@ -600,6 +604,7 @@ async fn run_status(args: StatusArgs) -> Result<()> {
     } else {
         println!("❌ Cortex workflow not found");
         println!("   Run `cortex github install` to set up GitHub Actions.");
+        std::process::exit(1);
     }
 
     Ok(())

cortex-cli/src/main.rs

@@ -443,6 +443,10 @@ struct ConfigCommand {
     #[arg(long)]
     json: bool,
 
+    /// Output minified/compact JSON (only valid with --json)
+    #[arg(long, requires = "json")]
+    compact: bool,
+
     /// Edit configuration interactively
     #[arg(long)]
     edit: bool,
@@ -667,6 +671,16 @@ async fn main() -> Result<()> {
 
 async fn run_tui(initial_prompt: Option<String>, args: &InteractiveArgs) -> Result<()> {
     use cortex_common::resolve_model_alias;
+    use std::io::IsTerminal;
+
+    // Check if we're running in a terminal - TUI requires a TTY
+    if !std::io::stdin().is_terminal() || !std::io::stdout().is_terminal() {
+        eprintln!("Error: Interactive mode requires a terminal.");
+        eprintln!();
+        eprintln!("Use 'cortex run <prompt>' for non-interactive execution,");
+        eprintln!("or 'cortex --help' for usage information.");
+        std::process::exit(1);
+    }
 
     let mut config = cortex_engine::Config::default();
 
@@ -1179,7 +1193,11 @@ async fn show_config(config_cli: ConfigCommand) -> Result<()> {
             "cwd": config.cwd,
             "fabric_home": config.fabric_home,
         });
-        println!("{}", serde_json::to_string_pretty(&json)?);
+        if config_cli.compact {
+            println!("{}", serde_json::to_string(&json)?);
+        } else {
+            println!("{}", serde_json::to_string_pretty(&json)?);
+        }
     } else if config_cli.edit {
         let config_path = config.fabric_home.join("config.toml");
         let editor = get_default_editor();