✨ feat: add automatic conventional commit style detection

Implement local commit history analysis to detect and apply
conventional commit format when no explicit style is configured.

New commit_style module provides pattern matching against recent
commit history with confidence thresholds. When 3+ of 4+ commits
match conventional format (type[scope]: description), Iris injects
style instructions to use the same format.

GitCommitService no longer applies gitmoji post-processing,
allowing agent-generated messages to remain exactly as formatted.
The use_gitmoji parameter is retained for API compatibility but
no longer modifies commit messages.

Git tools extended with range-based commit queries (from/to
parameters) and contributor filtering to support style analysis
and release notes generation.

The detection skips merge commits, fixups, and squashes to avoid
false positives from non-conventional maintenance commits.

Author: hyperb1iss

src/agents/capabilities/release_notes.toml

@@ -46,6 +46,7 @@ Organize your release notes naturally. A typical structure might include:
   - Agent Platform, API Changes, Performance, Developer Experience, etc.
 - **Breaking Changes** — Clear impact statements and migration guidance
 - **Upgrade Notes** — Actionable steps for users updating
+- **Contributors** — Include a short list of unique human contributors when there is more than one, or when the collaboration is worth calling out
 
 Adapt the structure based on what makes sense for this specific release. Let the content drive the organization.
 
@@ -59,6 +60,8 @@ Adapt the structure based on what makes sense for this specific release. Let the
 - Avoid cliché words: "enhance", "streamline", "leverage", "utilize", "robust"
 - Be precise. If context is incomplete, gather more evidence and clearly separate verified facts from inference.
 - Only describe what's evident from the diffs and commits
+- Exclude bot identities from contributor callouts (`[bot]`, `dependabot`, `renovate`, `github-actions`)
+- Omit the contributor section when there is only one human contributor or the list would add no value
 
 ## Example Format
 

src/agents/commit_style.rs

@@ -0,0 +1,74 @@
+use crate::context::RecentCommit;
+use regex::Regex;
+use std::sync::LazyLock;
+
+const MIN_CONVENTIONAL_SAMPLES: usize = 4;
+const MIN_CONVENTIONAL_MATCHES: usize = 3;
+const MIN_CONVENTIONAL_CONFIDENCE_NUMERATOR: usize = 3;
+const MIN_CONVENTIONAL_CONFIDENCE_DENOMINATOR: usize = 5;
+
+static CONVENTIONAL_COMMIT_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^[a-z][a-z0-9-]*(\([^)]+\))?!?: [^\s].+$")
+        .expect("conventional commit regex must compile")
+});
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ConventionalCommitStyle {
+    examples: Vec<String>,
+}
+
+impl ConventionalCommitStyle {
+    #[must_use]
+    pub(crate) fn examples(&self) -> &[String] {
+        &self.examples
+    }
+}
+
+#[must_use]
+pub(crate) fn detect_conventional_commit_style(
+    commits: &[RecentCommit],
+) -> Option<ConventionalCommitStyle> {
+    let subjects: Vec<&str> = commits
+        .iter()
+        .map(|commit| first_subject_line(&commit.message))
+        .filter(|subject| !should_ignore_subject(subject))
+        .collect();
+
+    if subjects.len() < MIN_CONVENTIONAL_SAMPLES {
+        return None;
+    }
+
+    let matching_subjects: Vec<&str> = subjects
+        .iter()
+        .copied()
+        .filter(|subject| CONVENTIONAL_COMMIT_RE.is_match(subject))
+        .collect();
+
+    if matching_subjects.len() < MIN_CONVENTIONAL_MATCHES
+        || matching_subjects.len() * MIN_CONVENTIONAL_CONFIDENCE_DENOMINATOR
+            < subjects.len() * MIN_CONVENTIONAL_CONFIDENCE_NUMERATOR
+    {
+        return None;
+    }
+
+    Some(ConventionalCommitStyle {
+        examples: matching_subjects
+            .into_iter()
+            .take(3)
+            .map(ToOwned::to_owned)
+            .collect(),
+    })
+}
+
+fn first_subject_line(message: &str) -> &str {
+    message.lines().next().unwrap_or_default().trim()
+}
+
+fn should_ignore_subject(subject: &str) -> bool {
+    let normalized = subject.trim().to_ascii_lowercase();
+
+    normalized.is_empty()
+        || normalized.starts_with("merge ")
+        || normalized.starts_with("fixup!")
+        || normalized.starts_with("squash!")
+}

src/agents/iris.rs

@@ -13,6 +13,8 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt;
 
+use crate::agents::commit_style::{ConventionalCommitStyle, detect_conventional_commit_style};
+
 /// Macro to build a streaming agent for any provider.
 ///
 /// All three providers (`OpenAI`, `Anthropic`, `Gemini`) share identical setup logic —
@@ -815,7 +817,8 @@ Guidelines:
         // Handle commit-specific styling (structured JSON output with emoji field)
         if capability == "commit" {
             if use_style_detection {
-                tracing::info!("🔍 Using local commit style detection (default mode)");
+                tracing::info!("🔍 Running local commit style detection (default mode)");
+                Self::inject_detected_commit_style(system_prompt);
             } else if commit_emoji {
                 system_prompt.push_str("\n\n=== GITMOJI INSTRUCTIONS ===\n");
                 system_prompt.push_str("Set the 'emoji' field to a single relevant gitmoji. ");
@@ -856,6 +859,41 @@ Guidelines:
         }
     }
 
+    fn inject_detected_commit_style(prompt: &mut String) {
+        let Some(style) = Self::detect_local_conventional_commit_style() else {
+            tracing::info!("🔍 No high-confidence conventional commit pattern detected locally");
+            return;
+        };
+
+        tracing::info!("📋 Detected conventional commit history locally");
+        prompt.push_str("\n\n=== STYLE INSTRUCTIONS ===\n");
+        prompt.push_str(
+            "Detected repository commit format from recent history: Conventional Commits without emojis.\n",
+        );
+        prompt.push_str(
+            "Use `<type>[optional scope]: <description>` with a lowercase type, optional scope, and imperative description. ",
+        );
+        prompt.push_str(
+            "Set the `emoji` field to null and do not include emojis anywhere in the title or body.\n",
+        );
+
+        if !style.examples().is_empty() {
+            prompt.push_str("Observed examples:\n");
+            for example in style.examples() {
+                prompt.push_str("- `");
+                prompt.push_str(example);
+                prompt.push_str("`\n");
+            }
+        }
+    }
+
+    fn detect_local_conventional_commit_style() -> Option<ConventionalCommitStyle> {
+        let current_dir = std::env::current_dir().ok()?;
+        let repo = crate::git::GitRepo::new(&current_dir).ok()?;
+        let commits = repo.get_recent_commits(12).ok()?;
+        detect_conventional_commit_style(&commits)
+    }
+
     fn inject_pr_review_emoji_styling(prompt: &mut String) {
         prompt.push_str("\n\n=== EMOJI STYLING ===\n");
         prompt.push_str("Use emojis to make the output visually scannable and engaging:\n");

src/agents/mod.rs

@@ -4,6 +4,7 @@
 //! including setup, core types, and execution management.
 
 // Core agent components
+mod commit_style;
 pub mod context;
 pub mod core;
 pub mod iris;

src/agents/tools/git.rs

@@ -6,8 +6,9 @@ use anyhow::Result;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
 
-use crate::context::ChangeType;
+use crate::context::{ChangeType, RecentCommit};
 use crate::define_tool_error;
 use crate::git::StagedFile;
 
@@ -500,6 +501,10 @@ pub struct GitLog;
 pub struct GitLogArgs {
     #[serde(default)]
     pub count: Option<usize>,
+    #[serde(default)]
+    pub from: Option<String>,
+    #[serde(default)]
+    pub to: Option<String>,
 }
 
 impl Tool for GitLog {
@@ -519,22 +524,75 @@ impl Tool for GitLog {
     async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
         let repo = get_current_repo().map_err(GitError::from)?;
 
+        if let Some(from) = args.from {
+            let to = args.to.unwrap_or_else(|| "HEAD".to_string());
+            let commits = repo
+                .get_commits_in_range(&from, &to)
+                .map_err(GitError::from)?;
+            return Ok(format_git_log_output(
+                &format!("Commits from {from} to {to}:"),
+                &commits,
+                true,
+            ));
+        }
+
+        if args.to.is_some() {
+            return Err(GitError::from(anyhow::anyhow!(
+                "git_log requires `from` when `to` is provided"
+            )));
+        }
+
         let commits = repo
             .get_recent_commits(args.count.unwrap_or(10))
             .map_err(GitError::from)?;
 
-        let mut output = String::new();
-        output.push_str("Recent commits:\n");
+        Ok(format_git_log_output("Recent commits:", &commits, false))
+    }
+}
 
-        for commit in commits {
-            output.push_str(&format!(
-                "{}: {} ({})\n",
-                commit.hash, commit.message, commit.author
-            ));
-        }
+fn format_git_log_output(
+    header: &str,
+    commits: &[RecentCommit],
+    include_contributors: bool,
+) -> String {
+    let mut output = String::new();
+    output.push_str(header);
+    output.push('\n');
 
-        Ok(output)
+    for commit in commits {
+        let title = commit.message.lines().next().unwrap_or_default().trim();
+        output.push_str(&format!("{}: {} ({})\n", commit.hash, title, commit.author));
     }
+
+    if include_contributors {
+        let contributors: BTreeSet<String> = commits
+            .iter()
+            .map(|commit| commit.author.trim())
+            .filter(|author| !author.is_empty() && !is_bot_author(author))
+            .map(ToOwned::to_owned)
+            .collect();
+
+        if !contributors.is_empty() {
+            output.push_str("\nContributors (excluding bots):\n");
+            for contributor in contributors {
+                output.push_str(&format!("- {contributor}\n"));
+            }
+        }
+    }
+
+    output
+}
+
+fn is_bot_author(author: &str) -> bool {
+    let normalized = author.trim().to_ascii_lowercase();
+
+    normalized.contains("[bot]")
+        || normalized.contains("dependabot")
+        || normalized.contains("renovate")
+        || normalized.contains("github-actions")
+        || normalized.ends_with(" bot")
+        || normalized.ends_with("-bot")
+        || normalized == "bot"
 }
 
 // Git repository info tool

src/git/repository.rs

@@ -700,6 +700,20 @@ impl GitRepo {
         commit::get_commits_for_pr(&repo, from, to)
     }
 
+    /// Get commits between two references with author metadata.
+    pub fn get_commits_in_range(&self, from: &str, to: &str) -> Result<Vec<RecentCommit>> {
+        let repo = self.open_repo()?;
+        let mut commits =
+            commit::get_commits_between_with_callback(
+                &repo,
+                from,
+                to,
+                |commit| Ok(commit.clone()),
+            )?;
+        commits.reverse();
+        Ok(commits)
+    }
+
     /// Get files changed in a commit range  
     pub fn get_commit_range_files(&self, from: &str, to: &str) -> Result<Vec<StagedFile>> {
         let repo = self.open_repo()?;

src/services/git_commit.rs

@@ -7,7 +7,6 @@ use anyhow::Result;
 use std::sync::Arc;
 
 use crate::git::{CommitResult, GitRepo};
-use crate::gitmoji::process_commit_message;
 use crate::log_debug;
 
 /// Service for performing git commit operations
@@ -23,7 +22,6 @@ use crate::log_debug;
 /// - Message generation (handled by agents)
 pub struct GitCommitService {
     repo: Arc<GitRepo>,
-    use_gitmoji: bool,
     verify: bool,
 }
 
@@ -32,15 +30,12 @@ impl GitCommitService {
     ///
     /// # Arguments
     /// * `repo` - The git repository to operate on
-    /// * `use_gitmoji` - Whether to apply gitmoji to commit messages
+    /// * `_use_gitmoji` - Retained for API compatibility; commit messages are
+    ///   stored exactly as provided
     /// * `verify` - Whether to run pre/post-commit hooks
     #[must_use]
-    pub fn new(repo: Arc<GitRepo>, use_gitmoji: bool, verify: bool) -> Self {
-        Self {
-            repo,
-            use_gitmoji,
-            verify,
-        }
+    pub fn new(repo: Arc<GitRepo>, _use_gitmoji: bool, verify: bool) -> Self {
+        Self { repo, verify }
     }
 
     /// Create from an existing `GitRepo` (convenience constructor)
@@ -82,7 +77,7 @@ impl GitCommitService {
     ///
     /// This method:
     /// 1. Validates the repository is not remote
-    /// 2. Processes the message (applies gitmoji if enabled)
+    /// 2. Uses the exact message provided
     /// 3. Runs pre-commit hook (if verify is enabled)
     /// 4. Creates the commit
     /// 5. Runs post-commit hook (if verify is enabled)
@@ -101,12 +96,11 @@ impl GitCommitService {
             return Err(anyhow::anyhow!("Cannot commit to a remote repository"));
         }
 
-        let processed_message = process_commit_message(message.to_string(), self.use_gitmoji);
-        log_debug!("Performing commit with message: {}", processed_message);
+        log_debug!("Performing commit with message: {}", message);
 
         if !self.verify {
             log_debug!("Skipping pre-commit hook (verify=false)");
-            return self.repo.commit(&processed_message);
+            return self.repo.commit(message);
         }
 
         // Execute pre-commit hook
@@ -118,7 +112,7 @@ impl GitCommitService {
         log_debug!("Pre-commit hook executed successfully");
 
         // Perform the commit
-        match self.repo.commit(&processed_message) {
+        match self.repo.commit(message) {
             Ok(result) => {
                 // Execute post-commit hook (failure doesn't fail the commit)
                 log_debug!("Executing post-commit hook");
@@ -139,7 +133,7 @@ impl GitCommitService {
     ///
     /// This method:
     /// 1. Validates the repository is not remote
-    /// 2. Processes the message (applies gitmoji if enabled)
+    /// 2. Uses the exact message provided
     /// 3. Runs pre-commit hook (if verify is enabled)
     /// 4. Amends the commit (replaces HEAD)
     /// 5. Runs post-commit hook (if verify is enabled)
@@ -160,12 +154,11 @@ impl GitCommitService {
             ));
         }
 
-        let processed_message = process_commit_message(message.to_string(), self.use_gitmoji);
-        log_debug!("Performing amend with message: {}", processed_message);
+        log_debug!("Performing amend with message: {}", message);
 
         if !self.verify {
             log_debug!("Skipping pre-commit hook (verify=false)");
-            return self.repo.amend_commit(&processed_message);
+            return self.repo.amend_commit(message);
         }
 
         // Execute pre-commit hook
@@ -177,7 +170,7 @@ impl GitCommitService {
         log_debug!("Pre-commit hook executed successfully");
 
         // Perform the amend
-        match self.repo.amend_commit(&processed_message) {
+        match self.repo.amend_commit(message) {
             Ok(result) => {
                 // Execute post-commit hook (failure doesn't fail the amend)
                 log_debug!("Executing post-commit hook");