feat: add exclude file patterns and clipboard support

FR-031: `--exclude <GLOB>` CLI flag (repeatable) and `exclude_patterns`
config option filter files from analysis and diff context using globset.
Excluded files are listed in output but not sent to the LLM. CLI
patterns are additive with config patterns.

FR-033: `--clipboard` flag copies the generated message to the system
clipboard via platform commands (pbcopy/xclip/clip) and prints to
stdout, skipping the commit confirmation prompt entirely.

Author: Sephyi

Cargo.lock

@@ -88,6 +88,7 @@ keyring = { version = "3", optional = true }
 
 # Utilities
 regex = "1.12"
+globset = "0.4"
 
 [features]
 default = [

Cargo.toml

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 
 use console::style;
 use dialoguer::Confirm;
+use globset::{Glob, GlobSetBuilder};
 use tokio::signal;
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
@@ -90,6 +91,9 @@ impl App {
             changes.stats.deletions
         ));
 
+        // Step 1.5: Exclude files matching glob patterns
+        let changes = self.apply_exclude_patterns(changes, &progress)?;
+
         // Step 2: Check for safety issues
         if safety::check_for_conflicts(&changes) {
             return Err(Error::MergeConflicts);
@@ -338,7 +342,14 @@ impl App {
             self.select_candidate(&candidates)?
         };
 
-        // Step 7: Confirm and commit
+        // Step 7: Clipboard / dry-run / confirm and commit
+        if self.cli.clipboard {
+            Self::copy_to_clipboard(&message)?;
+            eprintln!("{} Copied to clipboard!", style("✓").green().bold());
+            println!("{}", message);
+            return Ok(());
+        }
+
         if self.cli.dry_run {
             println!("{}", message);
             return Ok(());
@@ -401,6 +412,12 @@ impl App {
                     "Learn from history: {} (sample: {})",
                     self.config.learn_from_history, self.config.history_sample_size
                 );
+                if !self.config.exclude_patterns.is_empty() {
+                    println!(
+                        "Exclude patterns: {}",
+                        self.config.exclude_patterns.join(", ")
+                    );
+                }
                 println!();
                 println!("[format]");
                 println!("  include_body: {}", self.config.format.include_body);
@@ -1265,6 +1282,108 @@ fi
         parts.join("\n")
     }
 
+    // ─── Exclude Helpers ───
+
+    /// Filter staged changes by removing files matching exclude glob patterns.
+    /// Returns the filtered changes. Excluded files are listed in output.
+    fn apply_exclude_patterns(
+        &self,
+        mut changes: StagedChanges,
+        progress: &Progress,
+    ) -> Result<StagedChanges> {
+        if self.config.exclude_patterns.is_empty() {
+            return Ok(changes);
+        }
+
+        let mut builder = GlobSetBuilder::new();
+        for pattern in &self.config.exclude_patterns {
+            let glob = Glob::new(pattern).map_err(|e| {
+                Error::Config(format!("Invalid exclude pattern '{}': {}", pattern, e))
+            })?;
+            builder.add(glob);
+        }
+        let glob_set = builder
+            .build()
+            .map_err(|e| Error::Config(format!("Failed to build exclude patterns: {}", e)))?;
+
+        let original_count = changes.files.len();
+        let mut excluded: Vec<PathBuf> = Vec::new();
+
+        changes.files.retain(|f| {
+            if glob_set.is_match(&f.path) {
+                excluded.push(f.path.clone());
+                false
+            } else {
+                true
+            }
+        });
+
+        if !excluded.is_empty() {
+            // Recalculate stats from remaining files
+            changes.stats.files_changed = changes.files.len();
+            changes.stats.insertions = changes.files.iter().map(|f| f.additions).sum();
+            changes.stats.deletions = changes.files.iter().map(|f| f.deletions).sum();
+
+            progress.info(&format!(
+                "Excluded {}/{} files matching patterns:",
+                excluded.len(),
+                original_count,
+            ));
+            for path in &excluded {
+                debug!(path = %path.display(), "excluded by pattern");
+            }
+        }
+
+        if changes.files.is_empty() {
+            return Err(Error::NoStagedChanges);
+        }
+
+        Ok(changes)
+    }
+
+    // ─── Clipboard Helpers ───
+
+    /// Copy text to the system clipboard using platform-specific commands.
+    fn copy_to_clipboard(text: &str) -> Result<()> {
+        let (cmd, args): (&str, &[&str]) = if cfg!(target_os = "macos") {
+            ("pbcopy", &[])
+        } else if cfg!(target_os = "windows") {
+            ("clip", &[])
+        } else {
+            // Linux: try xclip first, fall back to xsel
+            ("xclip", &["-selection", "clipboard"])
+        };
+
+        let mut child = std::process::Command::new(cmd)
+            .args(args)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::piped())
+            .spawn()
+            .map_err(|e| {
+                Error::Config(format!(
+                    "Failed to run clipboard command '{}': {}. Install it or use --dry-run instead.",
+                    cmd, e
+                ))
+            })?;
+
+        if let Some(ref mut stdin) = child.stdin {
+            use std::io::Write;
+            stdin.write_all(text.as_bytes())?;
+        }
+
+        let status = child.wait()?;
+        if !status.success() {
+            return Err(Error::Config(format!(
+                "Clipboard command '{}' failed with exit code {}",
+                cmd,
+                status.code().unwrap_or(-1)
+            )));
+        }
+
+        Ok(())
+    }
+
     // ─── Security Helpers ───
 
     /// Check if a URL host resolves to a loopback address (localhost, 127.0.0.1, ::1).

src/app.rs

@@ -45,6 +45,14 @@ pub struct Cli {
     #[arg(long)]
     pub no_scope: bool,
 
+    /// Copy generated message to clipboard instead of committing
+    #[arg(long)]
+    pub clipboard: bool,
+
+    /// Exclude files matching glob pattern (repeatable)
+    #[arg(long = "exclude", value_name = "GLOB")]
+    pub exclude: Vec<String>,
+
     /// Generate commit message in specified language (e.g., de, ja, fr)
     #[arg(long)]
     pub locale: Option<String>,

src/cli.rs

@@ -143,6 +143,11 @@ pub struct Config {
     #[serde(default = "default_history_sample_size")]
     pub history_sample_size: usize,
 
+    /// Glob patterns for files to exclude from analysis and diff context
+    /// Excluded files are listed in output but not sent to the LLM.
+    #[serde(default)]
+    pub exclude_patterns: Vec<String>,
+
     /// Path to custom system prompt file (overrides built-in SYSTEM_PROMPT)
     #[serde(default)]
     pub system_prompt_path: Option<PathBuf>,
@@ -210,6 +215,7 @@ impl Default for Config {
             locale: None,
             learn_from_history: false,
             history_sample_size: default_history_sample_size(),
+            exclude_patterns: Vec::new(),
             system_prompt_path: None,
             template_path: None,
             format: CommitFormat::default(),
@@ -239,6 +245,7 @@ impl std::fmt::Debug for Config {
             .field("locale", &self.locale)
             .field("learn_from_history", &self.learn_from_history)
             .field("history_sample_size", &self.history_sample_size)
+            .field("exclude_patterns", &self.exclude_patterns)
             .field("system_prompt_path", &self.system_prompt_path)
             .field("template_path", &self.template_path)
             .field("format", &self.format)
@@ -355,6 +362,9 @@ impl Config {
         if let Some(ref l) = cli.locale {
             self.locale = Some(l.clone());
         }
+        if !cli.exclude.is_empty() {
+            self.exclude_patterns.extend(cli.exclude.iter().cloned());
+        }
         Ok(())
     }
 
@@ -504,6 +514,10 @@ max_file_lines = 100
 # Number of recent commits to sample for style learning (default: 50)
 # history_sample_size = 50
 
+# Exclude files matching glob patterns from analysis and diff context
+# Excluded files are listed in output but not sent to the LLM.
+# exclude_patterns = ["*.lock", "**/*.generated.*"]
+
 # Custom system prompt file (overrides built-in prompt)
 # system_prompt_path = "/path/to/system_prompt.txt"