messygit 0.1.3__tar.gz → 0.2.0__tar.gz

messygit-0.2.0/.claude/worktrees/frosty-montalcini-03d71b/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find /Users/jaydentan/Desktop/projects/messygit -name \"agent.py\" 2>/dev/null)"
+    ]
+  }
+}

messygit-0.2.0/.claude/worktrees/frosty-montalcini-03d71b/.git

@@ -0,0 +1 @@
+gitdir: /Users/jaydentan/Desktop/projects/messygit/.git/worktrees/frosty-montalcini-03d71b

messygit-0.2.0/.claude/worktrees/frosty-montalcini-03d71b/messygit/git.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass
+from subprocess import CompletedProcess
+
+TOKEN_CHAR_ESTIMATE = 4
+MAX_CONTEXT_TOKENS = 60_000
+MAX_CONTEXT_CHARS = MAX_CONTEXT_TOKENS * TOKEN_CHAR_ESTIMATE
+
+NOISE_PATTERNS: tuple[str, ...] = (
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "Pipfile.lock",
+    "poetry.lock",
+    "Cargo.lock",
+    "composer.lock",
+    "Gemfile.lock",
+    "go.sum",
+    ".DS_Store",
+    "Thumbs.db",
+    "*.min.js",
+    "*.min.css",
+    "*.map",
+    "*.bundle.js",
+    "*.chunk.js",
+    "*.pb.go",
+    "*.generated.*",
+    "*.snap",
+)
+
+_DIFF_FILE_HEADER = re.compile(r"^diff --git a/.+ b/(.+)$")
+_HUNK_HEADER = re.compile(r"^@@\s")
+
+
+def _is_noise_file(path: str) -> bool:
+    """Return True if path matches a common build/generated pattern we always skip."""
+    from fnmatch import fnmatch
+
+    name = path.rsplit("/", 1)[-1]
+    for pattern in NOISE_PATTERNS:
+        if fnmatch(name, pattern) or fnmatch(path, pattern):
+            return True
+    return False
+
+
+def _parse_compact_diff(raw_diff: str) -> str:
+    """Parse a -U0 unified diff into a compact per-file changed-lines format.
+
+    Output looks like:
+
+        === path/to/file.py ===
+        + added line
+        - removed line
+        === another/file.ts ===
+        + another addition
+    """
+    lines = raw_diff.splitlines()
+    out: list[str] = []
+    current_file: str | None = None
+    skip_file = False
+
+    for line in lines:
+        header_match = _DIFF_FILE_HEADER.match(line)
+        if header_match:
+            current_file = header_match.group(1)
+            skip_file = _is_noise_file(current_file)
+            if not skip_file:
+                out.append(f"\n=== {current_file} ===")
+            continue
+
+        if skip_file:
+            continue
+
+        if _HUNK_HEADER.match(line):
+            continue
+
+        if line.startswith("+") and not line.startswith("+++"):
+            out.append(line)
+        elif line.startswith("-") and not line.startswith("---"):
+            out.append(line)
+
+    return "\n".join(out).strip()
+
+
+@dataclass
+class FileStat:
+    path: str
+    added: int
+    removed: int
+
+    @property
+    def total_changed(self) -> int:
+        return self.added + self.removed
+
+
+_STAT_LINE_RE = re.compile(
+    r"^\s*(\d+)\s+(\d+)\s+(.+)$"
+)
+
+
+def _get_raw_staged_diff() -> str:
+    result = subprocess.run(
+        ["git", "diff", "--cached", "-U0"],
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout
+
+
+def _get_staged_numstat() -> list[FileStat]:
+    """Run git diff --cached --numstat and parse per-file added/removed counts."""
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--numstat"],
+        capture_output=True,
+        text=True,
+    )
+    stats: list[FileStat] = []
+    for line in result.stdout.strip().splitlines():
+        match = _STAT_LINE_RE.match(line)
+        if not match:
+            continue
+        added_str, removed_str, path = match.groups()
+        if added_str == "-" or removed_str == "-":
+            continue
+        path = path.strip()
+        if _is_noise_file(path):
+            continue
+        stats.append(FileStat(path=path, added=int(added_str), removed=int(removed_str)))
+    return stats
+
+
+def _get_stat_summary() -> str:
+    """Run git diff --cached --stat and return the summary string."""
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--stat"],
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def _compact_diff_for_files(paths: set[str], raw_diff: str) -> str:
+    """Extract compact changed lines only for the given file paths."""
+    raw_lines = raw_diff.splitlines()
+    collected: list[str] = []
+    active_path: str | None = None
+    include = False
+
+    for raw_line in raw_lines:
+        file_match = _DIFF_FILE_HEADER.match(raw_line)
+        if file_match:
+            active_path = file_match.group(1)
+            include = active_path in paths
+            if include:
+                collected.append(f"\n=== {active_path} ===")
+            continue
+
+        if not include:
+            continue
+
+        if _HUNK_HEADER.match(raw_line):
+            continue
+
+        if raw_line.startswith("+") and not raw_line.startswith("+++"):
+            collected.append(raw_line)
+        elif raw_line.startswith("-") and not raw_line.startswith("---"):
+            collected.append(raw_line)
+
+    return "\n".join(collected).strip()
+
+
+def build_staged_context() -> str:
+    """Build the context string sent to the LLM.
+
+    If the full compact diff fits within the token budget, return it as-is.
+    Otherwise, fall back to:
+      - The full --stat summary (file list with bar chart)
+      - Full compact diff of only the most-changed files that fit the budget
+    """
+    raw_diff = _get_raw_staged_diff()
+    full_compact = _parse_compact_diff(raw_diff)
+
+    if len(full_compact) <= MAX_CONTEXT_CHARS:
+        return full_compact
+
+    stat_summary = _get_stat_summary()
+    file_stats = _get_staged_numstat()
+    file_stats.sort(key=lambda fs: fs.total_changed, reverse=True)
+
+    header = (
+        "This diff was too large to include in full. "
+        "Below is the complete --stat summary followed by the full changed lines "
+        "of the most-changed files.\n\n"
+        f"--- stat summary ---\n{stat_summary}\n\n"
+        "--- most-changed files (full changed lines) ---\n"
+    )
+
+    budget = MAX_CONTEXT_CHARS - len(header)
+    selected_paths: set[str] = set()
+    for fs in file_stats:
+        file_diff = _compact_diff_for_files({fs.path}, raw_diff)
+        if len(file_diff) > budget:
+            continue
+        selected_paths.add(fs.path)
+        budget -= len(file_diff)
+
+    if not selected_paths:
+        return header.strip()
+
+    top_files_diff = _compact_diff_for_files(selected_paths, raw_diff)
+    return f"{header}{top_files_diff}"
+
+
+def get_staged_diff() -> str:
+    """Return a compact, changed-lines-only representation of staged changes."""
+    return build_staged_context()
+
+
+def get_staged_files() -> list[str]:
+    """Return list of staged file paths, excluding noise files."""
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--name-only"],
+        capture_output=True,
+        text=True,
+    )
+    files = result.stdout.strip()
+    if not files:
+        return []
+    return [f for f in files.split("\n") if not _is_noise_file(f)]
+
+
+def git_commit(message: str) -> CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "commit", "-m", message],
+        capture_output=True,
+        text=True,
+    )

{messygit-0.1.3 → messygit-0.2.0/.claude/worktrees/frosty-montalcini-03d71b}/messygit/prompts.py

@@ -3,9 +3,9 @@ You are a git commit message generator. Your sole purpose is to produce \
 a single Conventional Commits subject line from staged changes.
 
 # Input format
-You will receive a compact summary of staged changes, NOT a raw unified diff. \
-The format is:
+You will receive staged changes in one of two formats:
 
+## Format A — full compact diff (small changes)
 === path/to/file.py ===
 + added line
 - removed line
@@ -16,6 +16,15 @@ Each "=== filename ===" header marks the file that the following +/- lines \
 belong to. Lines starting with "+" were added; lines starting with "-" were \
 removed. Context lines and diff metadata are already stripped.
 
+## Format B — truncated large diff
+When the diff exceeds the token budget, you receive:
+1. A note explaining the diff was too large.
+2. The complete `git diff --stat` summary (file list with insertions/deletions bar chart).
+3. Full changed lines for the most-changed files only.
+
+Use the stat summary to understand the overall scope, then use the detailed \
+changed lines to infer what the commit actually does.
+
 # Output rules (absolute, no exceptions)
 - Output EXACTLY one line: type(scope): description
 - No markdown, no quotes, no code fences, no bullet points, no explanation.

{messygit-0.1.3 → messygit-0.2.0/.claude/worktrees/frosty-montalcini-03d71b}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "messygit"
-version = "0.1.3"
+version = "0.1.4"
 description = "CLI that drafts Conventional Commits from staged git diffs with Claude, then commit, cancel, or edit."
 readme = "README.md"
 requires-python = ">=3.10"

messygit-0.2.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+*.egg-info/

messygit-0.2.0/ARCHITECTURE.md

@@ -0,0 +1,48 @@
+# Architecture
+
+This document describes the purpose of each file in the `messygit` project.
+
+## Root
+
+
+| File             | Purpose                                                                                                                        |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `pyproject.toml` | Package metadata, dependencies (`anthropic`, `click`), build system (hatchling), and the `messygit` console script entrypoint. |
+| `README.md`      | User-facing documentation: install, usage, commands, and development instructions.                                             |
+| `.gitignore`     | Keeps `.venv/`, `__pycache__/`, `dist/`, and `*.egg-info/` out of version control.                                             |
+
+
+## `messygit/` (Python package)
+
+
+| File          | Purpose                                                                                                                                                                                                                                                                  |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `__init__.py` | Marks the directory as a Python package (empty).                                                                                                                                                                                                                         |
+| `cli.py`      | Click CLI entrypoint. Defines the command group (`main`), the default commit flow (generate → prompt Y/n/e → commit), and subcommands (`config`, `show`). Orchestrates all other modules.                                                                                |
+| `git.py`      | All subprocess calls to `git`. Reads staged diffs (`git diff --cached -U0`), parses them into a compact changed-lines format, filters noise files, handles the large-diff fallback (stat summary + top-N most-changed files), and runs `git commit -m`.                  |
+| `llm.py`      | Anthropic SDK integration. Creates the client with the resolved API key, calls `messages.create`, extracts the text response, and maps SDK exceptions (`AuthenticationError`, `PermissionDeniedError`, `BadRequestError`, billing 402) into user-friendly error classes. |
+| `config.py`   | API key storage and resolution. Reads/writes `~/.messygit/config.json`, checks the `ANTHROPIC_API_KEY` env var, validates keys are non-empty, masks keys for display, and defines all user-facing error messages and exception classes.                                  |
+| `prompts.py`  | System prompt and user prompt builder. Contains the full Conventional Commits instructions, input format descriptions (full and truncated), security rules, and the function that wraps staged changes into the user message sent to Claude.                             |
+
+
+## Data flow
+
+```
+User runs `messygit`
+       │
+       ▼
+   cli.py ──► git.py (read staged diff, apply token budget)
+       │
+       ▼
+   cli.py ──► llm.py (send context to Claude)
+       │           │
+       │           ├── config.py (resolve API key)
+       │           └── prompts.py (system + user prompt)
+       │
+       ▼
+   cli.py (display message, prompt Y/n/e)
+       │
+       ▼
+   cli.py ──► git.py (git commit -m "...")
+```
+

{messygit-0.1.3 → messygit-0.2.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: messygit
-Version: 0.1.3
-Summary: CLI that drafts Conventional Commits from staged git diffs with Claude, then commit, cancel, or edit.
+Version: 0.2.0
+Summary: Interactive CLI that turns messy git workflows into clean Conventional Commits — stage, commit, push, as well as agentic functionality, all from one interface.
 License-Expression: MIT
 Requires-Python: >=3.10
 Requires-Dist: anthropic>=0.39.0

messygit-0.2.0/README.md

@@ -0,0 +1,105 @@
+# messygit
+
+**messygit** is a command-line tool that reads your **staged** Git changes, asks **Claude** (via the [Anthropic API](https://www.anthropic.com/api)) to suggest a **Conventional Commits** subject line, and then lets you **commit**, **cancel**, or **edit** the message before running `git commit`.
+
+## Why use it
+
+- Keeps commit subjects consistent (`feat(scope): describe the change`) without thinking up wording from scratch.
+- Only the **staged** diff is sent to the model—what you `git add` is what gets summarized.
+- The API key is never printed in full; `show` uses a masked preview.
+- Clear errors for missing keys, rejected keys, and billing or zero-balance situations.
+
+## Requirements
+
+- **Python** 3.10 or newer  
+- **Git** (run inside a repository)  
+- An **Anthropic API key** with access to the Messages API  
+
+## Installation
+
+```bash
+pip install messygit
+```
+
+This installs the `messygit` command (see `[project.scripts]` in `pyproject.toml`).
+
+### Install from source
+
+From a checkout of this project:
+
+```bash
+cd messygit
+python -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -e .
+```
+
+## API key
+
+messygit resolves the key in this order:
+
+1. Environment variable **`ANTHROPIC_API_KEY`**
+2. Config file **`~/.messygit/config.json`** (written by `messygit config`)
+
+If neither is set, the default command exits with a short message explaining how to fix it.
+
+**Save a key to the config file:**
+
+```bash
+messygit config --key YOUR_ANTHROPIC_API_KEY
+```
+
+**Show a masked key** (which source is active, without revealing the secret):
+
+```bash
+messygit show
+```
+
+## Usage
+
+Typical flow:
+
+```bash
+git add .
+messygit
+```
+
+1. If there is nothing staged, messygit tells you to run `git add` first.  
+2. Otherwise it sends the staged diff to Claude and prints a suggested one-line message.  
+3. You are prompted: **commit** (default), **no** (cancel), or **edit** (open `$EDITOR` to change the message).  
+4. On confirmation, it runs `git commit -m "..."` with your chosen text.
+
+### Commands
+
+| Command | Description |
+|--------|-------------|
+| `messygit` | Generate a message from `git diff --staged`, then prompt to commit / cancel / edit. |
+| `messygit config --key KEY` | Store the Anthropic API key under `~/.messygit/config.json`. |
+| `messygit show` | Print a masked API key and whether it comes from the environment or config file. |
+
+### Commit message style
+
+The model is instructed to follow **Conventional Commits**, for example:
+
+`feat(auth): validate refresh tokens`
+
+Allowed types include: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`. Subjects are one line, imperative, lowercase, no trailing period, and kept within a reasonable length (see your prompts in the package if you customize behavior).
+
+## Development
+
+Without installing the package, from the **repository root** (the directory that contains the `messygit` package folder):
+
+```bash
+.venv/bin/python -m messygit.cli
+```
+
+Subcommands:
+
+```bash
+python -m messygit.cli config --key YOUR_KEY
+python -m messygit.cli show
+```
+
+## License
+
+MIT (see `pyproject.toml`).

messygit-0.2.0/messygit/agent/agent.py

@@ -0,0 +1,79 @@
+from .tool import Tool
+from anthropic import (
+    Anthropic,
+    APIStatusError,
+    AuthenticationError,
+    BadRequestError,
+    PermissionDeniedError,
+)
+
+from ..config import (
+    FORBIDDEN_API_KEY_MESSAGE,
+    INVALID_API_KEY_MESSAGE,
+    AnthropicInsufficientBalanceError,
+    InvalidAnthropicCredentialsError,
+    resolve_api_key,
+)
+from ..llm import _is_insufficient_balance_or_billing, _insufficient_balance_user_message, _text_from_message
+
+DEFAULT_MODEL = "claude-haiku-4-5-20251001"
+DEFAULT_MAX_TOKENS = 4096
+
+class Agent:
+    def __init__(self, name: str, system_prompt: str, max_iterations: int, tools: list[Tool]):
+        self.name = name
+        self.system_prompt = system_prompt
+        self.max_iterations = max_iterations
+        self.tools = tools
+
+    def run(self, user_input: str) -> str:
+        """Run the agent."""
+        client = Anthropic(api_key=resolve_api_key())
+        messages = []
+        try:
+            messages.append({"role": "user", "content": user_input})
+            response = None
+            for i in range(self.max_iterations):
+                response = client.messages.create(
+                    model=DEFAULT_MODEL,
+                    max_tokens=DEFAULT_MAX_TOKENS,
+                    tools=[t.to_schema() for t in self.tools],
+                    tool_choice={"type": "auto"},
+                    system=self.system_prompt,
+                    messages=messages,
+                )
+                messages.append({"role": "assistant", "content": response.content})
+
+                tool_use_blocks = [b for b in response.content if b.type == "tool_use"]
+                if not tool_use_blocks:
+                    break
+
+                tool_results = []
+                for block in tool_use_blocks:
+                    tool = next(t for t in self.tools if t.name == block.name)
+                    result = tool.run(**block.input)
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": str(result),
+                    })
+                messages.append({"role": "user", "content": tool_results})
+        except AuthenticationError as e:
+            raise InvalidAnthropicCredentialsError(INVALID_API_KEY_MESSAGE) from e
+        except PermissionDeniedError as e:
+            raise InvalidAnthropicCredentialsError(FORBIDDEN_API_KEY_MESSAGE) from e
+        except BadRequestError as e:
+            if _is_insufficient_balance_or_billing(e):
+                raise AnthropicInsufficientBalanceError(
+                    _insufficient_balance_user_message(e)
+                ) from e
+            raise
+        except APIStatusError as e:
+            if _is_insufficient_balance_or_billing(e):
+                raise AnthropicInsufficientBalanceError(
+                    _insufficient_balance_user_message(e)
+                ) from e
+            raise
+        if not response:
+            return "No response from the agent."
+        return _text_from_message(response)

messygit-0.2.0/messygit/agent/tool.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+@dataclass
+class Tool:
+    """A tool that an Agent can invoke, wrapping a plain Python function."""
+
+    name: str
+    description: str
+    function: Callable[..., Any]
+    parameters: dict[str, Any] = field(default_factory=dict)
+
+    def run(self, **kwargs: Any) -> Any:
+        return self.function(**kwargs)
+
+    def to_schema(self) -> dict[str, Any]:
+        """Return an Anthropic-compatible tool schema for API calls."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": {
+                "type": "object",
+                "properties": self.parameters,
+            },
+        }

messygit-0.2.0/messygit/agent/tools.py

@@ -0,0 +1,82 @@
+import os
+from .tool import Tool
+from ..git import get_staged_diff, get_staged_files
+import subprocess
+
+ALLOWED_GIT_COMMANDS = ["log", "diff", "status", "show", "status", "shortlog", "blame"]
+
+def run_git(args: list[str]) -> str:
+    if not args or args[0] not in ALLOWED_GIT_COMMANDS:
+        return "Invalid git command."
+    result = subprocess.run(["git", *args], capture_output=True, text=True)
+    return result.stdout or result.stderr
+
+run_git_tool = Tool(
+    name="run_git",
+    description="Run a git command",
+    function=run_git,
+    parameters={
+        "args": {
+            "type": "array",
+            "items": {"type": "string"},
+        },
+    },
+)
+
+def read_file(path: str) -> str:
+    try:
+        with open(path, "r") as file:
+            return file.read()
+    except FileNotFoundError:
+        return "File not found."
+    except PermissionError:
+        return "Permission denied."
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+read_file_tool = Tool(
+    name="read_file",
+    description="Read a file",
+    function=read_file,
+    parameters={
+        "path": {
+            "type": "string",
+        },
+    },
+)
+
+def list_directory(path: str) -> list[str]:
+    try:
+        return os.listdir(path)
+    except FileNotFoundError:
+        return "Directory not found."
+    except PermissionError:
+        return "Permission denied."
+    except Exception as e:
+        return f"Error listing directory: {e}"
+
+list_directory_tool = Tool(
+    name="list_directory", 
+    description="List a directory",
+    function=list_directory,
+    parameters={
+        "path": {
+            "type": "string",
+        },
+    },
+)
+
+def search_code(query: str) -> str:
+    result = subprocess.run(["git", "grep", "-n", query], capture_output=True, text=True)
+    return result.stdout or result.stderr
+
+search_code_tool = Tool(
+    name="search_code",
+    description="Search the codebase for a query",
+    function=search_code,
+    parameters={
+        "query": {
+            "type": "string",
+        },
+    },
+)