cmt-cli 0.1.0__tar.gz

cmt_cli-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# IDE files
+.idea/

cmt_cli-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

cmt_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bijay Das
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmt_cli-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.5
+Name: cmt-cli
+Version: 0.1.0
+Summary: AI-powered Git commit message generator
+Author-email: Bijay Das <me@bijaydas.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: langchain-openai>=1.6.0
+Requires-Dist: langchain>=1.3.18
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: typer>=0.27.1
+Description-Content-Type: text/markdown
+
+# cmt
+
+`cmt` is a CLI tool that checks the currently staged Git changes and suggests a professional commit message.
+
+## License
+
+MIT

cmt_cli-0.1.0/README.md

@@ -0,0 +1,7 @@
+# cmt
+
+`cmt` is a CLI tool that checks the currently staged Git changes and suggests a professional commit message.
+
+## License
+
+MIT

cmt_cli-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "cmt-cli"
+version = "0.1.0"
+description = "AI-powered Git commit message generator"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Bijay Das", email = "me@bijaydas.com" },
+]
+dependencies = [
+    "langchain>=1.3.18",
+    "langchain-openai>=1.6.0",
+    "pydantic>=2.13.4",
+    "typer>=0.27.1",
+]
+
+[project.scripts]
+cmt = "cmt.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+keywords = ["ai", "git", "commit", "message", "generator"]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.16.5",
+]
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src"]
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle errors
+    "F", # pyflakes
+    "I", # isort (import sorting)
+    "UP", # pyupgrade (modern syntax)
+    "B", # flake8-bugbear (common bugs)
+    "SIM", # flake8-simplify
+]
+ignore = []
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.hatch.build.targets.wheel]
+include = ["src/cmt"]

cmt_cli-0.1.0/src/cmt/ai/cache.py

@@ -0,0 +1,28 @@
+import hashlib
+import json
+from pathlib import Path
+
+from cmt.config.settings import Settings
+from cmt.models.suggestion import CommitSuggestion
+
+
+class CommitMessageCache:
+    def __init__(self):
+        self.cache_dir = Path(Settings().CACHE_DIR)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _key(diff: str, model: str) -> str:
+        return hashlib.sha256(f"{diff}-{model}".encode()).hexdigest()
+
+    def set(self, diff: str, model: str, commit: CommitSuggestion):
+        key = CommitMessageCache._key(diff, model)
+        cache_file = self.cache_dir / key
+        cache_file.write_text(commit.model_dump_json())
+
+    def get(self, diff: str, model: str) -> CommitSuggestion | None:
+        key = CommitMessageCache._key(diff, model)
+        cache_file = self.cache_dir / key
+        if cache_file.exists():
+            return CommitSuggestion(**json.loads(cache_file.read_text()))
+        return None

cmt_cli-0.1.0/src/cmt/ai/openai.py

@@ -0,0 +1,86 @@
+from langchain.agents import create_agent
+from langchain_openai import ChatOpenAI
+from pydantic import SecretStr
+
+from cmt.ai.cache import CommitMessageCache
+from cmt.ai.prompt import COMMIT_PROMPT, COMMIT_SYSTEM_PROMPT
+from cmt.ai.provider import AIProvider
+from cmt.config.settings import Settings
+from cmt.models.changes import AnalysisResult, StagedChangeSet, StagedFile
+from cmt.models.suggestion import CommitSuggestion
+
+
+class OpenAIProvider(AIProvider):
+    def __init__(self) -> None:
+        settings = Settings()
+        self.config = settings.get()
+
+    def _build_prompt(
+        self,
+        changes: StagedChangeSet,
+        analysis: AnalysisResult
+    ) -> str:
+        staged_files = self._process_files(changes.files)
+        staged_diffs = changes.diff
+
+        return COMMIT_PROMPT.format_messages(
+            total_files=len(changes.files),
+            added_files=analysis.added_files,
+            modified_files=analysis.modified_files,
+            deleted_files=analysis.deleted_files,
+            renamed_files=analysis.renamed_files,
+            staged_files=staged_files,
+            staged_diffs=staged_diffs
+        )
+
+    @staticmethod
+    def _process_files(files: list[StagedFile]) -> str:
+        output = ""
+        for file in files:
+            output += f"{file.status} {file.path}\n"
+
+        return output.strip()
+
+    def _invoke(self, prompt: str) -> CommitSuggestion:
+        model = ChatOpenAI(
+            model=self.config.model,
+            api_key=SecretStr(self.config.api_key),
+            timeout=30,
+            max_tokens=1200,
+        )
+
+        agent = create_agent(
+            model=model,
+            system_prompt=COMMIT_SYSTEM_PROMPT,
+            response_format=CommitSuggestion,
+        )
+
+        result = agent.invoke({"messages": prompt})
+
+        return result["structured_response"]
+
+    def generate_commit_message(
+        self,
+        change_set: StagedChangeSet,
+        analysis: AnalysisResult
+    ) -> CommitSuggestion:
+        prompt = self._build_prompt(change_set, analysis)
+
+        cache = CommitMessageCache()
+        cached_message = cache.get(change_set.diff, self.config.model)
+
+        if cached_message:
+            return CommitSuggestion(
+                message=cached_message.message,
+                description=cached_message.description
+            )
+
+        suggestion = self._invoke(prompt)
+
+        cache.set(change_set.diff, self.config.model, suggestion)
+
+        return suggestion
+
+    @staticmethod
+    def commit_command(commit_suggestion: CommitSuggestion) -> str:
+        return f"{commit_suggestion.message} \n\n{commit_suggestion.description}"

cmt_cli-0.1.0/src/cmt/ai/prompt.py

@@ -0,0 +1,66 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+COMMIT_SYSTEM_PROMPT = """You are an expert software engineer responsible for generating Git commit
+messages.
+
+Your task is to analyze the staged Git changes provided below and generate the most appropriate
+commit message.
+
+## Rules
+
+1. Base the commit message ONLY on the provided staged changes.
+2. Do not invent functionality, behavior, or intent.
+3. Identify the primary purpose of the changes.
+4. If multiple files are changed, determine whether they represent one coherent change.
+5. If the changes are unrelated or miscellaneous, use an appropriate general commit type
+such as `chore`.
+6. Follow the Conventional Commits specification.
+7. Use one of these commit types when appropriate:
+   - feat
+   - fix
+   - refactor
+   - docs
+   - test
+   - chore
+   - perf
+   - build
+   - ci
+   - style
+8. Add a scope only when the affected area is clear.
+9. Keep the commit message concise.
+10. Use imperative mood.
+11. Do not mention individual files unless necessary.
+12. Do not generate multiple commit messages.
+13. Do not include a commit body.
+14. Return ONLY the commit message.
+15. Do not include markdown, quotes, explanations, or additional text.
+
+## Commit message format
+
+<type>[optional scope]: <short description>
+"""
+
+COMMIT_DATA_PROMPT = """## Change statistics
+
+Total files: {total_files}
+Added: {added_files}
+Modified: {modified_files}
+Deleted: {deleted_files}
+Renamed: {renamed_files}
+
+## Staged files
+
+{staged_files}
+
+## Staged Git diff
+
+{staged_diffs}
+
+Generate the commit message now.
+"""
+
+COMMIT_PROMPT = ChatPromptTemplate.from_messages(
+    [
+        ("human", COMMIT_DATA_PROMPT),
+    ]
+)

cmt_cli-0.1.0/src/cmt/ai/provider.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from cmt.models.changes import AnalysisResult, StagedChangeSet
+from cmt.models.suggestion import CommitSuggestion
+
+
+class AIProvider(ABC):
+    @abstractmethod
+    def generate_commit_message(
+        self,
+        change_set: StagedChangeSet,
+        analysis: AnalysisResult
+    ) -> CommitSuggestion:
+        pass

cmt_cli-0.1.0/src/cmt/analysis/analyzer.py

@@ -0,0 +1,29 @@
+from cmt.models.changes import AnalysisResult, StagedChangeSet
+
+
+class Analyzer:
+    def analyze(self, change_set: StagedChangeSet) -> AnalysisResult:
+        added = 0
+        modified = 0
+        deleted = 0
+        renamed = 0
+        total = 0
+
+        for file in change_set.files:
+            total += 1
+            if file.status == "A":
+                added += 1
+            elif file.status == "M":
+                modified += 1
+            elif file.status == "D":
+                deleted += 1
+            elif file.status == "R":
+                renamed += 1
+
+        return AnalysisResult(
+            total_files=total,
+            added_files=added,
+            modified_files=modified,
+            deleted_files=deleted,
+            renamed_files=renamed,
+        )

cmt_cli-0.1.0/src/cmt/cli.py

@@ -0,0 +1,85 @@
+import typer
+
+from cmt.ai.openai import OpenAIProvider
+from cmt.analysis.analyzer import Analyzer
+from cmt.config.settings import OpenAIConfig, Settings
+from cmt.exceptions import CmtError
+from cmt.git.repository import Repository
+from cmt.utils import edit_with_vim
+
+app = typer.Typer()
+
+
+@app.command()
+def suggest() -> None:
+    try:
+        repository = Repository()
+        analyzer = Analyzer()
+
+        if not repository.is_git_repository():
+            raise CmtError("Not a git repository.")
+
+        staged_files = repository.get_staged_changes()
+
+        if not staged_files.files:
+            typer.echo(
+                "No staged files found. Please stage your changes before running this command."
+            )
+            raise typer.Exit(code=0)
+
+        analysis_result = analyzer.analyze(staged_files)
+
+        open_ai = OpenAIProvider()
+
+        commit = open_ai.generate_commit_message(staged_files, analysis_result)
+        commit_command = OpenAIProvider.commit_command(commit)
+
+        typer.echo(f"Suggested commit:\n\n{commit_command}")
+
+        while True:
+            action = (
+                typer.prompt("\nUse this message? [y]es / [e]dit / [n]o", default="y")
+                .strip()
+                .lower()[0]
+            )
+
+            if action == "n":
+                typer.echo("Aborted.")
+                break
+
+            if action == "e":
+                commit_command = edit_with_vim(commit_command)
+                typer.echo(f"Edited commit:\n\n{commit_command}")
+
+            if action == "y":
+                result = repository.commit(commit_command)
+                typer.echo(f"Commit result:\n\n{result.stdout}")
+                break
+
+    except CmtError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1) from None
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        typer.echo("\nOperation cancelled by user.", err=True)
+        raise typer.Exit(code=1) from None
+    except Exception as e:
+        typer.echo(f"Unexpected error: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+
+@app.command()
+def config(task: str) -> None:
+    if task == "set":
+        settings = Settings()
+
+        open_ai_key = typer.prompt("Enter your OpenAI API key")
+        open_ai_model = typer.prompt(
+            "Enter your OpenAI model", default=settings.OPEN_AI_DEFAULT_MODEL
+        )
+        settings.set(OpenAIConfig(api_key=open_ai_key, model=open_ai_model))
+
+
+if __name__ == "__main__":
+    app()

cmt_cli-0.1.0/src/cmt/config/settings.py

@@ -0,0 +1,58 @@
+from configparser import ConfigParser
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from cmt.exceptions import ConfigurationError
+
+
+class OpenAIConfig(BaseModel):
+    api_key: str
+    model: str
+
+
+class Settings:
+    CONFIG_DIR: Path = Path.home() / ".config" / "cmt"
+    CACHE_DIR: Path = CONFIG_DIR / "cache"
+
+    CONFIG_FILE: Path = CONFIG_DIR / "config.ini"
+    OPEN_AI_DEFAULT_MODEL: str = "gpt-4o-mini"
+
+    def set(self, openai_config: OpenAIConfig):
+        self.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+        config = ConfigParser()
+        config["openai"] = {
+            "api_key": openai_config.api_key,
+            "model": openai_config.model
+        }
+
+        with open(self.CONFIG_FILE, "w") as f:
+            config.write(f)
+
+    def get(self) -> OpenAIConfig:
+        if not self.CONFIG_FILE.exists():
+            raise FileNotFoundError(
+                "Configuration file not found. Run `cmt config set` to set it up."
+            )
+
+        config = ConfigParser()
+        config.read(self.CONFIG_FILE)
+
+        api_key = config["openai"].get("api_key")
+        model = config["openai"].get("model")
+
+        if not api_key:
+            raise ConfigurationError(
+                "API key not found in the configuration. Run `cmt config set` to set it up."
+            )
+
+        if not model:
+            raise ConfigurationError(
+                "Model not found in the configuration. Run `cmt config set` to set it up."
+            )
+
+        return OpenAIConfig(
+            api_key=api_key,
+            model=model
+        )

cmt_cli-0.1.0/src/cmt/exceptions.py

@@ -0,0 +1,14 @@
+class CmtError(Exception):
+    """Base exception for expected cmt errors."""
+
+
+class ConfigurationError(CmtError):
+    """Raised when cmt configuration is missing or invalid."""
+
+
+class GitError(CmtError):
+    """Raised when a Git operation fails."""
+
+
+class AIError(CmtError):
+    """Raised when AI processing fails."""

cmt_cli-0.1.0/src/cmt/git/repository.py

@@ -0,0 +1,50 @@
+import subprocess
+from pathlib import Path
+
+from cmt.models.changes import StagedChangeSet, StagedFile
+
+
+class Repository:
+    def __init__(self, root: Path | None = None):
+        self.root = Path(root) if root is not None else Path.cwd()
+
+    def _execute(self, command: list[str]) -> subprocess.CompletedProcess:
+        return subprocess.run(
+            command,
+            cwd=self.root,
+            capture_output=True,
+            check=True,
+            text=True
+        )
+
+    def is_git_repository(self):
+        try:
+            result = self._execute(["git", "rev-parse", "--is-inside-work-tree"])
+            return result.stdout.strip() == "true"
+        except subprocess.CalledProcessError:
+            return False
+
+    def _get_staged_files(self) -> list[StagedFile]:
+        result = self._execute(["git", "diff", "--name-status", "--cached"])
+
+        files: list[StagedFile] = []
+
+        for line in result.stdout.splitlines():
+            _line = line.split("\t", 1)
+            status, path = _line
+            files.append(StagedFile(status=status, path=path))
+
+        return files
+
+    def _get_staged_diff(self) -> str:
+        result = self._execute(["git", "diff", "--cached"])
+        return result.stdout
+
+    def get_staged_changes(self) -> StagedChangeSet:
+        return StagedChangeSet(
+            files=self._get_staged_files(),
+            diff=self._get_staged_diff()
+        )
+
+    def commit(self, message: str) -> subprocess.CompletedProcess:
+        return self._execute(["git", "commit", "-m", message])

cmt_cli-0.1.0/src/cmt/models/changes.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+
+class StagedFile(BaseModel):
+    status: str
+    path: str
+
+class StagedChangeSet(BaseModel):
+    files: list[StagedFile]
+    diff: str
+
+class AnalysisResult(BaseModel):
+    total_files: int
+    added_files: int
+    modified_files: int
+    deleted_files: int
+    renamed_files: int

cmt_cli-0.1.0/src/cmt/models/suggestion.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class CommitSuggestion(BaseModel):
+    message: str
+    description: str

cmt_cli-0.1.0/src/cmt/utils.py

@@ -0,0 +1,14 @@
+import subprocess
+import tempfile
+
+
+def edit_with_vim(message: str) -> str:
+    with tempfile.NamedTemporaryFile(
+        mode="w+",
+        delete=False
+    ) as tmp_file:
+        tmp_file.write(message)
+        tmp_file.flush()
+        subprocess.run(["vim", tmp_file.name], check=True)
+        tmp_file.seek(0)
+        return tmp_file.read().strip()