fix: batch fixes for issues #2074, 2075, 2077, 2078, 2080, 2082, 2083, 2086, 2088, 2089 [skip ci] (#399)

Fixes:
- #2074: Add alias command for custom shortcuts
- #2075: Add --system flag to exec command (run already has it)
- #2077: Add --max-tokens flag to exec command (run already has it)
- #2078: Plugin system already exists (no changes needed)
- #2080: Add cache management command
- #2082: Add graceful shutdown message on SIGTERM
- #2083: Add logs command to view debug logs
- #2086: Add shell/interactive/repl command
- #2088: Add workspace/project management command
- #2089: Add file permissions display (rw-r--r-- format) in debug file

Also fixes pre-existing build issues:
- Add trust_proxy field to RateLimitConfig
- Add cookies feature to reqwest
- Fix borrow checker issue in scrape_cmd

Co-authored-by: Bounty Bot <bounty-bot@factory.ai>
Co-authored-by: Droid Agent <droid@factory.ai>

Author: 3 people

Cargo.toml

@@ -130,7 +130,7 @@ simd-json = "0.14"
 toml = "0.8"
 
 # HTTP client
-reqwest = { version = "0.12", features = ["json", "stream", "rustls-tls"], default-features = false }
+reqwest = { version = "0.12", features = ["json", "stream", "rustls-tls", "cookies"], default-features = false }
 
 # Error handling
 thiserror = "2.0"

cortex-cli/src/alias_cmd.rs

@@ -0,0 +1,262 @@
+//! Alias command for Cortex CLI.
+//!
+//! Provides user-defined command alias functionality:
+//! - Set custom command aliases
+//! - List all aliases
+//! - Remove aliases
+//! - Show alias details
+
+use anyhow::{Result, bail};
+use clap::Parser;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+/// Alias CLI command.
+#[derive(Debug, Parser)]
+pub struct AliasCli {
+    #[command(subcommand)]
+    pub subcommand: AliasSubcommand,
+}
+
+/// Alias subcommands.
+#[derive(Debug, clap::Subcommand)]
+pub enum AliasSubcommand {
+    /// Set a command alias
+    Set(AliasSetArgs),
+
+    /// List all aliases
+    #[command(visible_alias = "ls")]
+    List(AliasListArgs),
+
+    /// Remove an alias
+    #[command(visible_aliases = ["rm", "delete"])]
+    Remove(AliasRemoveArgs),
+
+    /// Show alias details
+    #[command(visible_alias = "info")]
+    Show(AliasShowArgs),
+}
+
+/// Arguments for alias set command.
+#[derive(Debug, Parser)]
+pub struct AliasSetArgs {
+    /// Alias name (short name for the command)
+    pub name: String,
+
+    /// Command to alias (e.g., "exec --output-schema")
+    pub command: String,
+
+    /// Description of the alias
+    #[arg(long, short = 'd')]
+    pub description: Option<String>,
+
+    /// Force overwrite if alias already exists
+    #[arg(long, short = 'f')]
+    pub force: bool,
+}
+
+/// Arguments for alias list command.
+#[derive(Debug, Parser)]
+pub struct AliasListArgs {
+    /// Output as JSON
+    #[arg(long)]
+    pub json: bool,
+}
+
+/// Arguments for alias remove command.
+#[derive(Debug, Parser)]
+pub struct AliasRemoveArgs {
+    /// Alias name to remove
+    pub name: String,
+
+    /// Skip confirmation prompt
+    #[arg(long, short = 'y')]
+    pub yes: bool,
+}
+
+/// Arguments for alias show command.
+#[derive(Debug, Parser)]
+pub struct AliasShowArgs {
+    /// Alias name to show
+    pub name: String,
+
+    /// Output as JSON
+    #[arg(long)]
+    pub json: bool,
+}
+
+/// Alias definition.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AliasDefinition {
+    pub name: String,
+    pub command: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
+/// Alias configuration.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct AliasConfig {
+    #[serde(default)]
+    pub aliases: HashMap<String, AliasDefinition>,
+}
+
+/// Get the aliases config file path.
+fn get_aliases_config_path() -> PathBuf {
+    dirs::home_dir()
+        .map(|h| h.join(".cortex").join("aliases.toml"))
+        .unwrap_or_else(|| PathBuf::from(".cortex/aliases.toml"))
+}
+
+/// Load aliases from config file.
+fn load_aliases() -> Result<AliasConfig> {
+    let config_path = get_aliases_config_path();
+    if !config_path.exists() {
+        return Ok(AliasConfig::default());
+    }
+
+    let content = std::fs::read_to_string(&config_path)?;
+    let config: AliasConfig = toml::from_str(&content)?;
+    Ok(config)
+}
+
+/// Save aliases to config file.
+fn save_aliases(config: &AliasConfig) -> Result<()> {
+    let config_path = get_aliases_config_path();
+
+    // Create parent directory if needed
+    if let Some(parent) = config_path.parent() {
+        if !parent.exists() {
+            std::fs::create_dir_all(parent)?;
+        }
+    }
+
+    let content = toml::to_string_pretty(config)?;
+    std::fs::write(&config_path, content)?;
+    Ok(())
+}
+
+impl AliasCli {
+    /// Run the alias command.
+    pub async fn run(self) -> Result<()> {
+        match self.subcommand {
+            AliasSubcommand::Set(args) => run_set(args).await,
+            AliasSubcommand::List(args) => run_list(args).await,
+            AliasSubcommand::Remove(args) => run_remove(args).await,
+            AliasSubcommand::Show(args) => run_show(args).await,
+        }
+    }
+}
+
+async fn run_set(args: AliasSetArgs) -> Result<()> {
+    let mut config = load_aliases()?;
+
+    // Check if alias already exists
+    if config.aliases.contains_key(&args.name) && !args.force {
+        bail!(
+            "Alias '{}' already exists. Use --force to overwrite.",
+            args.name
+        );
+    }
+
+    // Create the alias definition
+    let alias = AliasDefinition {
+        name: args.name.clone(),
+        command: args.command.clone(),
+        description: args.description.clone(),
+    };
+
+    config.aliases.insert(args.name.clone(), alias);
+    save_aliases(&config)?;
+
+    println!("Alias '{}' set to: {}", args.name, args.command);
+    if let Some(desc) = &args.description {
+        println!("  Description: {}", desc);
+    }
+
+    Ok(())
+}
+
+async fn run_list(args: AliasListArgs) -> Result<()> {
+    let config = load_aliases()?;
+
+    if args.json {
+        let aliases: Vec<&AliasDefinition> = config.aliases.values().collect();
+        println!("{}", serde_json::to_string_pretty(&aliases)?);
+        return Ok(());
+    }
+
+    if config.aliases.is_empty() {
+        println!("No aliases defined.");
+        println!("\nUse 'cortex alias set <name> <command>' to create an alias.");
+        println!("Example: cortex alias set q \"exec --output-schema\"");
+        return Ok(());
+    }
+
+    println!("Defined Aliases:");
+    println!("{}", "-".repeat(60));
+
+    let mut aliases: Vec<_> = config.aliases.values().collect();
+    aliases.sort_by(|a, b| a.name.cmp(&b.name));
+
+    for alias in aliases {
+        println!("  {} = {}", alias.name, alias.command);
+        if let Some(desc) = &alias.description {
+            println!("      {}", desc);
+        }
+    }
+
+    println!("\nTotal: {} alias(es)", config.aliases.len());
+    Ok(())
+}
+
+async fn run_remove(args: AliasRemoveArgs) -> Result<()> {
+    let mut config = load_aliases()?;
+
+    if !config.aliases.contains_key(&args.name) {
+        bail!("Alias '{}' does not exist.", args.name);
+    }
+
+    if !args.yes {
+        println!(
+            "Are you sure you want to remove alias '{}'? (y/N)",
+            args.name
+        );
+        let mut input = String::new();
+        std::io::stdin().read_line(&mut input)?;
+        if !input.trim().eq_ignore_ascii_case("y") {
+            println!("Aborted.");
+            return Ok(());
+        }
+    }
+
+    config.aliases.remove(&args.name);
+    save_aliases(&config)?;
+
+    println!("Alias '{}' removed.", args.name);
+    Ok(())
+}
+
+async fn run_show(args: AliasShowArgs) -> Result<()> {
+    let config = load_aliases()?;
+
+    let alias = config
+        .aliases
+        .get(&args.name)
+        .ok_or_else(|| anyhow::anyhow!("Alias '{}' does not exist.", args.name))?;
+
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(alias)?);
+        return Ok(());
+    }
+
+    println!("Alias: {}", alias.name);
+    println!("{}", "-".repeat(40));
+    println!("  Command: {}", alias.command);
+    if let Some(desc) = &alias.description {
+        println!("  Description: {}", desc);
+    }
+
+    Ok(())
+}