messygit 0.1.4__tar.gz → 0.2.1__tar.gz

messygit-0.2.1/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

messygit-0.2.1/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.2.1/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: messygit
+Version: 0.2.1
+Summary: An AI-powered interactive git CLI with agentic tools for commits, code suggestions, and workflow automation.
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.39.0
+Requires-Dist: click>=8.0
+Description-Content-Type: text/markdown
+
+# messygit
+
+**messygit** is an interactive CLI that turns messy git workflows into clean Conventional Commits — stage, commit, push, and get AI-powered project suggestions, all from one interface powered by [Claude](https://www.anthropic.com/api).
+
+## Why use it
+
+- **Interactive REPL** — one command drops you into a persistent session where you can stage, commit, push, and more without leaving.
+- **AI commit messages** — sends your staged diff to Claude and suggests a clean Conventional Commits subject line.
+- **Project suggestions** — an AI agent inspects your repo and recommends concrete next steps.
+- **Safe by default** — only the staged diff is sent to the model. Your API key is never printed in full.
+
+## 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
+```
+
+### Install from source
+
+```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`**
+
+You can set the key from within the messygit interface:
+
+```
+messygit > config YOUR_ANTHROPIC_API_KEY
+```
+
+## Usage
+
+```bash
+messygit
+```
+
+This drops you into the interactive interface:
+
+```
+ mmm    mmm  eeeeeee  sssssss  sssssss  yy   yy  ggggggg  ii  tttttttt
+ mm mm mm m  ee       ss       ss        yy yy   gg       ii     tt
+ mm  mmm  m  eeeee    sssssss  sssssss    yyy    gg  ggg  ii     tt
+ mm       m  ee            ss       ss    yy     gg   gg  ii     tt
+ mm       m  eeeeeee  sssssss  sssssss   yy      ggggg   ii     tt
+
+Type 'help' for commands, 'quit' to exit.
+
+messygit >
+```
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `add <file>` or `add .` | Stage files for commit |
+| `commit` | Generate an AI commit message from staged changes, then commit / cancel / edit |
+| `push` | Push commits to remote |
+| `suggestion` | Get AI-powered next-step suggestions for your project |
+| `config <key>` | Save your Anthropic API key to `~/.messygit/config.json` |
+| `show` | Display a masked API key and its source |
+| `help` | List available commands |
+| `quit` / `exit` | Exit messygit |
+
+### Typical flow
+
+```
+messygit > add .
+Staged everything
+
+messygit > commit
+feat(cli): add interactive REPL with ASCII banner
+Commit with this message? [y/n/e] y
+
+messygit > push
+```
+
+### Commit message style
+
+The model follows **Conventional Commits**: `type(scope): description`
+
+Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`. Subjects are one line, imperative, lowercase, no trailing period.
+
+## Publishing to PyPI
+
+This project uses GitHub Actions with [PyPI trusted publishing](https://docs.pypi.org/trusted-publishers/) — no API tokens needed in your repo.
+
+### One-time setup
+
+1. Go to your project on [pypi.org](https://pypi.org/manage/project/messygit/settings/publishing/)
+2. Add a **Trusted Publisher**:
+   - **Owner:** your GitHub username
+   - **Repository:** `messygit`
+   - **Workflow name:** `publish.yml`
+   - **Environment:** leave blank
+
+### To release a new version
+
+1. Bump `version` in `pyproject.toml`
+2. Commit and push
+3. Create a GitHub release:
+
+```bash
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+4. Go to GitHub → Releases → Draft a new release → select the tag → Publish
+
+The workflow at `.github/workflows/publish.yml` will automatically build and upload to PyPI.
+
+### Manual publish (without CI)
+
+```bash
+rm -rf dist/
+python -m build
+twine upload dist/*
+```
+
+## License
+
+MIT (see `pyproject.toml`).

messygit-0.2.1/README.md

@@ -0,0 +1,136 @@
+# messygit
+
+**messygit** is an interactive CLI that turns messy git workflows into clean Conventional Commits — stage, commit, push, and get AI-powered project suggestions, all from one interface powered by [Claude](https://www.anthropic.com/api).
+
+## Why use it
+
+- **Interactive REPL** — one command drops you into a persistent session where you can stage, commit, push, and more without leaving.
+- **AI commit messages** — sends your staged diff to Claude and suggests a clean Conventional Commits subject line.
+- **Project suggestions** — an AI agent inspects your repo and recommends concrete next steps.
+- **Safe by default** — only the staged diff is sent to the model. Your API key is never printed in full.
+
+## 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
+```
+
+### Install from source
+
+```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`**
+
+You can set the key from within the messygit interface:
+
+```
+messygit > config YOUR_ANTHROPIC_API_KEY
+```
+
+## Usage
+
+```bash
+messygit
+```
+
+This drops you into the interactive interface:
+
+```
+ mmm    mmm  eeeeeee  sssssss  sssssss  yy   yy  ggggggg  ii  tttttttt
+ mm mm mm m  ee       ss       ss        yy yy   gg       ii     tt
+ mm  mmm  m  eeeee    sssssss  sssssss    yyy    gg  ggg  ii     tt
+ mm       m  ee            ss       ss    yy     gg   gg  ii     tt
+ mm       m  eeeeeee  sssssss  sssssss   yy      ggggg   ii     tt
+
+Type 'help' for commands, 'quit' to exit.
+
+messygit >
+```
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `add <file>` or `add .` | Stage files for commit |
+| `commit` | Generate an AI commit message from staged changes, then commit / cancel / edit |
+| `push` | Push commits to remote |
+| `suggestion` | Get AI-powered next-step suggestions for your project |
+| `config <key>` | Save your Anthropic API key to `~/.messygit/config.json` |
+| `show` | Display a masked API key and its source |
+| `help` | List available commands |
+| `quit` / `exit` | Exit messygit |
+
+### Typical flow
+
+```
+messygit > add .
+Staged everything
+
+messygit > commit
+feat(cli): add interactive REPL with ASCII banner
+Commit with this message? [y/n/e] y
+
+messygit > push
+```
+
+### Commit message style
+
+The model follows **Conventional Commits**: `type(scope): description`
+
+Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`. Subjects are one line, imperative, lowercase, no trailing period.
+
+## Publishing to PyPI
+
+This project uses GitHub Actions with [PyPI trusted publishing](https://docs.pypi.org/trusted-publishers/) — no API tokens needed in your repo.
+
+### One-time setup
+
+1. Go to your project on [pypi.org](https://pypi.org/manage/project/messygit/settings/publishing/)
+2. Add a **Trusted Publisher**:
+   - **Owner:** your GitHub username
+   - **Repository:** `messygit`
+   - **Workflow name:** `publish.yml`
+   - **Environment:** leave blank
+
+### To release a new version
+
+1. Bump `version` in `pyproject.toml`
+2. Commit and push
+3. Create a GitHub release:
+
+```bash
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+4. Go to GitHub → Releases → Draft a new release → select the tag → Publish
+
+The workflow at `.github/workflows/publish.yml` will automatically build and upload to PyPI.
+
+### Manual publish (without CI)
+
+```bash
+rm -rf dist/
+python -m build
+twine upload dist/*
+```
+
+## License
+
+MIT (see `pyproject.toml`).

messygit-0.2.1/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.1/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.1/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",
+        },
+    },
+)

messygit-0.2.1/messygit/cli.py

@@ -0,0 +1,283 @@
+import os
+import shlex
+import sys
+import threading
+import time
+
+import click
+
+from .config import (
+    ANTHROPIC_ENV_VAR,
+    CONFIG_FILE,
+    AnthropicInsufficientBalanceError,
+    InvalidAnthropicCredentialsError,
+    MissingApiKeyError,
+    load_api_key,
+    mask_api_key,
+    save_api_key,
+)
+from .git import get_staged_diff, git_add, git_commit, git_push
+from .llm import generate_commit_message
+from .prompts import SUGGESTION_SYSTEM_PROMPT
+from .agent.tools import run_git_tool, read_file_tool, list_directory_tool, search_code_tool
+from .agent.agent import Agent
+
+BANNER = r"""
+=========================================================================
+  mmm    mmmm  eeeeeee  sssssss  sssssss  yy   yy  ggggggg  ii  tttttttt
+  mm mm mm mm  ee       ss       ss        yy yy   gg       ii     tt
+  mm  mmm  mm  eeeee    sssssss  sssssss    yy     gg  ggg  ii     tt
+  mm       mm  ee            ss       ss    yy     gg   gg  ii     tt
+  mm       mm  eeeeeee  sssssss  sssssss    yy     ggggg    ii     tt
+=========================================================================
+"""
+
+HELP_TEXT = """
+commands:
+  add          stage files (usage: add . or add <file> ...)
+  commit       generate a commit message from staged changes
+  push         push commits to remote
+  config       set your Anthropic API key (usage: config <key>)
+  show         display your masked API key
+  suggest      suggest next steps for your project
+  help         show this help message
+  quit/exit    exit messygit
+""".strip()
+
+SPINNER_PHRASES = [
+    "brewing commit magic",
+    "reading your diffs",
+    "thinking real hard",
+    "untangling your code",
+    "consulting the git gods",
+]
+
+
+class Spinner:
+    """Animated loading indicator that runs in a background thread."""
+
+    def __init__(self, phrase: str | None = None):
+        import random
+        self._phrase = phrase or random.choice(SPINNER_PHRASES)
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def _animate(self) -> None:
+        dots = ["   ", ".  ", ".. ", "..."]
+        idx = 0
+        while not self._stop.is_set():
+            frame = f"\r  {self._phrase} {dots[idx % len(dots)]}"
+            sys.stderr.write(frame)
+            sys.stderr.flush()
+            idx += 1
+            self._stop.wait(0.4)
+        sys.stderr.write("\r" + " " * (len(self._phrase) + 10) + "\r")
+        sys.stderr.flush()
+
+    def __enter__(self):
+        self._thread = threading.Thread(target=self._animate, daemon=True)
+        self._thread.start()
+        return self
+
+    def __exit__(self, *exc):
+        self._stop.set()
+        if self._thread:
+            self._thread.join()
+
+
+def _print_error(msg: str) -> None:
+    click.secho(f"error: {msg}", fg="red", err=True)
+
+
+def _prompt_commit_action(message: str) -> None:
+    """Ask [Y/n/e]: commit, cancel, or edit in $EDITOR."""
+    current = message
+    while True:
+        click.echo(current)
+        choice = click.prompt(
+            "Commit with this message? [y/n/e]",
+            default="Y",
+            show_default=False,
+        ).strip().lower()
+
+        if choice in ("", "y", "yes"):
+            result = git_commit(current)
+            if result.stdout:
+                click.echo(result.stdout, nl=False)
+            if result.stderr:
+                click.echo(result.stderr, nl=False, err=True)
+            if result.returncode != 0:
+                _print_error("git commit failed.")
+            return
+
+        if choice in ("n", "no"):
+            click.echo("Commit cancelled.")
+            return
+
+        if choice in ("e", "edit"):
+            edited = click.edit(current)
+            if edited is None:
+                click.echo("Editor exited without saving; message unchanged.")
+                continue
+            stripped = edited.strip()
+            if not stripped:
+                click.echo("Empty message ignored; message unchanged.")
+                continue
+            current = stripped
+            continue
+
+        click.echo("Please answer y (yes), n (no), or e (edit).")
+
+
+def _handle_add(args: list[str]) -> None:
+    if not args:
+        _print_error("Usage: add <file> ... or add .")
+        return
+    result = git_add(args)
+    if result.returncode != 0:
+        _print_error(result.stderr.strip() if result.stderr else "git add failed.")
+        return
+    label = "everything" if args == ["."] else ", ".join(args)
+    click.echo(f"Staged {label}")
+
+
+def _handle_push() -> None:
+    result = git_push()
+    if result.returncode != 0:
+        _print_error(result.stderr.strip() if result.stderr else "git push failed.")
+        return
+    output = (result.stdout or result.stderr or "").strip()
+    if output:
+        click.echo(output)
+    else:
+        click.echo("Pushed successfully.")
+
+
+def _handle_commit() -> None:
+    diff = get_staged_diff()
+    if not diff.strip():
+        _print_error("No staged changes found. Run 'add .' or 'add <file>' first.")
+        return
+    try:
+        with Spinner():
+            message = generate_commit_message(diff)
+    except (MissingApiKeyError, InvalidAnthropicCredentialsError, AnthropicInsufficientBalanceError) as e:
+        _print_error(str(e))
+        return
+    _prompt_commit_action(message)
+
+
+def _handle_config(args: list[str]) -> None:
+    if not args:
+        _print_error("Usage: config <api-key>")
+        return
+    key = args[0]
+    try:
+        save_api_key(key)
+    except ValueError as e:
+        _print_error(str(e))
+        return
+    click.echo(f"API key saved successfully ({mask_api_key(key.strip())})")
+
+
+def _handle_show() -> None:
+    env_set = ANTHROPIC_ENV_VAR in os.environ
+    env_key = (os.environ.get(ANTHROPIC_ENV_VAR) or "").strip()
+    if env_key:
+        click.echo(f"API key: {mask_api_key(env_key)} (from ANTHROPIC_API_KEY)")
+        return
+    file_key = load_api_key()
+    if file_key:
+        if env_set:
+            click.echo(
+                f"{ANTHROPIC_ENV_VAR} is set but empty; showing key from {CONFIG_FILE}."
+            )
+        click.echo(f"API key: {mask_api_key(file_key)} (from {CONFIG_FILE})")
+        return
+    if env_set:
+        click.echo(
+            f"{ANTHROPIC_ENV_VAR} is set but empty or whitespace-only, and no usable key "
+            f"is stored in {CONFIG_FILE}. Unset the variable or run: config <key>"
+        )
+        return
+    click.echo("No API key found. Set ANTHROPIC_API_KEY or run: config <key>")
+
+
+def _handle_suggestion() -> None:
+    agent = Agent(
+        name="suggestion_agent",
+        system_prompt=SUGGESTION_SYSTEM_PROMPT,
+        max_iterations=8,
+        tools=[run_git_tool, read_file_tool, list_directory_tool],
+    )
+    try:
+        with Spinner():
+            result = agent.run("What should the next steps for my project be? Let's limit it to 3-5 steps")
+    except (MissingApiKeyError, InvalidAnthropicCredentialsError, AnthropicInsufficientBalanceError) as e:
+        _print_error(str(e))
+        return
+    click.echo(result)
+
+
+COMMANDS = {
+    "add": _handle_add,
+    "commit": lambda args: _handle_commit(),
+    "push": lambda args: _handle_push(),
+    "config": _handle_config,
+    "show": lambda args: _handle_show(),
+    "suggest": lambda args: _handle_suggestion(),
+    "help": lambda args: click.echo(HELP_TEXT),
+}
+
+
+def _repl() -> None:
+    click.echo()
+    click.secho(BANNER, fg="cyan", bold=True)
+    click.echo()
+    click.echo("Type 'help' for commands, 'quit' to exit.")
+    click.echo()
+
+    while True:
+        try:
+            raw = click.prompt(
+                click.style("messygit", fg="cyan", bold=True) + click.style(" > ", bold=True),
+                prompt_suffix="",
+                default="",
+                show_default=False,
+            ).strip()
+        except (EOFError, KeyboardInterrupt):
+            click.echo()
+            click.secho("Bye!", fg="cyan")
+            break
+
+        if not raw:
+            continue
+
+        try:
+            parts = shlex.split(raw)
+        except ValueError:
+            parts = raw.split()
+
+        cmd, args = parts[0].lower(), parts[1:]
+
+        if cmd in ("quit", "exit"):
+            click.secho("Bye!", fg="cyan")
+            break
+
+        handler = COMMANDS.get(cmd)
+        if handler is None:
+            _print_error(f"Unknown command '{cmd}'. Type 'help' for a list of commands.")
+            continue
+
+        handler(args)
+        click.echo()
+
+
+@click.command()
+def main():
+    """Messy Git — interactive CLI for clean commits from messy code."""
+    _repl()
+
+
+if __name__ == "__main__":
+    main()

{messygit-0.1.4 → messygit-0.2.1}/messygit/git.py

@@ -232,6 +232,22 @@ def get_staged_files() -> list[str]:
     return [f for f in files.split("\n") if not _is_noise_file(f)]
 
 
+def git_add(paths: list[str]) -> CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "add", *paths],
+        capture_output=True,
+        text=True,
+    )
+
+
+def git_push() -> CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "push"],
+        capture_output=True,
+        text=True,
+    )
+
+
 def git_commit(message: str) -> CompletedProcess[str]:
     return subprocess.run(
         ["git", "commit", "-m", message],

{messygit-0.1.4 → messygit-0.2.1}/messygit/prompts.py

@@ -60,6 +60,44 @@ YOU MUST:
 """
 
 
+SUGGESTION_SYSTEM_PROMPT = """\
+You are a senior developer reviewing a git repository to suggest actionable \
+next steps. You have tools to inspect the repo — use them to understand the \
+codebase before responding.
+
+# Workflow
+1. Run git status, git log, and list the directory to understand the current state.
+2. Read key files (README, config, entry points) to understand the project's purpose.
+3. Identify what's been done recently and what gaps or opportunities remain.
+
+# Output format (strict)
+Respond with a SHORT summary (1-2 sentences) of what the project is and where \
+it stands, followed by a numbered list of 3-5 concrete next steps.
+
+Each step must be:
+- One line, imperative mood ("Add tests for…", "Refactor…", "Set up…")
+- Specific enough to act on immediately (name files, modules, or concepts)
+- Ordered by priority (most impactful first)
+
+Example output:
+
+A CLI tool for generating commit messages from diffs — core functionality works, \
+but lacks tests and error handling polish.
+
+1. Add unit tests for the diff parser in git.py
+2. Handle the edge case where git is not installed
+3. Add a --dry-run flag to preview without committing
+4. Write a README with install and usage instructions
+5. Set up CI with GitHub Actions
+
+# Rules
+- No markdown headers, bold, or code fences in the final output.
+- No filler phrases ("Here are some suggestions", "I'd recommend").
+- Jump straight into the summary and list.
+- Keep total output under 15 lines.\
+"""
+
+
 def build_user_prompt(staged_changes: str) -> str:
     return (
         "Generate a commit message for the following staged changes.\n"

{messygit-0.1.4 → messygit-0.2.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "messygit"
-version = "0.1.4"
-description = "CLI that drafts Conventional Commits from staged git diffs with Claude, then commit, cancel, or edit."
+version = "0.2.1"
+description = "An AI-powered interactive git CLI with agentic tools for commits, code suggestions, and workflow automation."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"

messygit-0.1.4/PKG-INFO

@@ -1,115 +0,0 @@
-Metadata-Version: 2.4
-Name: messygit
-Version: 0.1.4
-Summary: CLI that drafts Conventional Commits from staged git diffs with Claude, then commit, cancel, or edit.
-License-Expression: MIT
-Requires-Python: >=3.10
-Requires-Dist: anthropic>=0.39.0
-Requires-Dist: click>=8.0
-Description-Content-Type: text/markdown
-
-# 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.1.4/README.md

@@ -1,105 +0,0 @@
-# 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.1.4/messygit/cli.py

@@ -1,112 +0,0 @@
-import os
-
-import click
-
-from .config import (
-    ANTHROPIC_ENV_VAR,
-    CONFIG_FILE,
-    AnthropicInsufficientBalanceError,
-    InvalidAnthropicCredentialsError,
-    MissingApiKeyError,
-    load_api_key,
-    mask_api_key,
-    save_api_key,
-)
-from .git import get_staged_diff, git_commit
-from .llm import generate_commit_message
-
-def _prompt_commit_action(message: str) -> None:
-    """Ask [Y/n/e]: commit, cancel, or edit in $EDITOR."""
-    current = message
-    while True:
-        click.echo(current)
-        choice = click.prompt(
-            "Commit with this message? [y/n/e]",
-            default="Y",
-            show_default=False,
-        ).strip().lower()
-
-        if choice in ("", "y", "yes"):
-            result = git_commit(current)
-            if result.stdout:
-                click.echo(result.stdout, nl=False)
-            if result.stderr:
-                click.echo(result.stderr, nl=False, err=True)
-            if result.returncode != 0:
-                raise click.ClickException("git commit failed.")
-            return
-
-        if choice in ("n", "no"):
-            click.echo("Commit cancelled.")
-            return
-
-        if choice in ("e", "edit"):
-            edited = click.edit(current)
-            if edited is None:
-                click.echo("Editor exited without saving; message unchanged.")
-                continue
-            stripped = edited.strip()
-            if not stripped:
-                click.echo("Empty message ignored; message unchanged.")
-                continue
-            current = stripped
-            continue
-
-        click.echo("Please answer y (yes), n (no), or e (edit).")
-
-@click.group(invoke_without_command=True)
-@click.pass_context
-def main(ctx):
-    """Messy Git is a tool that analyzes your updated code and generates clean commit messages. Let's keep your "messy" messages in check!"""
-    if ctx.invoked_subcommand is None:
-        diff = get_staged_diff()
-        if not diff.strip():
-            raise click.ClickException(
-                "No staged changes found. Run 'git add' first."
-            )
-        try:
-            message = generate_commit_message(diff)
-        except MissingApiKeyError as e:
-            raise click.ClickException(str(e)) from e
-        except InvalidAnthropicCredentialsError as e:
-            raise click.ClickException(str(e)) from e
-        except AnthropicInsufficientBalanceError as e:
-            raise click.ClickException(str(e)) from e
-        _prompt_commit_action(message)
-
-@main.command("config")
-@click.option("--key", type=str, required=True, help="Anthropic API key")
-def config_cmd(key):
-    """Configure your Anthropic API key."""
-    try:
-        save_api_key(key)
-    except ValueError as e:
-        raise click.ClickException(str(e)) from e
-    click.echo(f"API key saved successfully ({mask_api_key(key.strip())})")
-
-@main.command("show")
-def show():
-    """Display masked API key (env takes precedence over config file)."""
-    env_set = ANTHROPIC_ENV_VAR in os.environ
-    env_key = (os.environ.get(ANTHROPIC_ENV_VAR) or "").strip()
-    if env_key:
-        click.echo(f"API key: {mask_api_key(env_key)} (from ANTHROPIC_API_KEY)")
-        return
-    file_key = load_api_key()
-    if file_key:
-        if env_set:
-            click.echo(
-                f"{ANTHROPIC_ENV_VAR} is set but empty; showing key from {CONFIG_FILE}."
-            )
-        click.echo(f"API key: {mask_api_key(file_key)} (from {CONFIG_FILE})")
-        return
-    if env_set:
-        click.echo(
-            f"{ANTHROPIC_ENV_VAR} is set but empty or whitespace-only, and no usable key "
-            f"is stored in {CONFIG_FILE}. Unset the variable or run messygit config --key."
-        )
-        return
-    click.echo("No API key found. Set ANTHROPIC_API_KEY or run messygit config --key.")
-
-if __name__ == "__main__":
-    main()