✨ Add shell completions, configurable subagent timeout, and release notes file update

Introduce shell completion script generation for bash, zsh, fish, elvish,
and powershell via the new `completions` subcommand.

Add configurable timeout for parallel subagent tasks via `--subagent-timeout`
flag in both global and project config commands. The timeout defaults to
120 seconds and is now stored in the config file.

Extend the release-notes command with `--update` and `--file` flags to
automatically write generated release notes to a file (prepending to
existing content or creating a new file).

Improve gitmoji CLI handling by replacing the single `--gitmoji` flag with
explicit `--gitmoji` and `--no-gitmoji` flags for clearer intent.

Refactor project-config command to properly isolate project settings from
personal config, ensuring API keys are never inherited into project files.

Author: hyperb1iss

Cargo.lock

@@ -28,6 +28,7 @@ arboard = "3.4"
 async-trait = "0.1.88"
 chrono = { version = "0.4.38", features = ["serde"] }
 clap = { version = "4.5.36", features = ["derive", "cargo"] }
+clap_complete = "4.5"
 colored = "3.0.0"
 crossterm = "0.28.1"
 dirs = "6.0.0"

Cargo.toml

@@ -439,9 +439,12 @@ Guidelines:
             // Workspace for Iris's notes and task management (clone to share Arc-backed state)
             .tool(DebugTool::new(self.workspace.clone()))
             // Parallel analysis for distributing work across multiple subagents
-            .tool(DebugTool::new(ParallelAnalyze::new(
+            .tool(DebugTool::new(ParallelAnalyze::with_timeout(
                 &self.provider,
                 fast_model,
+                self.config
+                    .as_ref()
+                    .map_or(120, |c| c.subagent_timeout_secs),
             )))
             // Sub-agent delegation (Rig's built-in agent-as-tool!)
             .tool(sub_agent);

src/agents/iris.rs

@@ -20,8 +20,8 @@ use tokio::sync::Mutex;
 
 use crate::agents::debug as agent_debug;
 
-/// Timeout for individual subagent tasks (2 minutes)
-const SUBAGENT_TIMEOUT: Duration = Duration::from_secs(120);
+/// Default timeout for individual subagent tasks (2 minutes)
+const DEFAULT_SUBAGENT_TIMEOUT_SECS: u64 = 120;
 
 /// Arguments for parallel analysis
 #[derive(Debug, Deserialize, JsonSchema)]
@@ -140,10 +140,18 @@ impl SubagentRunner {
 pub struct ParallelAnalyze {
     runner: SubagentRunner,
     model: String,
+    /// Timeout in seconds for each subagent task
+    timeout_secs: u64,
 }
 
 impl ParallelAnalyze {
+    /// Create a new parallel analyzer with default timeout
     pub fn new(provider: &str, model: &str) -> Self {
+        Self::with_timeout(provider, model, DEFAULT_SUBAGENT_TIMEOUT_SECS)
+    }
+
+    /// Create a new parallel analyzer with custom timeout
+    pub fn with_timeout(provider: &str, model: &str, timeout_secs: u64) -> Self {
         // Default to openai if creation fails
         let runner = SubagentRunner::new(provider, model).unwrap_or_else(|_| {
             tracing::warn!(
@@ -156,6 +164,7 @@ impl ParallelAnalyze {
         Self {
             runner,
             model: model.to_string(),
+            timeout_secs,
         }
     }
 }
@@ -220,25 +229,25 @@ impl Tool for ParallelAnalyze {
 
         // Spawn all tasks as parallel tokio tasks, tracking index for ordering
         let mut handles = Vec::new();
+        let timeout = Duration::from_secs(self.timeout_secs);
         for (index, task) in tasks.into_iter().enumerate() {
             let runner = self.runner.clone();
             let results = Arc::clone(&results);
+            let task_timeout = timeout;
+            let timeout_secs = self.timeout_secs;
 
             let handle = tokio::spawn(async move {
                 // Wrap task execution in timeout to prevent hanging
-                let result =
-                    match tokio::time::timeout(SUBAGENT_TIMEOUT, runner.run_task(&task)).await {
-                        Ok(result) => result,
-                        Err(_) => SubagentResult {
-                            task: task.clone(),
-                            result: String::new(),
-                            success: false,
-                            error: Some(format!(
-                                "Task timed out after {} seconds",
-                                SUBAGENT_TIMEOUT.as_secs()
-                            )),
-                        },
-                    };
+                let result = match tokio::time::timeout(task_timeout, runner.run_task(&task)).await
+                {
+                    Ok(result) => result,
+                    Err(_) => SubagentResult {
+                        task: task.clone(),
+                        result: String::new(),
+                        success: false,
+                        error: Some(format!("Task timed out after {} seconds", timeout_secs)),
+                    },
+                };
 
                 // Store result at original index to preserve ordering
                 let mut guard = results.lock().await;

src/agents/tools/parallel_analyze.rs

@@ -5,8 +5,10 @@ use crate::providers::Provider;
 use crate::theme;
 use crate::ui;
 use clap::builder::{Styles, styling::AnsiColor};
-use clap::{Parser, Subcommand, crate_version};
+use clap::{CommandFactory, Parser, Subcommand, crate_version};
+use clap_complete::{Shell, generate};
 use colored::Colorize;
+use std::io;
 
 /// Default log file path for debug output
 pub const LOG_FILE: &str = "git-iris-debug.log";
@@ -260,6 +262,17 @@ pub enum Commands {
         #[arg(long, help = "Output raw markdown without any console formatting")]
         raw: bool,
 
+        /// Update the release notes file with the new content
+        #[arg(long, help = "Update the release notes file with the new content")]
+        update: bool,
+
+        /// Path to the release notes file
+        #[arg(
+            long,
+            help = "Path to the release notes file (defaults to RELEASE_NOTES.md)"
+        )]
+        file: Option<String>,
+
         /// Explicit version name to use in the release notes instead of getting it from Git
         #[arg(long, help = "Explicit version name to use in the release notes")]
         version_name: Option<String>,
@@ -323,6 +336,13 @@ pub enum Commands {
             help = "Set additional parameters for the specified provider (key=value)"
         )]
         param: Option<Vec<String>>,
+
+        /// Set timeout in seconds for parallel subagent tasks
+        #[arg(
+            long,
+            help = "Set timeout in seconds for parallel subagent tasks (default: 120)"
+        )]
+        subagent_timeout: Option<u64>,
     },
 
     /// Create or update a project-specific configuration file
@@ -356,6 +376,13 @@ pub enum Commands {
         )]
         param: Option<Vec<String>>,
 
+        /// Set timeout in seconds for parallel subagent tasks
+        #[arg(
+            long,
+            help = "Set timeout in seconds for parallel subagent tasks (default: 120)"
+        )]
+        subagent_timeout: Option<u64>,
+
         /// Print the current project configuration
         #[arg(short, long, help = "Print the current project configuration")]
         print: bool,
@@ -368,6 +395,17 @@ pub enum Commands {
     /// List available themes
     #[command(about = "List available themes")]
     Themes,
+
+    /// Generate shell completions
+    #[command(
+        about = "Generate shell completions",
+        long_about = "Generate shell completion scripts for bash, zsh, fish, elvish, or powershell.\n\nUsage examples:\n• Bash: git-iris completions bash >> ~/.bashrc\n• Zsh:  git-iris completions zsh >> ~/.zshrc\n• Fish: git-iris completions fish > ~/.config/fish/completions/git-iris.fish"
+    )]
+    Completions {
+        /// Shell to generate completions for
+        #[arg(value_enum)]
+        shell: Shell,
+    },
 }
 
 /// Define custom styles for Clap
@@ -674,16 +712,26 @@ fn handle_config(
     fast_model: Option<String>,
     token_limit: Option<usize>,
     param: Option<Vec<String>>,
+    subagent_timeout: Option<u64>,
 ) -> anyhow::Result<()> {
     log_debug!(
-        "Handling 'config' command with common: {:?}, api_key: {:?}, model: {:?}, token_limit: {:?}, param: {:?}",
+        "Handling 'config' command with common: {:?}, api_key: {:?}, model: {:?}, token_limit: {:?}, param: {:?}, subagent_timeout: {:?}",
         common,
         api_key,
         model,
         token_limit,
-        param
+        param,
+        subagent_timeout
     );
-    commands::handle_config_command(common, api_key, model, fast_model, token_limit, param)
+    commands::handle_config_command(
+        common,
+        api_key,
+        model,
+        fast_model,
+        token_limit,
+        param,
+        subagent_timeout,
+    )
 }
 
 /// Handle the `Review` command
@@ -852,20 +900,25 @@ async fn handle_changelog(
 }
 
 /// Handle the `Release Notes` command
+#[allow(clippy::too_many_arguments)]
 async fn handle_release_notes(
     common: CommonParams,
     from: String,
     to: Option<String>,
     raw: bool,
     repository_url: Option<String>,
+    update: bool,
+    file: Option<String>,
     _version_name: Option<String>,
 ) -> anyhow::Result<()> {
     log_debug!(
-        "Handling 'release-notes' command with common: {:?}, from: {}, to: {:?}, raw: {}",
+        "Handling 'release-notes' command with common: {:?}, from: {}, to: {:?}, raw: {}, update: {}, file: {:?}",
         common,
         from,
         to,
-        raw
+        raw,
+        update,
+        file
     );
 
     // For raw output, skip all formatting
@@ -875,6 +928,8 @@ async fn handle_release_notes(
     }
 
     use crate::agents::{IrisAgentService, TaskContext};
+    use std::fs;
+    use std::path::Path;
 
     // Create structured context for release notes
     let context = TaskContext::for_changelog(from, to);
@@ -896,6 +951,43 @@ async fn handle_release_notes(
     }
 
     println!("{response}");
+
+    // Handle --update flag
+    if update {
+        let release_notes_path = file.unwrap_or_else(|| "RELEASE_NOTES.md".to_string());
+        let formatted_content = response.to_string();
+
+        let update_spinner = ui::create_spinner(&format!(
+            "Updating release notes file at {release_notes_path}..."
+        ));
+
+        // Write or append to file
+        let path = Path::new(&release_notes_path);
+        let result = if path.exists() {
+            // Prepend to existing file
+            let existing = fs::read_to_string(path)?;
+            fs::write(path, format!("{formatted_content}\n\n---\n\n{existing}"))
+        } else {
+            // Create new file
+            fs::write(path, &formatted_content)
+        };
+
+        match result {
+            Ok(()) => {
+                update_spinner.finish_and_clear();
+                ui::print_success(&format!(
+                    "✨ Release notes successfully updated at {}",
+                    release_notes_path.bright_green()
+                ));
+            }
+            Err(e) => {
+                update_spinner.finish_and_clear();
+                ui::print_error(&format!("Failed to update release notes file: {e}"));
+                return Err(e.into());
+            }
+        }
+    }
+
     Ok(())
 }
 
@@ -934,7 +1026,16 @@ pub async fn handle_command(
             fast_model,
             token_limit,
             param,
-        } => handle_config(&common, api_key, model, fast_model, token_limit, param),
+            subagent_timeout,
+        } => handle_config(
+            &common,
+            api_key,
+            model,
+            fast_model,
+            token_limit,
+            param,
+            subagent_timeout,
+        ),
         Commands::Review {
             common,
             print,
@@ -982,28 +1083,48 @@ pub async fn handle_command(
             from,
             to,
             raw,
+            update,
+            file,
             version_name,
-        } => handle_release_notes(common, from, to, raw, repository_url, version_name).await,
+        } => {
+            handle_release_notes(
+                common,
+                from,
+                to,
+                raw,
+                repository_url,
+                update,
+                file,
+                version_name,
+            )
+            .await
+        }
         Commands::ProjectConfig {
             common,
             model,
             fast_model,
             token_limit,
             param,
+            subagent_timeout,
             print,
         } => commands::handle_project_config_command(
             &common,
             model,
             fast_model,
             token_limit,
             param,
+            subagent_timeout,
             print,
         ),
         Commands::ListPresets => commands::handle_list_presets_command(),
         Commands::Themes => {
             handle_themes();
             Ok(())
         }
+        Commands::Completions { shell } => {
+            handle_completions(shell);
+            Ok(())
+        }
         Commands::Pr {
             common,
             print,
@@ -1104,6 +1225,12 @@ fn handle_themes() {
     );
 }
 
+/// Handle the `Completions` command - generate shell completion scripts
+fn handle_completions(shell: Shell) {
+    let mut cmd = Cli::command();
+    generate(shell, &mut cmd, "git-iris", &mut io::stdout());
+}
+
 /// Handle the `Pr` command with agent framework
 async fn handle_pr_with_agent(
     common: CommonParams,