commitai 1.0.5__tar.gz → 2.2.2__tar.gz

{commitai-1.0.5 → commitai-2.2.2}/.github/workflows/main.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12"]
 
     steps:
     - name: Check out code

{commitai-1.0.5 → commitai-2.2.2}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version. Must be aligned with the version in pyproject.toml
-    rev: v0.4.4 # Choose a specific Ruff version
+    rev: v0.15.0 # Match local version
     hooks:
       # Run the linter. Applies fixes including import sorting, etc.
       - id: ruff
@@ -25,16 +25,15 @@ repos:
     hooks:
       - id: mypy
         # Ensure mypy runs with the necessary dependencies installed
-        additional_dependencies: [
-            "click>=8.0,<9.0",
-            "langchain>=0.1.0,<0.3.0",
-            "langchain-community>=0.0.20,<0.2.0",
-            "langchain-anthropic>=0.1.0,<0.3.0",
-            "langchain-openai>=0.1.0,<0.3.0",
-            "langchain-google-genai~=0.0.9",
-            "pydantic>=2.0,<3.0",
-            "types-setuptools"
-        ]
+        additional_dependencies:
+          - "click>=8.0,<9.0"
+          - "langchain>=1.0"
+          - "langchain-core>=1.0"
+          - "langchain-community>=0.4.0"
+          - "langchain-google-genai>=1.0"
+          - "langgraph>=1.0.0"
+          - "pydantic>=2.0,<3.0"
+          - "types-setuptools"
         args: [--config-file=pyproject.toml] # Point mypy to the config
         # You might need to adjust entry if your structure changes
         # entry: mypy commitai commitai/tests

{commitai-1.0.5 → commitai-2.2.2}/PKG-INFO

@@ -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-1.0.5 → commitai-2.2.2}/README.md

@@ -41,7 +41,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.
@@ -96,7 +96,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
 
@@ -163,14 +163,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-1.0.5 → commitai-2.2.2}/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-2.2.2/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-2.2.2/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