commitai 1.0.5__py3-none-any.whl → 2.2.2__py3-none-any.whl

commitai/__init__.py

@@ -3,7 +3,7 @@
 
 # This __version__ string is read by hatchling during the build process
 # Make sure to update it for new releases.
-__version__ = "0.3.0"
+__version__ = "2.2.2"
 
 # The importlib.metadata approach is generally for reading the version
 # of an *already installed* package at runtime. We don't need it here

commitai/agent.py

@@ -0,0 +1,252 @@
+import glob
+import os
+import subprocess
+from typing import Any, Dict, Type
+
+# from langchain.agents import AgentExecutor, create_tool_calling_agent # Removed
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable
+from langchain_core.tools import BaseTool
+from langgraph.prebuilt import create_react_agent
+from pydantic import BaseModel, Field
+
+# --- TOOLS ---
+
+
+class ShellInput(BaseModel):
+    command: str = Field(
+        description=(
+            "The git command to execute (e.g., 'git status', 'git log'). "
+            "Must start with 'git'."
+        )
+    )
+
+
+class ReadOnlyShellTool(BaseTool):
+    name: str = "git_shell"
+    description: str = (
+        "Run read-only git commands to inspect the repository state. "
+        "Only 'git' commands are allowed. Write operations are blocked."
+    )
+    args_schema: Type[BaseModel] = ShellInput
+
+    def _run(self, command: str) -> str:
+        command = command.strip()
+        if not command.startswith("git"):
+            return "Error: Only 'git' commands are allowed."
+
+        # Simple blocklist for write operations
+        forbidden = [
+            "push",
+            "pull",
+            "commit",
+            "merge",
+            "rebase",
+            "cherry-pick",
+            "stash",
+            "clean",
+            "reset",
+            "checkout",
+            "switch",
+            "branch",
+        ]
+        if any(w in command.split() for w in forbidden):
+            return f"Error: Command '{command}' contains forbidden write operations."
+
+        try:
+            # shell=True is dangerous in general, but we heavily restricted input above
+            result = subprocess.run(
+                command, shell=True, capture_output=True, text=True, cwd=os.getcwd()
+            )
+            if result.returncode != 0:
+                return f"Error ({result.returncode}): {result.stderr}"
+            return result.stdout
+        except Exception as e:
+            return f"Execution Error: {str(e)}"
+
+
+class FileSearchInput(BaseModel):
+    pattern: str = Field(
+        description="The glob pattern to search for files (e.g., 'src/**/*.py')."
+    )
+
+
+class FileSearchTool(BaseTool):
+    name: str = "file_search"
+    description: str = (
+        "Search for file paths in the project using glob patterns. "
+        "Useful to find files to inspect."
+    )
+    args_schema: Type[BaseModel] = FileSearchInput
+
+    def _run(self, pattern: str) -> str:
+        try:
+            # Security: prevent breaking out of repo?
+            # For simplicity, just run glob.
+            if ".." in pattern:
+                return "Error: '..' not allowed in patterns."
+
+            files = glob.glob(pattern, recursive=True)
+            if not files:
+                return "No files found."
+            return "\n".join(files[:20])  # Limit output
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+
+class FileReadInput(BaseModel):
+    file_path: str = Field(description="The path of the file to read.")
+
+
+class FileReadTool(BaseTool):
+    name: str = "file_read"
+    description: str = "Read the contents of a specific file."
+    args_schema: Type[BaseModel] = FileReadInput
+
+    def _run(self, file_path: str) -> str:
+        if ".." in file_path:
+            return "Error: Traversing up directories is not allowed."
+        if not os.path.exists(file_path):
+            return "Error: File does not exist."
+        try:
+            with open(file_path, "r") as f:
+                content = f.read()
+                return content[:2000]  # Truncate large files
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+
+# --- MIDDLEWARE (Simulated for Agent) ---
+
+
+class SummarizationMiddleware:
+    """Uses LLM to summarize diff before agent sees it."""
+
+    def __init__(self, llm: BaseChatModel):
+        self.llm = llm
+
+    def process(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        diff = inputs.get("diff", "")
+        if not diff:
+            return inputs
+
+        # Simple summarization chain (inline invocation)
+        # Truncate for summary
+        msg = f"Summarize these changes in 2 sentences:\n\n{diff[:5000]}"
+        resp = self.llm.invoke(msg)
+        inputs["summary"] = resp.content
+        return inputs
+
+
+class TodoMiddleware:
+    """Scans diff for TODOs and adds to inputs."""
+
+    def process(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        diff = inputs.get("diff", "")
+        todos = []
+        for line in diff.splitlines():
+            if line.startswith("+") and any(
+                x in line.lower() for x in ["todo", "fixme"]
+            ):
+                todos.append(line[1:].strip())
+        inputs["todos"] = todos
+        inputs["todo_str"] = "\n".join(f"- {t}" for t in todos) if todos else "None"
+        return inputs
+
+
+# --- AGENT ---
+
+
+# --- AGENT ---
+
+
+def create_commit_agent(llm: BaseChatModel) -> Runnable:
+    # 1. Init Tools
+    tools = [ReadOnlyShellTool(), FileSearchTool(), FileReadTool()]
+
+    # 2. Middlewares
+    summ_mw = SummarizationMiddleware(llm)
+    todo_mw = TodoMiddleware()
+
+    # 3. Prompt
+    system_prompt = """You are an expert software engineer acting as a Commit Assistant.
+Your goal is to generate a conventional commit message.
+
+Context:
+- User Explanation: {explanation}
+- Detected TODOs: {todo_str}
+- Auto-Summary: {summary}
+- Staged Diff: {diff}
+
+You have access to tools to explore the codebase if the diff + explanation is ambiguous.
+- Use `git_shell` to check status or logs.
+- Use `file_search` and `file_read` to understand context of modified files.
+
+Protocol:
+1. Analyze the input.
+2. If detecting POTENTIAL SENSITIVE DATA (API keys, secrets) in the diff, you MUST stop
+   and ask the user (simulated by returning a warning message).
+3. If clarification is needed, explore files.
+4. Final Answer MUST be ONLY the commit message.
+"""
+    # Note: create_react_agent handles the prompt internally or via state_modifier.
+    # We can pass a system string or a function. Since our prompt depends on dynamic
+    # variables (diff, explanation, etc.), we need to inject them. LangGraph's
+    # prebuilt agent usually takes a static system message. However, we can use the
+    # 'messages' state. But to keep it simple and compatible with existing 'invoke'
+    # interface: We will format the system prompt in the wrapper and pass it as the
+    # first message.
+
+    # Actually, create_react_agent supports 'state_modifier'.
+    # If we pass a formatted string, it works as system prompt.
+
+    # 4. Construct Graph
+    # We don't construct the graph with ALL variables pre-bound if they change per run.
+    # Instead, we'll format the prompt in the pipeline and pass it to the agent.
+
+    agent_graph = create_react_agent(llm, tools)
+
+    # 5. Pipeline with Middleware
+    def run_pipeline(inputs: Dict[str, Any]) -> str:
+        # Run Middleware
+        state = inputs.copy()
+        state = todo_mw.process(state)
+        state = summ_mw.process(state)
+
+        # Inject formatted fields if missing
+        state.setdefault("explanation", "None")
+        state.setdefault("summary", "None")
+        state.setdefault("todo_str", "None")
+
+        # Format System Prompt
+        formatted_system_prompt = system_prompt.format(
+            explanation=state["explanation"],
+            todo_str=state["todo_str"],
+            summary=state["summary"],
+            diff=state.get("diff", ""),
+        )
+
+        # Run Agent
+        # LangGraph inputs: {"messages": [{"role": "user", "content": ...}]}
+        # We inject the system prompt as a SystemMessage or just update the state.
+        # create_react_agent primarily looks at 'messages'.
+
+        from langchain_core.messages import HumanMessage, SystemMessage
+
+        messages = [
+            SystemMessage(content=formatted_system_prompt),
+            HumanMessage(content="Generate the commit message."),
+        ]
+
+        # Invoke graph
+        # result is a dict with 'messages'
+        result = agent_graph.invoke({"messages": messages})
+
+        # Extract last message content
+        last_message = result["messages"][-1]
+        return str(last_message.content)
+
+    # Wrap in RunnableLambda to expose 'invoke'
+    from langchain_core.runnables import RunnableLambda
+
+    return RunnableLambda(run_pipeline)

commitai/chains.py

@@ -0,0 +1,135 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import Runnable, RunnableLambda, RunnablePassthrough
+
+
+class CommitState(TypedDict):
+    diff: str
+    explanation: Optional[str]
+    summary: Optional[str]
+    todos: Optional[List[str]]
+
+
+class SummarizationMiddleware:
+    """Middleware to summarize the diff before generating the commit message."""
+
+    def __init__(self, llm: BaseChatModel):
+        self.llm = llm
+        self.prompt = ChatPromptTemplate.from_template(
+            "Summarize the following code changes concisely in 1-2 sentences:\n\n{diff}"
+        )
+        self.chain = self.prompt | self.llm | StrOutputParser()
+
+    def __call__(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Run the summarizer and add 'summary' to the state."""
+        diff = inputs.get("diff", "")
+        if not diff:
+            return {**inputs, "summary": ""}
+
+        # We invoke the chain synchronously here
+        summary = self.chain.invoke({"diff": diff})
+        return {**inputs, "summary": summary}
+
+
+class TodoMiddleware:
+    """Middleware to scan the diff for TODO/FIXME/HACK comments."""
+
+    def __call__(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        diff = inputs.get("diff", "")
+        todos = []
+        for line in diff.splitlines():
+            if line.startswith("+"):
+                lower_line = line.lower()
+                if (
+                    "todo" in lower_line
+                    or "fixme" in lower_line
+                    or "hack" in lower_line
+                ):
+                    # Strip the + and whitespace
+                    clean_line = line[1:].strip()
+                    todos.append(clean_line)
+
+        return {**inputs, "todos": todos}
+
+
+def create_commit_chain(llm: BaseChatModel) -> Runnable:
+    """Creates the full commit generation pipeline with middleware."""
+
+    # 1. Initialize Middlewares
+    summarizer = SummarizationMiddleware(llm)
+    todo_scanner = TodoMiddleware()
+
+    # 2. Define the Prompt
+    # We include placeholders for summary and todos if they exist
+    system_template = (
+        "You are an expert software engineer and git commit message generator.\n"
+        "Your task is to generate a clean, concise commit message following the "
+        "Conventional Commits specification.\n\n"
+        "Values from middleware:\n"
+        "{summary_section}\n"
+        "{todo_section}\n\n"
+        "Input context:\n"
+        "{explanation_section}\n\n"
+        "Existing Code Changes (Diff):\n"
+        "{diff}\n\n"
+        "Instructions:\n"
+        "1. Use the format: <type>(<scope>): <subject>\n"
+        "2. Keep the subject line under 50 characters if possible.\n"
+        "3. If there are multiple changes, provide a bulleted body.\n"
+        "4. If TODOs were detected, mention them in the footer or body as "
+        "appropriate.\n"
+        "5. If an explanation is provided, prioritize it.\n"
+    )
+    prompt = ChatPromptTemplate.from_template(system_template)
+
+    # 3. Helper to format the prompt inputs from state
+    def format_inputs(state: CommitState) -> Dict[str, Any]:
+        summary = state.get("summary")
+        todos = state.get("todos")
+        explanation = state.get("explanation")
+
+        summary_section = f"Summary of changes:\n{summary}\n" if summary else ""
+
+        todo_section = ""
+        if todos:
+            todo_section = (
+                "Detected TODOs in this diff:\n"
+                + "\n".join(f"- {t}" for t in todos)
+                + "\n"
+            )
+
+        explanation_section = ""
+        if explanation:
+            explanation_section = f"User Explanation:\n{explanation}\n"
+
+        return {
+            "diff": state["diff"],
+            "summary_section": summary_section,
+            "todo_section": todo_section,
+            "explanation_section": explanation_section,
+        }
+
+    # 4. Construct the Pipeline
+    # Parallel step to run middlewares
+    # (conceptually, though here we chain them or use RunnablePassthrough)
+    # Since middlewares modify state, we can chain them:
+
+    middleware_chain: Runnable = (
+        RunnablePassthrough()
+        | RunnableLambda(todo_scanner)
+        | RunnableLambda(summarizer)
+    )
+
+    # Final generation chain
+    generation_chain = (
+        middleware_chain
+        | RunnableLambda(format_inputs)
+        | prompt
+        | llm
+        | StrOutputParser()
+    )
+
+    return generation_chain

commitai/cli.py

@@ -2,13 +2,11 @@
 # -*- coding: utf-8 -*-
 
 import os
-from typing import Optional, Tuple, cast
+import sys
+from typing import Optional, Tuple
 
 import click
-from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_ollama import ChatOllama
-from langchain_openai import ChatOpenAI
 
 # Keep SecretStr import in case it's needed elsewhere or for future refinement
 
@@ -18,6 +16,7 @@ try:
 except ImportError:
     ChatGoogleGenerativeAI = None  # type: ignore
 
+from commitai.agent import create_commit_agent
 from commitai.git import (
     create_commit,
     get_commit_template,
@@ -28,11 +27,6 @@ from commitai.git import (
     save_commit_template,
     stage_all_changes,
 )
-from commitai.template import (
-    adding_template,
-    build_user_message,
-    default_system_message,
-)
 
 
 def _get_google_api_key() -> Optional[str]:
@@ -49,45 +43,30 @@ def _initialize_llm(model: str) -> BaseChatModel:
     google_api_key_str = _get_google_api_key()
 
     try:
-        if model.startswith("gpt-"):
-            api_key = os.getenv("OPENAI_API_KEY")
-            if not api_key:
-                raise click.ClickException(
-                    "Error: OPENAI_API_KEY environment variable not set."
-                )
-            return ChatOpenAI(model=model, api_key=api_key, temperature=0.7)
-
-        elif model.startswith("claude-"):
-            api_key = os.getenv("ANTHROPIC_API_KEY")
-            if not api_key:
-                raise click.ClickException(
-                    "Error: ANTHROPIC_API_KEY environment variable not set."
-                )
-            return ChatAnthropic(model_name=model, api_key=api_key, temperature=0.7)
-
-        elif model.startswith("gemini-"):
-            if ChatGoogleGenerativeAI is None:
-                raise click.ClickException(
-                    "Error: 'langchain-google-genai' is not installed. "
-                    "Run 'pip install commitai[test]' or "
-                    "'pip install langchain-google-genai'"
-                )
-            if not google_api_key_str:
-                raise click.ClickException(
-                    "Error: Google API Key not found. Set GOOGLE_API_KEY, "
-                    "GEMINI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY."
-                )
-            return ChatGoogleGenerativeAI(
-                model=model,
-                google_api_key=google_api_key_str,
-                temperature=0.7,
-                convert_system_message_to_human=True,
+        # Enforce Gemini-Only Policy
+        # Enforce Strict Gemini-3 Policy
+        allowed_models = ["gemini-3-flash-preview", "gemini-3-pro-preview"]
+        if model not in allowed_models:
+            raise click.ClickException(
+                f"🚫 Unsupported model: {model}. "
+                f"Only Google Gemini 3 models are allowed: {', '.join(allowed_models)}"
+            )
+
+        if ChatGoogleGenerativeAI is None:
+            raise click.ClickException(
+                "Error: 'langchain-google-genai' is not installed. "
+                "Run 'pip install commitai[test]' or "
+                "'pip install langchain-google-genai'"
             )
-        elif model.startswith("llama"):
-            # Ollama models (e.g., llama2, llama3)
-            return cast(BaseChatModel, ChatOllama(model=model, temperature=0.7))
-        else:
-            raise click.ClickException(f"🚫 Unsupported model: {model}")
+        if not google_api_key_str:
+            raise click.ClickException(
+                "Error: Google API Key not found. Set GOOGLE_API_KEY, "
+                "GEMINI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY."
+            )
+        return ChatGoogleGenerativeAI(
+            model=model,
+            google_api_key=google_api_key_str,
+        )
 
     except Exception as e:
         raise click.ClickException(f"Error initializing AI model: {e}") from e
@@ -100,25 +79,13 @@ def _prepare_context() -> str:
 
     repo_name = get_repository_name()
     branch_name = get_current_branch_name()
+    # Return just the diff for the chain, or context?
+    # The chain prompt expects 'diff'.
+    # Current helper was returning "Repo/Branch\n\nDiff".
+    # Let's keep it to maximize context for the chain.
     return f"{repo_name}/{branch_name}\n\n{diff}"
 
 
-def _build_prompt(
-    explanation: str, formatted_diff: str, template: Optional[str]
-) -> str:
-    system_message = default_system_message
-    if template:
-        system_message += adding_template
-        system_message += template
-
-    if explanation:
-        diff_message = build_user_message(explanation, formatted_diff)
-    else:
-        diff_message = formatted_diff
-
-    return f"{system_message}\n\n{diff_message}"
-
-
 def _handle_commit(commit_message: str, commit_flag: bool) -> None:
     repo_path = get_repository_name()
     git_dir = os.path.join(repo_path, ".git")
@@ -135,19 +102,34 @@ def _handle_commit(commit_message: str, commit_flag: bool) -> None:
     except IOError as e:
         raise click.ClickException(f"Error writing commit message file: {e}") from e
 
+    final_commit_message = commit_message
     final_commit_message = commit_message
     if not commit_flag:
+        click.secho(
+            f"\n📝 Generated Commit Message:\n{'-' * 40}\n"
+            f"{commit_message}\n{'-' * 40}\n",
+            fg="green",
+        )
+
+        # Interactive loop for Enter-Enter flow
         try:
-            click.edit(filename=commit_msg_path)
-            with open(commit_msg_path, "r") as f:
-                final_commit_message = f.read().strip()
-        except click.UsageError as e:
-            click.secho(f"Could not open editor: {e}", fg="yellow")
-            click.secho(f"Using generated message:\n\n{commit_message}\n", fg="yellow")
-        except IOError as e:
-            raise click.ClickException(
-                f"Error reading commit message file after edit: {e}"
-            ) from e
+            # Default to Yes (Enter)
+            if click.confirm("🚀 Commit with this message?", default=True):
+                pass  # final_commit_message is already set
+            else:
+                if click.confirm("✏️  Edit message?", default=True):
+                    try:
+                        click.edit(filename=commit_msg_path)
+                        with open(commit_msg_path, "r") as f:
+                            final_commit_message = f.read().strip()
+                    except click.UsageError as e:
+                        click.secho(f"Could not open editor: {e}", fg="yellow")
+                else:
+                    raise click.ClickException("Aborted by user.")
+        except click.Abort:
+            raise click.ClickException("Aborted by user.") from None
+        except Exception as e:
+            raise click.ClickException(f"Error handling user input: {e}") from e
 
     if not final_commit_message:
         raise click.ClickException("Aborting commit due to empty commit message.")
@@ -173,6 +155,11 @@ def cli() -> None:
     is_flag=True,
     help="Commit the changes with the generated message",
 )
+@click.option(
+    "--review/--no-review",
+    default=True,
+    help="AI review the diff before generating the commit message (default: enabled)",
+)
 @click.option(
     "--template",
     "-t",
@@ -190,23 +177,42 @@ def cli() -> None:
 @click.option(
     "--model",
     "-m",
-    default="gemini-2.5-pro-preview-03-25",
+    default="gemini-3-flash-preview",
     help=(
-        "Set the engine model (e.g., 'gpt-4', 'claude-3-opus-20240229', "
-        "'gemini-2.5-pro-preview-03-25'). Ensure API key env var is set "
-        "(OPENAI_API_KEY, ANTHROPIC_API_KEY, "
-        "GOOGLE_API_KEY/GEMINI_API_KEY/GOOGLE_GENERATIVE_AI_API_KEY)."
+        "Set the engine model (default: gemini-3-flash-preview). "
+        "Only Google Gemini 3 models are supported "
+        "('gemini-3-flash-preview', 'gemini-3-pro-preview'). "
+        "Ensure GOOGLE_API_KEY is set."
     ),
 )
+@click.option(
+    "--deep",
+    "-d",
+    is_flag=True,
+    help="Use the deeper reasoning model (gemini-3-pro-preview).",
+)
 def generate_message(
     description: Tuple[str, ...],
     commit: bool,
+    review: bool,
     template: Optional[str],
     add: bool,
     model: str,
+    deep: bool = False,
 ) -> None:
     explanation = " ".join(description)
 
+    # Handle Model Selection Logic
+    # 1. Default is gemini-3-flash-preview
+    # 2. If --deep is passed, upgrade to gemini-3-pro-preview
+    # (unless -m is explicitly distinct)
+    if deep:
+        # Upgrade to Pro model if deep flag is set
+        # We override the model unless the user explicitly chose a different one
+        # (For simplicity here, we assume --deep implies pro)
+        if model == "gemini-3-flash-preview":
+            model = "gemini-3-pro-preview"
+
     llm = _initialize_llm(model)
 
     if add:
@@ -222,26 +228,63 @@ def generate_message(
 
     formatted_diff = _prepare_context()
 
+    # Initialize Agent Pipeline
+    agent_pipeline = create_commit_agent(llm)
+
+    # Optional pre-generation review
+    if review:
+        click.secho(
+            "\n\n🔎 Reviewing the staged changes before "
+            "generating a commit message...\n",
+            fg="blue",
+            bold=True,
+        )
+
+        # Only prompt for confirmation when running in an interactive TTY
+        try:
+            is_interactive = sys.stdin.isatty()
+        except Exception:
+            is_interactive = False
+        if is_interactive:
+            if not click.confirm(
+                "Proceed with generating the commit message?", default=True
+            ):
+                raise click.ClickException("Aborted by user after review.")
+
     if template:
         click.secho(
             "⚠️ Warning: The --template/-t option is deprecated. Use environment "
             "variable TEMPLATE_COMMIT or `commitai-create-template` command.",
             fg="yellow",
         )
-    final_template = template or get_commit_template()
 
-    input_message = _build_prompt(explanation, formatted_diff, final_template)
+    # Check for template from env or file if not provided via CLI
+    # (though CLI overrides or is deprecated)
+    # The agent/chain prompt Logic usually handles 'template' variable
+    # if passed in input.
+    # We need to fetch the template content if it exists to pass to agent.
+
+    final_template_content = template
+    if not final_template_content:
+        # Check env var or local file
+        final_template_content = os.getenv("TEMPLATE_COMMIT") or get_commit_template()
 
     click.clear()
     click.secho(
-        "\n\n🧠 Analyzing the changes and generating a commit message...\n\n",
+        "\n\n🧠 internal-monologue: Analyzing changes, "
+        "checking for sensitive data, and summarizing...\n\n",
         fg="blue",
         bold=True,
     )
     try:
         assert llm is not None
-        ai_message = llm.invoke(input=input_message)
-        commit_message = ai_message.content
+        # Invoke the Agent Pipeline
+        inputs = {"diff": formatted_diff, "explanation": explanation}
+        if final_template_content:
+            inputs["template"] = final_template_content
+
+        commit_message = agent_pipeline.invoke(inputs)
+
         if not isinstance(commit_message, str):
             commit_message = str(commit_message)
 
@@ -283,23 +326,42 @@ def create_template_command(template_content: Tuple[str, ...]) -> None:
     is_flag=True,
     help="Commit the changes with the generated message",
 )
+@click.option(
+    "--review/--no-review",
+    default=True,
+    help="AI review the diff before generating the commit message (default: enabled)",
+)
 @click.option(
     "--model",
     "-m",
-    default="gemini-2.5-pro-preview-03-25",
+    default="gemini-3-flash-preview",
     help="Set the engine model to be used.",
 )
+@click.option(
+    "--deep",
+    "-d",
+    is_flag=True,
+    help="Use the deeper reasoning model (gemini-3-pro-preview).",
+)
 @click.pass_context
 def commitai_alias(
     ctx: click.Context,
     description: Tuple[str, ...],
     add: bool,
     commit: bool,
+    review: bool,
     model: str,
+    deep: bool,
 ) -> None:
     """Alias for the 'generate' command."""
     ctx.forward(
-        generate_message, description=description, add=add, commit=commit, model=model
+        generate_message,
+        description=description,
+        add=add,
+        commit=commit,
+        review=review,
+        model=model,
+        deep=deep,
     )
 
 

commitai/template.py

@@ -23,3 +23,24 @@ adding_template = " The message should follow this template: "
 
 def build_user_message(explanation, diff):
     return f"Here is a high-level explanation of the commit: {explanation}\n\n{diff}"
+
+
+def build_review_prompt(explanation: str, formatted_diff: str) -> str:
+    """Builds a review prompt asking the AI to review the diff before message generation.
+
+    The review should highlight:
+    - correctness concerns, risky changes, missing tests or docs
+    - obvious refactors or style violations
+    - a short bullet summary of the changes
+    Keep it concise.
+    """
+    review_system = (
+        "You are a senior code reviewer. You will receive a repository path/branch and a git diff. "
+        "Provide a brief review focusing on potential issues, risks, and improvement suggestions. "
+        "Then provide a very short summary of changes. Keep output as plain text, no markdown code fences."
+    )
+    if explanation:
+        intro = f"High-level explanation: {explanation}\n\n{formatted_diff}"
+    else:
+        intro = formatted_diff
+    return f"{review_system}\n\n{intro}"

{commitai-1.0.5.dist-info → commitai-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commitai
-Version: 1.0.5
+Version: 2.2.2
 Summary: Commitai helps you generate git commit messages using AI
 Project-URL: Bug Tracker, https://github.com/lguibr/commitai/issues
 Project-URL: Documentation, https://github.com/lguibr/commitai/blob/main/README.md
@@ -34,28 +34,25 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Version Control :: Git
 Classifier: Topic :: Utilities
-Requires-Python: >=3.9
-Requires-Dist: click<9.0,>=8.0
-Requires-Dist: langchain-anthropic<=0.3.12,>=0.1.0
-Requires-Dist: langchain-community<=0.3.23,>=0.0.20
-Requires-Dist: langchain-core<=0.3.58,>=0.1.0
-Requires-Dist: langchain-google-genai~=2.1.4
-Requires-Dist: langchain-ollama~=0.3.2
-Requires-Dist: langchain-openai<=0.3.16,>=0.1.0
-Requires-Dist: langchain<=0.3.25,>=0.1.0
-Requires-Dist: pydantic<3.0,>=2.0
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: langchain-community>=0.4.0
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: langchain-google-genai>=1.0
+Requires-Dist: langchain>=1.0
+Requires-Dist: langgraph>=1.0.0
+Requires-Dist: pydantic>=2.0
 Provides-Extra: test
-Requires-Dist: langchain-google-genai~=2.1.4; extra == 'test'
+Requires-Dist: langchain-google-genai>=2.0.0; extra == 'test'
 Requires-Dist: mypy>=1.9.0; extra == 'test'
 Requires-Dist: pytest-cov>=3.0; extra == 'test'
 Requires-Dist: pytest>=7.0; extra == 'test'
-Requires-Dist: ruff==0.4.4; extra == 'test'
+Requires-Dist: ruff>=0.4.4; extra == 'test'
 Requires-Dist: types-setuptools; extra == 'test'
 Description-Content-Type: text/markdown
 
@@ -102,7 +99,7 @@ Simply stage your files and run `commitai`. It analyzes the diff, optionally tak
 
 ## Features
 
-*   🧠 **Intelligent Commit Generation**: Analyzes staged code differences (`git diff --staged`) using state-of-the-art AI models (GPT, Claude, Gemini) to create meaningful commit messages.
+*   🧠 **Intelligent Commit Generation**: Analyzes staged code differences (`git diff --staged`) using state-of-the-art AI models (Gemini, GPT, Claude) to create meaningful commit messages.
 *   📄 **Conventional Commits**: Automatically formats messages according to the Conventional Commits specification (e.g., `feat(auth): add JWT authentication`). This improves readability and enables automated changelog generation.
 *   📝 **Optional Explanations**: Provide a high-level description of your changes as input to guide the AI, or let it infer the context solely from the code diff.
 *   ✅ **Pre-commit Hook Integration**: Automatically runs your existing native Git pre-commit hook (`.git/hooks/pre-commit`) before generating the message, ensuring code quality and style checks pass.
@@ -157,7 +154,7 @@ CommitAi requires API keys for the AI provider you intend to use. Set these as e
     export GOOGLE_API_KEY="your_google_api_key_here"
     ```
 
-You only need to set the key for the provider corresponding to the model you select (or the default, Gemini).
+You only need to set the key for the provider corresponding to the model you select (or the default, Gemini 3 Flash with Google).
 
 ### Ollama
 
@@ -224,14 +221,20 @@ The `commitai` command (which is an alias for `commitai generate`) accepts the f
     *   Example: `commitai -c "Fix typo in documentation"` (for minor changes)
     *   Can be combined with `-a`: `commitai -a -c "Quick fix and commit all"`
 
+*   `--review` / `--no-review`:
+    *   Toggle a preliminary AI review of the staged diff before generating the commit message. Default is `--review` (enabled).
+    *   When enabled, CommitAi prints a brief review and asks if you want to proceed.
+    *   Example: `commitai --no-review` to skip the review step.
+
 *   `-m <model_name>`, `--model <model_name>`:
     *   Specifies which AI model to use.
-    *   Defaults to `gemini-2.5-pro-preview-03-25`.
+    *   Specifies which AI model to use.
+    *   Defaults to `gemini-3-flash-preview`.
     *   Ensure the corresponding API key environment variable is set.
     *   Examples:
+        *   `commitai -m gemini-3-pro-preview "Use Google's Gemini 3 Pro"`
         *   `commitai -m gpt-4 "Use OpenAI's GPT-4"`
-        *   `commitai -m claude-3-opus-20240229 "Use Anthropic's Claude 3 Opus"`
-        *   `commitai -m gemini-2.5-flash-preview-04-17 "Use Google's Gemini 1.5 Flash"`
+        *   `commitai -m claude-3-opus "Use Anthropic's Claude 3 Opus"`
 
 ### Creating Repository Templates
 

commitai-2.2.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+commitai/__init__.py,sha256=6977C2xbYqWwIRHhuFqmyoyI7MaMQmzb3SYtWjIJ4To,388
+commitai/agent.py,sha256=dxTHlxpYWuOQU9purJMoZCWhTszY4pkQhhnXXuWvmWk,8330
+commitai/chains.py,sha256=i5tQL9Qg-kP4yVCiQavhOLS9ljh72bxYALQ27Hoqivc,4612
+commitai/cli.py,sha256=I_3c2q15e3KniprWidqry8ZLJJXg-jAcT2w9wO00_L4,11666
+commitai/git.py,sha256=XWAloZWQuLrFHUyfh3SkOgLsL4kfKRtgj3fzuJjcL2A,1649
+commitai/template.py,sha256=PAS3BUjj6fcdsvSheopU_0xGCLPMj-vvFeZVCNRf0VM,2274
+commitai-2.2.2.dist-info/METADATA,sha256=sdVS1BuvMbvck6vWfNjv4tPrGyMI8RTff6bvhditrz8,13856
+commitai-2.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+commitai-2.2.2.dist-info/entry_points.txt,sha256=qzWJQdPoR38mjQgRPRCB3tA7Kojtj3WrozlFWR4KhLY,128
+commitai-2.2.2.dist-info/licenses/LICENSE,sha256=wVkmSz0UMpGw0xYxk4AmkPLd_tVFcuszTdNIoq02tJA,1087
+commitai-2.2.2.dist-info/RECORD,,

{commitai-1.0.5.dist-info → commitai-2.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

commitai-1.0.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-commitai/__init__.py,sha256=Z5hB8NLKlfi7oPDRcDSQmtPSo_arLjoa6jwjFt3Pb9o,388
-commitai/cli.py,sha256=ClIF6hLekc4gRg9IAUDK9d-y4ee7kvJcZuTt9NCfFRg,9732
-commitai/git.py,sha256=XWAloZWQuLrFHUyfh3SkOgLsL4kfKRtgj3fzuJjcL2A,1649
-commitai/template.py,sha256=q4AO64hKhJP2y9DCc5-ePFoRZfOQBkbkB6vt8CnoMh8,1379
-commitai-1.0.5.dist-info/METADATA,sha256=_wO_IflHPj969OHjwzuQ-kCgV0DPgJ9ChPi8qPjBJPs,13710
-commitai-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-commitai-1.0.5.dist-info/entry_points.txt,sha256=qzWJQdPoR38mjQgRPRCB3tA7Kojtj3WrozlFWR4KhLY,128
-commitai-1.0.5.dist-info/licenses/LICENSE,sha256=wVkmSz0UMpGw0xYxk4AmkPLd_tVFcuszTdNIoq02tJA,1087
-commitai-1.0.5.dist-info/RECORD,,