messygit 0.3.1__tar.gz → 0.3.2__tar.gz

messygit-0.3.2/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package with dev dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -q

{messygit-0.3.1 → messygit-0.3.2}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: messygit
-Version: 0.3.1
+Version: 0.3.2
 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
 Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # messygit

{messygit-0.3.1 → messygit-0.3.2}/messygit/agent/agent.py

@@ -53,8 +53,25 @@ class Agent:
 
                 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 = next((t for t in self.tools if t.name == block.name), None)
+                    if tool is None:
+                        tool_results.append({
+                            "type": "tool_result",
+                            "tool_use_id": block.id,
+                            "content": f"Unknown tool: {block.name!r}.",
+                            "is_error": True,
+                        })
+                        continue
+                    try:
+                        result = tool.run(**block.input)
+                    except Exception as e:
+                        tool_results.append({
+                            "type": "tool_result",
+                            "tool_use_id": block.id,
+                            "content": f"Error running tool {block.name!r}: {e}",
+                            "is_error": True,
+                        })
+                        continue
                     tool_results.append({
                         "type": "tool_result",
                         "tool_use_id": block.id,

{messygit-0.3.1 → messygit-0.3.2}/messygit/agent/tool.py

@@ -12,17 +12,21 @@ class Tool:
     description: str
     function: Callable[..., Any]
     parameters: dict[str, Any] = field(default_factory=dict)
+    required: list[str] = field(default_factory=list)
 
     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."""
+        input_schema: dict[str, Any] = {
+            "type": "object",
+            "properties": self.parameters,
+        }
+        if self.required:
+            input_schema["required"] = self.required
         return {
             "name": self.name,
             "description": self.description,
-            "input_schema": {
-                "type": "object",
-                "properties": self.parameters,
-            },
+            "input_schema": input_schema,
         }

messygit-0.3.2/messygit/agent/tools.py

@@ -0,0 +1,137 @@
+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 _repo_root() -> str:
+    """Absolute, symlink-resolved path to the git repository root."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+    )
+    root = result.stdout.strip() or os.getcwd()
+    return os.path.realpath(root)
+
+
+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 read-only git command and return its output. The first element "
+        "of `args` must be one of: "
+        + ", ".join(sorted(set(ALLOWED_GIT_COMMANDS)))
+        + ". Example: [\"log\", \"--oneline\", \"-n\", \"10\"]."
+    ),
+    function=run_git,
+    parameters={
+        "args": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": (
+                "git subcommand and its arguments as separate strings, e.g. "
+                "[\"diff\", \"--stat\"]. The subcommand (first item) must be allowed."
+            ),
+        },
+    },
+    required=["args"],
+)
+
+def read_file(path: str) -> str:
+    root = _repo_root()
+    target = os.path.realpath(os.path.join(root, path))
+    if target != root and not target.startswith(root + os.sep):
+        return f"Access denied: '{path}' is outside the repository root."
+    try:
+        with open(target, "r") as file:
+            return file.read()
+    except FileNotFoundError:
+        return "File not found."
+    except IsADirectoryError:
+        return "Path is a directory, not a file."
+    except PermissionError:
+        return "Permission denied."
+    except UnicodeDecodeError:
+        return "File is not valid UTF-8 text and cannot be read."
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+read_file_tool = Tool(
+    name="read_file",
+    description=(
+        "Read and return the UTF-8 text contents of a file inside the repository. "
+        "Paths are resolved relative to the repository root; paths that escape the "
+        "repository (e.g. via '..' or absolute paths) are rejected."
+    ),
+    function=read_file,
+    parameters={
+        "path": {
+            "type": "string",
+            "description": (
+                "File path relative to the repository root, e.g. "
+                "\"messygit/cli.py\"."
+            ),
+        },
+    },
+    required=["path"],
+)
+
+def list_directory(path: str) -> list[str]:
+    root = _repo_root()
+    target = os.path.realpath(os.path.join(root, path))
+    if target != root and not target.startswith(root + os.sep):
+        return f"Access denied: '{path}' is outside the repository root."
+    try:
+        return os.listdir(target)
+    except FileNotFoundError:
+        return "Directory not found."
+    except NotADirectoryError:
+        return "Path is a file, not a directory."
+    except PermissionError:
+        return "Permission denied."
+    except Exception as e:
+        return f"Error listing directory: {e}"
+
+list_directory_tool = Tool(
+    name="list_directory",
+    description=(
+        "List the names of entries (files and subdirectories) in a directory. "
+        "Use \".\" for the current directory."
+    ),
+    function=list_directory,
+    parameters={
+        "path": {
+            "type": "string",
+            "description": "Directory path to list, e.g. \"messygit\" or \".\".",
+        },
+    },
+    required=["path"],
+)
+
+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 tracked files in the repository for a string or regex using "
+        "`git grep`. Returns matching lines prefixed with file path and line number."
+    ),
+    function=search_code,
+    parameters={
+        "query": {
+            "type": "string",
+            "description": "The text or basic regex pattern to search for.",
+        },
+    },
+    required=["query"],
+)

{messygit-0.3.1 → messygit-0.3.2}/messygit/cli.py

@@ -32,6 +32,7 @@ from .git import (
     get_current_branch,
     get_repo_status,
     get_staged_diff,
+    get_unpushed_commits,
     git_add,
     git_commit,
     git_push,
@@ -112,6 +113,7 @@ HELP_GROUPS = [
         ("add", "stage files", "add . or add <file> ..."),
         ("commit", "generate a commit message from staged changes", "commit"),
         ("push", "push commits to remote", "push"),
+        ("outbox", "show committed but unpushed commits", "outbox"),
     ]),
     ("messyagent", [
         ("suggest", "suggest next steps for your project", "suggest"),
@@ -413,6 +415,33 @@ def _handle_push() -> None:
     _success(output if output else "Pushed successfully.")
 
 
+def _handle_outbox() -> None:
+    if not is_git_repo():
+        _print_error("Not a git repository.")
+        return
+    box = get_unpushed_commits()
+    if box.upstream is None:
+        _print_error(
+            "No upstream branch set — push once with 'git push -u' to start tracking."
+        )
+        return
+    if not box.commits:
+        _success(f"Up to date with [{BRAND}]{box.upstream}[/] — nothing to push.")
+        return
+
+    n = len(box.commits)
+    body = Text()
+    body.append(
+        f"{n} commit{'s' if n != 1 else ''} ahead of {box.upstream}\n\n", style=MUTED
+    )
+    for commit in box.commits:
+        body.append(f"{commit.short_hash} ", style=BRAND)
+        body.append(f"{commit.subject}\n", style="default")
+    console.print(
+        Panel(body, title="outbox", border_style=BRAND, title_align="left")
+    )
+
+
 def _handle_commit() -> None:
     diff = get_staged_diff()
     if not diff.strip():
@@ -657,6 +686,7 @@ COMMANDS = {
     "add": _handle_add,
     "commit": lambda args: _handle_commit(),
     "push": lambda args: _handle_push(),
+    "outbox": lambda args: _handle_outbox(),
     "config": _handle_config,
     "show": lambda args: _handle_show(),
     "suggest": lambda args: _handle_suggestion(),

{messygit-0.3.1 → messygit-0.3.2}/messygit/git.py

@@ -313,4 +313,48 @@ def git_commit(message: str) -> CompletedProcess[str]:
         ["git", "commit", "-m", message],
         capture_output=True,
         text=True,
-    )
+    )
+
+
+@dataclass
+class UnpushedCommit:
+    short_hash: str
+    subject: str
+
+
+@dataclass
+class Outbox:
+    """Commits made locally but not yet on the upstream branch."""
+
+    upstream: str | None
+    commits: list[UnpushedCommit]
+
+
+def get_unpushed_commits() -> Outbox:
+    """Return commits that are ahead of the current branch's upstream.
+
+    `upstream` is None when the branch has no configured upstream (e.g. it was
+    never pushed); in that case `commits` is empty and the caller should tell the
+    user to push/track the branch first.
+    """
+    upstream = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+        capture_output=True,
+        text=True,
+    )
+    if upstream.returncode != 0:
+        return Outbox(upstream=None, commits=[])
+    upstream_ref = upstream.stdout.strip()
+
+    log = subprocess.run(
+        ["git", "log", "--format=%h%x00%s", "@{upstream}..HEAD"],
+        capture_output=True,
+        text=True,
+    )
+    commits: list[UnpushedCommit] = []
+    for line in log.stdout.splitlines():
+        if not line:
+            continue
+        short_hash, _, subject = line.partition("\x00")
+        commits.append(UnpushedCommit(short_hash=short_hash, subject=subject))
+    return Outbox(upstream=upstream_ref, commits=commits)

{messygit-0.3.1 → messygit-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "messygit"
-version = "0.3.1"
+version = "0.3.2"
 description = "An AI-powered interactive git CLI with agentic tools for commits, code suggestions, and workflow automation."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -17,3 +17,6 @@ dependencies = [
 
 [project.scripts]
 messygit = "messygit.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]

messygit-0.3.2/tests/agent_test.py

@@ -0,0 +1,245 @@
+"""Drive Agent.run against a simulated Anthropic client.
+
+We replace the SDK client with a FakeClient that returns a preset queue of
+responses (text and/or tool_use blocks) and records every messages.create()
+call, so we can assert the agent actually executes tools, feeds results back,
+handles errors, and respects its iteration cap — all without a network call.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from messygit.agent import agent as agent_mod
+from messygit.agent.agent import Agent
+from messygit.agent.tool import Tool
+from messygit.usage import SESSION_USAGE
+
+
+# --- fakes for the Anthropic SDK surface the agent touches ----------------
+
+class FakeUsage:
+    def __init__(self, input_tokens=10, output_tokens=5):
+        self.input_tokens = input_tokens
+        self.output_tokens = output_tokens
+        self.cache_creation_input_tokens = 0
+        self.cache_read_input_tokens = 0
+
+
+def text_block(text):
+    return SimpleNamespace(type="text", text=text)
+
+
+def tool_use_block(name, tool_input, id="tu_1"):
+    return SimpleNamespace(type="tool_use", name=name, input=tool_input, id=id)
+
+
+def response(*blocks, usage=None):
+    return SimpleNamespace(content=list(blocks), usage=usage or FakeUsage())
+
+
+class FakeMessages:
+    def __init__(self, scripted):
+        self._scripted = list(scripted)
+        self.calls = []  # every kwargs dict passed to create()
+
+    def create(self, **kwargs):
+        # The agent mutates one `messages` list in place across iterations, so
+        # snapshot it here to capture what was actually sent on *this* call.
+        snapshot = dict(kwargs)
+        snapshot["messages"] = list(kwargs["messages"])
+        self.calls.append(snapshot)
+        if not self._scripted:
+            raise AssertionError("agent made more API calls than were scripted")
+        return self._scripted.pop(0)
+
+
+class FakeClient:
+    def __init__(self, scripted):
+        self.messages = FakeMessages(scripted)
+
+
+# --- test helpers ---------------------------------------------------------
+
+def make_spy_tool(name="read_file", returns="FILE CONTENTS"):
+    """A real Tool wrapping a spy fn that records the kwargs it was called with."""
+    calls = []
+
+    def fn(**kwargs):
+        calls.append(kwargs)
+        return returns
+
+    tool = Tool(
+        name=name,
+        description="spy tool",
+        function=fn,
+        parameters={"path": {"type": "string"}},
+        required=["path"],
+    )
+    return tool, calls
+
+
+def last_tool_results(client):
+    """The tool_result list the agent sent on its most recent create() call."""
+    return client.messages.calls[-1]["messages"][-1]["content"]
+
+
+@pytest.fixture(autouse=True)
+def reset_usage():
+    SESSION_USAGE.input = SESSION_USAGE.output = SESSION_USAGE.requests = 0
+    SESSION_USAGE.cost = 0.0
+    yield
+
+
+@pytest.fixture
+def run_agent(monkeypatch):
+    """Patch the agent's SDK dependencies and run it against scripted responses."""
+    model = SimpleNamespace(
+        id="claude-test", input_cost_per_token=0.0, output_cost_per_token=0.0
+    )
+    monkeypatch.setattr(agent_mod, "current_model", lambda: model)
+    monkeypatch.setattr(agent_mod, "resolve_api_key", lambda: "test-key")
+
+    def _run(scripted, tools, user_input="go", max_iterations=8):
+        client = FakeClient(scripted)
+        monkeypatch.setattr(agent_mod, "Anthropic", lambda **kwargs: client)
+        agent = Agent(
+            name="t",
+            system_prompt="sys",
+            max_iterations=max_iterations,
+            tools=tools,
+        )
+        result = agent.run(user_input)
+        return result, client
+
+    return _run
+
+
+# --- the happy path: no tools, then with tools ----------------------------
+
+def test_returns_text_without_calling_tools(run_agent):
+    tool, calls = make_spy_tool()
+    result, client = run_agent([response(text_block("just an answer"))], [tool])
+    assert result == "just an answer"
+    assert calls == []                       # tool never invoked
+    assert len(client.messages.calls) == 1   # only one round-trip
+
+
+def test_executes_tool_then_returns_final_text(run_agent):
+    tool, calls = make_spy_tool(returns="print('hi')")
+    scripted = [
+        response(tool_use_block("read_file", {"path": "x.py"}, id="tu_1")),
+        response(text_block("the file prints hi")),
+    ]
+    result, client = run_agent(scripted, [tool])
+    assert calls == [{"path": "x.py"}]       # tool ran with the model's args
+    assert result == "the file prints hi"
+    assert len(client.messages.calls) == 2
+
+
+def test_tool_result_is_sent_back_to_model(run_agent):
+    tool, _ = make_spy_tool(returns="RESULT-DATA")
+    scripted = [
+        response(tool_use_block("read_file", {"path": "x.py"}, id="tu_42")),
+        response(text_block("done")),
+    ]
+    _, client = run_agent(scripted, [tool])
+    tr = last_tool_results(client)[0]
+    assert tr["type"] == "tool_result"
+    assert tr["tool_use_id"] == "tu_42"      # id is threaded through correctly
+    assert tr["content"] == "RESULT-DATA"
+    assert "is_error" not in tr
+
+
+def test_first_call_sends_user_input_and_tool_schemas(run_agent):
+    tool, _ = make_spy_tool()
+    _, client = run_agent([response(text_block("ok"))], [tool], user_input="analyze repo")
+    first = client.messages.calls[0]
+    assert first["messages"][0] == {"role": "user", "content": "analyze repo"}
+    assert first["system"] == "sys"
+    assert first["tool_choice"] == {"type": "auto"}
+    assert first["tools"][0]["name"] == "read_file"
+    assert first["tools"][0]["input_schema"]["type"] == "object"
+
+
+# --- multiple tool calls in one assistant turn ----------------------------
+
+def test_multiple_tool_uses_in_one_turn_all_execute(run_agent):
+    tool, calls = make_spy_tool()
+    scripted = [
+        response(
+            tool_use_block("read_file", {"path": "a"}, id="t1"),
+            tool_use_block("read_file", {"path": "b"}, id="t2"),
+        ),
+        response(text_block("both read")),
+    ]
+    result, client = run_agent(scripted, [tool])
+    assert calls == [{"path": "a"}, {"path": "b"}]
+    assert [tr["tool_use_id"] for tr in last_tool_results(client)] == ["t1", "t2"]
+    assert result == "both read"
+
+
+# --- error handling -------------------------------------------------------
+
+def test_unknown_tool_returns_error_result_and_continues(run_agent):
+    tool, calls = make_spy_tool(name="read_file")
+    scripted = [
+        response(tool_use_block("does_not_exist", {}, id="tu_x")),
+        response(text_block("recovered")),
+    ]
+    result, client = run_agent(scripted, [tool])
+    assert result == "recovered"
+    assert calls == []                       # the real tool was never called
+    tr = client.messages.calls[1]["messages"][-1]["content"][0]
+    assert tr["is_error"] is True
+    assert "does_not_exist" in tr["content"]
+
+
+def test_tool_exception_becomes_error_result(run_agent):
+    def boom(**kwargs):
+        raise RuntimeError("kaboom")
+
+    tool = Tool(
+        name="read_file",
+        description="explodes",
+        function=boom,
+        parameters={"path": {"type": "string"}},
+        required=["path"],
+    )
+    scripted = [
+        response(tool_use_block("read_file", {"path": "x"}, id="tu_e")),
+        response(text_block("handled")),
+    ]
+    result, client = run_agent(scripted, [tool])
+    assert result == "handled"
+    tr = client.messages.calls[1]["messages"][-1]["content"][0]
+    assert tr["is_error"] is True
+    assert "kaboom" in tr["content"]
+
+
+# --- iteration cap --------------------------------------------------------
+
+def test_stops_at_max_iterations(run_agent):
+    tool, calls = make_spy_tool()
+    # The model never yields plain text, so only the cap can end the loop.
+    scripted = [
+        response(tool_use_block("read_file", {"path": str(i)}, id=f"tu_{i}"))
+        for i in range(10)
+    ]
+    result, client = run_agent(scripted, [tool], max_iterations=3)
+    assert len(client.messages.calls) == 3   # never exceeds the cap
+    assert len(calls) == 3
+
+
+# --- usage accounting -----------------------------------------------------
+
+def test_usage_is_recorded_per_api_call(run_agent):
+    tool, _ = make_spy_tool()
+    scripted = [
+        response(tool_use_block("read_file", {"path": "a"}, id="t1"), usage=FakeUsage(7, 3)),
+        response(text_block("done"), usage=FakeUsage(4, 2)),
+    ]
+    run_agent(scripted, [tool])
+    assert SESSION_USAGE.requests == 2
+    assert SESSION_USAGE.input == 11   # 7 + 4
+    assert SESSION_USAGE.output == 5   # 3 + 2

messygit-0.3.2/tests/config_test.py

@@ -0,0 +1,128 @@
+import json
+
+import pytest
+
+from messygit import config
+
+
+@pytest.fixture(autouse=True)
+def isolated_config(tmp_path, monkeypatch):
+    """Redirect config/todo files to a temp dir and clear the API-key env var.
+
+    autouse=True means every test in this module runs against a throwaway
+    directory instead of the real ~/.messygit, and never sees a key that
+    happens to be exported in the developer's (or CI runner's) environment.
+    """
+    config_dir = tmp_path / ".messygit"
+    monkeypatch.setattr(config, "CONFIG_DIR", config_dir)
+    monkeypatch.setattr(config, "CONFIG_FILE", config_dir / "config.json")
+    monkeypatch.setattr(config, "TODO_FILE", config_dir / "todo.md")
+    monkeypatch.delenv(config.ANTHROPIC_ENV_VAR, raising=False)
+    return config_dir
+
+
+# --- save_api_key / load_api_key ------------------------------------------
+
+def test_save_then_load_api_key_roundtrips():
+    config.save_api_key("sk-ant-secret")
+    assert config.load_api_key() == "sk-ant-secret"
+
+
+def test_save_api_key_strips_surrounding_whitespace():
+    config.save_api_key("  sk-ant-secret\n")
+    assert config.load_api_key() == "sk-ant-secret"
+
+
+@pytest.mark.parametrize("bad", ["", "   ", "\n\t"])
+def test_save_api_key_rejects_blank(bad):
+    with pytest.raises(ValueError):
+        config.save_api_key(bad)
+
+
+def test_load_api_key_returns_none_when_unset():
+    assert config.load_api_key() is None
+
+
+def test_save_api_key_preserves_other_keys():
+    config.save_theme("midnight")
+    config.save_api_key("sk-ant-secret")
+    assert config.load_theme() == "midnight"
+    assert config.load_api_key() == "sk-ant-secret"
+
+
+# --- resolve_api_key ------------------------------------------------------
+
+def test_resolve_prefers_env_over_file(monkeypatch):
+    config.save_api_key("file-key")
+    monkeypatch.setenv(config.ANTHROPIC_ENV_VAR, "env-key")
+    assert config.resolve_api_key() == "env-key"
+
+
+def test_resolve_falls_back_to_file_when_env_absent():
+    config.save_api_key("file-key")
+    assert config.resolve_api_key() == "file-key"
+
+
+def test_resolve_raises_when_env_set_but_blank(monkeypatch):
+    monkeypatch.setenv(config.ANTHROPIC_ENV_VAR, "   ")
+    with pytest.raises(config.MissingApiKeyError) as exc:
+        config.resolve_api_key()
+    assert exc.value.args[0] == config.EMPTY_ENV_API_KEY_MESSAGE
+
+
+def test_resolve_raises_when_nothing_configured():
+    with pytest.raises(config.MissingApiKeyError) as exc:
+        config.resolve_api_key()
+    assert exc.value.args[0] == config.MISSING_API_KEY_MESSAGE
+
+
+# --- theme / model --------------------------------------------------------
+
+def test_theme_roundtrips():
+    config.save_theme("midnight")
+    assert config.load_theme() == "midnight"
+
+
+def test_model_roundtrips():
+    config.save_model("claude-haiku-4-5")
+    assert config.load_model() == "claude-haiku-4-5"
+
+
+# --- todo -----------------------------------------------------------------
+
+def test_todo_roundtrips():
+    config.save_todo("- ship outbox command\n")
+    assert config.load_todo() == "- ship outbox command\n"
+
+
+def test_load_todo_empty_when_missing():
+    assert config.load_todo() == ""
+
+
+# --- corrupt / malformed config ------------------------------------------
+
+def test_corrupt_config_is_ignored(isolated_config):
+    isolated_config.mkdir(parents=True, exist_ok=True)
+    (isolated_config / "config.json").write_text("{not valid json")
+    # _read_config swallows the error and returns {}, so loads are None.
+    assert config.load_api_key() is None
+    # ...and a subsequent save overwrites the garbage cleanly.
+    config.save_api_key("sk-ant-secret")
+    assert json.loads((isolated_config / "config.json").read_text()) == {
+        "api_key": "sk-ant-secret"
+    }
+
+
+# --- mask_api_key ---------------------------------------------------------
+
+def test_mask_api_key_hides_middle():
+    assert config.mask_api_key("sk-ant-abcdefghijklmnop") == "sk-ant-a...mnop"
+
+
+@pytest.mark.parametrize("value,expected", [
+    (None, "(not set)"),
+    ("", "(not set)"),
+    ("short", "(set)"),
+])
+def test_mask_api_key_edge_cases(value, expected):
+    assert config.mask_api_key(value) == expected

messygit-0.3.2/tests/git_test.py

@@ -0,0 +1,199 @@
+import textwrap
+
+import pytest
+
+from messygit.git import (
+    FileStat,
+    _compact_diff_for_files,
+    _is_noise_file,
+    _parse_compact_diff,
+)
+
+
+def diff(text: str) -> str:
+    """Dedent a triple-quoted diff fixture and strip the leading newline."""
+    return textwrap.dedent(text).lstrip("\n")
+
+
+# --- _is_noise_file -------------------------------------------------------
+
+@pytest.mark.parametrize("path", [
+    "package-lock.json",
+    "frontend/yarn.lock",
+    "go.sum",
+    "app/bundle.min.js",
+    "styles/site.min.css",
+    "src/api.pb.go",
+    "schema.generated.ts",
+    "components/Button.snap",
+    "nested/dir/.DS_Store",
+])
+def test_noise_files_are_detected(path):
+    assert _is_noise_file(path) is True
+
+
+@pytest.mark.parametrize("path", [
+    "messygit/cli.py",
+    "README.md",
+    "src/index.js",
+    "lockfile_reader.py",   # 'lock' in name but not an actual lockfile
+    "minify.py",            # 'min' substring, not *.min.js
+])
+def test_real_source_files_are_not_noise(path):
+    assert _is_noise_file(path) is False
+
+
+# --- _parse_compact_diff --------------------------------------------------
+
+def test_parse_single_file_keeps_only_changed_lines():
+    raw = diff("""
+        diff --git a/messygit/cli.py b/messygit/cli.py
+        index 1111111..2222222 100644
+        --- a/messygit/cli.py
+        +++ b/messygit/cli.py
+        @@ -10,1 +10,1 @@ def main():
+        -    old_call()
+        +    new_call()
+    """)
+    assert _parse_compact_diff(raw) == diff("""
+        === messygit/cli.py ===
+        -    old_call()
+        +    new_call()
+    """).rstrip()
+
+
+def test_parse_drops_metadata_lines():
+    """index, ---, +++ and @@ hunk headers must never appear in output."""
+    raw = diff("""
+        diff --git a/a.py b/a.py
+        index 1111111..2222222 100644
+        --- a/a.py
+        +++ b/a.py
+        @@ -1,0 +1,1 @@
+        +added
+    """)
+    out = _parse_compact_diff(raw)
+    assert "index" not in out
+    assert "@@" not in out
+    assert "---" not in out
+    assert "+++" not in out
+    assert out == "=== a.py ===\n+added"
+
+
+def test_parse_multiple_files():
+    raw = diff("""
+        diff --git a/one.py b/one.py
+        --- a/one.py
+        +++ b/one.py
+        @@ -1 +1 @@
+        -a
+        +b
+        diff --git a/two.py b/two.py
+        --- a/two.py
+        +++ b/two.py
+        @@ -1 +0,0 @@
+        -gone
+    """)
+    # A blank line separates files: each header is emitted with a leading "\n",
+    # and the very first one is removed by the trailing .strip().
+    assert _parse_compact_diff(raw) == diff("""
+        === one.py ===
+        -a
+        +b
+
+        === two.py ===
+        -gone
+    """).rstrip()
+
+
+def test_parse_skips_noise_file_entirely():
+    """A noise file should not even get a === header, but real files still do."""
+    raw = diff("""
+        diff --git a/package-lock.json b/package-lock.json
+        --- a/package-lock.json
+        +++ b/package-lock.json
+        @@ -1 +1 @@
+        -  "version": "1.0.0"
+        +  "version": "1.0.1"
+        diff --git a/src/app.py b/src/app.py
+        --- a/src/app.py
+        +++ b/src/app.py
+        @@ -1 +1 @@
+        -x = 1
+        +x = 2
+    """)
+    out = _parse_compact_diff(raw)
+    assert "package-lock.json" not in out
+    assert "version" not in out
+    assert out == "=== src/app.py ===\n-x = 1\n+x = 2"
+
+
+def test_parse_empty_diff_returns_empty_string():
+    assert _parse_compact_diff("") == ""
+
+
+def test_parse_new_file_only_additions():
+    raw = diff("""
+        diff --git a/new.py b/new.py
+        new file mode 100644
+        index 0000000..3333333
+        --- /dev/null
+        +++ b/new.py
+        @@ -0,0 +1,2 @@
+        +line one
+        +line two
+    """)
+    assert _parse_compact_diff(raw) == diff("""
+        === new.py ===
+        +line one
+        +line two
+    """).rstrip()
+
+
+# --- _compact_diff_for_files ---------------------------------------------
+
+TWO_FILE_DIFF = diff("""
+    diff --git a/keep.py b/keep.py
+    --- a/keep.py
+    +++ b/keep.py
+    @@ -1 +1 @@
+    -old
+    +new
+    diff --git a/drop.py b/drop.py
+    --- a/drop.py
+    +++ b/drop.py
+    @@ -1 +1 @@
+    -foo
+    +bar
+""")
+
+
+def test_compact_for_files_includes_only_selected_paths():
+    out = _compact_diff_for_files({"keep.py"}, TWO_FILE_DIFF)
+    assert out == "=== keep.py ===\n-old\n+new"
+    assert "drop.py" not in out
+    assert "bar" not in out
+
+
+def test_compact_for_files_selects_multiple():
+    out = _compact_diff_for_files({"keep.py", "drop.py"}, TWO_FILE_DIFF)
+    assert "=== keep.py ===" in out
+    assert "=== drop.py ===" in out
+
+
+def test_compact_for_files_empty_selection_returns_empty():
+    assert _compact_diff_for_files(set(), TWO_FILE_DIFF) == ""
+
+
+def test_compact_for_files_unknown_path_returns_empty():
+    assert _compact_diff_for_files({"does/not/exist.py"}, TWO_FILE_DIFF) == ""
+
+
+# --- FileStat -------------------------------------------------------------
+
+def test_filestat_total_changed_sums_added_and_removed():
+    assert FileStat(path="a.py", added=3, removed=2).total_changed == 5
+
+
+def test_filestat_total_changed_zero():
+    assert FileStat(path="a.py", added=0, removed=0).total_changed == 0

messygit-0.3.2/tests/llm_test.py

@@ -0,0 +1,105 @@
+import pytest
+from anthropic import APIStatusError, BadRequestError
+
+from messygit import llm
+from messygit.config import ANTHROPIC_INSUFFICIENT_BALANCE_MESSAGE
+
+
+class FakeBadRequest(BadRequestError):
+    """A BadRequestError we can build without a live httpx response.
+
+    The real SDK error needs an httpx.Response; the balance helpers only read
+    .status_code/.body/.message/.request_id and check isinstance(BadRequestError),
+    so we override __init__ and set just those attributes.
+    """
+
+    def __init__(self, *, body=None, message="", status_code=400, request_id=None):
+        self.body = body
+        self.message = message
+        self.status_code = status_code
+        self.request_id = request_id
+
+
+class FakeAPIStatusError(APIStatusError):
+    """A non-BadRequest APIStatusError (e.g. a 402 or 5xx)."""
+
+    def __init__(self, *, body=None, message="", status_code=500, request_id=None):
+        self.body = body
+        self.message = message
+        self.status_code = status_code
+        self.request_id = request_id
+
+
+def billing_body(message="Your credit balance is too low"):
+    return {"type": "error", "error": {"type": "billing_error", "message": message}}
+
+
+# --- _is_insufficient_balance_or_billing ----------------------------------
+
+def test_status_402_is_billing_even_without_billing_type():
+    exc = FakeAPIStatusError(status_code=402, body={"error": {"type": "invalid_request_error"}})
+    assert llm._is_insufficient_balance_or_billing(exc) is True
+
+
+def test_nested_billing_error_type_is_detected():
+    exc = FakeAPIStatusError(status_code=400, body=billing_body())
+    assert llm._is_insufficient_balance_or_billing(exc) is True
+
+
+@pytest.mark.parametrize("hint", [
+    "Your credit balance is too low to access the API.",
+    "balance too low",
+    "insufficient credit on this account",
+    "the account has no credit",
+    "you are out of credit",
+])
+def test_bad_request_balance_hints_in_message(hint):
+    exc = FakeBadRequest(status_code=400, message=hint)
+    assert llm._is_insufficient_balance_or_billing(exc) is True
+
+
+def test_bad_request_hint_in_nested_body_message():
+    exc = FakeBadRequest(
+        status_code=400,
+        message="Bad request",
+        body={"error": {"type": "invalid_request_error", "message": "credit balance is too low"}},
+    )
+    assert llm._is_insufficient_balance_or_billing(exc) is True
+
+
+def test_unrelated_bad_request_is_not_billing():
+    exc = FakeBadRequest(status_code=400, message="max_tokens: must be greater than 0")
+    assert llm._is_insufficient_balance_or_billing(exc) is False
+
+
+def test_generic_non_billing_status_error_is_not_billing():
+    # A 500 with no billing markers: must not be misclassified as a balance issue.
+    exc = FakeAPIStatusError(status_code=500, message="internal server error")
+    assert llm._is_insufficient_balance_or_billing(exc) is False
+
+
+def test_hint_matching_is_case_insensitive():
+    exc = FakeBadRequest(status_code=400, message="CREDIT BALANCE TOO LOW")
+    assert llm._is_insufficient_balance_or_billing(exc) is True
+
+
+# --- _insufficient_balance_user_message -----------------------------------
+
+def test_user_message_without_request_id_is_the_base_message():
+    exc = FakeBadRequest(status_code=400, message="balance too low", request_id=None)
+    assert llm._insufficient_balance_user_message(exc) == ANTHROPIC_INSUFFICIENT_BALANCE_MESSAGE
+
+
+def test_user_message_appends_request_id_when_present():
+    exc = FakeBadRequest(status_code=400, message="balance too low", request_id="req_abc123")
+    msg = llm._insufficient_balance_user_message(exc)
+    assert msg.startswith(ANTHROPIC_INSUFFICIENT_BALANCE_MESSAGE)
+    assert msg.endswith("Request ID for support: req_abc123.")
+
+
+# --- nested-body helpers (defensive parsing) ------------------------------
+
+@pytest.mark.parametrize("body", [None, "a string", 42, {"error": "not a dict"}, {}])
+def test_nested_helpers_tolerate_malformed_bodies(body):
+    assert llm._nested_api_error_type(body) is None
+    assert llm._nested_api_error_message(body) == ""

messygit-0.3.2/tests/tool_schema_test.py

@@ -0,0 +1,86 @@
+import pytest
+
+from messygit.agent import tools as tools_mod
+from messygit.agent.tool import Tool
+
+# Every Tool exposed to the model. The suggestion agent passes the schemas of
+# these straight to client.messages.create(tools=[...]), so each must match the
+# shape the Anthropic Messages API expects for a tool definition.
+ALL_TOOLS = [
+    tools_mod.run_git_tool,
+    tools_mod.read_file_tool,
+    tools_mod.list_directory_tool,
+    tools_mod.search_code_tool,
+]
+
+
+@pytest.fixture(params=ALL_TOOLS, ids=lambda t: t.name)
+def schema(request):
+    return request.param.to_schema()
+
+
+# --- top-level shape ------------------------------------------------------
+
+def test_schema_has_exactly_the_expected_top_level_keys(schema):
+    # Anthropic tool definitions are {name, description, input_schema}.
+    # "required" belongs *inside* input_schema, never at the top level.
+    assert set(schema) == {"name", "description", "input_schema"}
+
+
+def test_name_is_nonempty_string(schema):
+    assert isinstance(schema["name"], str) and schema["name"]
+
+
+def test_description_is_nonempty_string(schema):
+    # A description is optional to the API but we want every tool to have one.
+    assert isinstance(schema["description"], str) and schema["description"].strip()
+
+
+# --- input_schema (JSON Schema object) ------------------------------------
+
+def test_input_schema_is_a_json_schema_object(schema):
+    input_schema = schema["input_schema"]
+    assert input_schema["type"] == "object"
+    assert isinstance(input_schema["properties"], dict)
+
+
+def test_every_property_declares_a_type(schema):
+    for name, prop in schema["input_schema"]["properties"].items():
+        assert isinstance(prop, dict), name
+        assert "type" in prop, name
+
+
+def test_required_is_a_list_referencing_real_properties(schema):
+    input_schema = schema["input_schema"]
+    if "required" not in input_schema:
+        return
+    required = input_schema["required"]
+    assert isinstance(required, list)
+    properties = input_schema["properties"]
+    for field in required:
+        assert field in properties, f"required field {field!r} missing from properties"
+
+
+def test_tool_names_are_unique():
+    names = [t.name for t in ALL_TOOLS]
+    assert len(names) == len(set(names))
+
+
+# --- to_schema behaviour for the `required` field -------------------------
+
+def test_required_omitted_when_not_set():
+    bare = Tool(name="noop", description="does nothing", function=lambda: None)
+    assert "required" not in bare.to_schema()["input_schema"]
+
+
+def test_required_included_when_set():
+    t = Tool(
+        name="echo",
+        description="echo text",
+        function=lambda text: text,
+        parameters={"text": {"type": "string"}},
+        required=["text"],
+    )
+    schema = t.to_schema()
+    assert schema["input_schema"]["required"] == ["text"]
+    assert schema["input_schema"]["properties"]["text"]["type"] == "string"

messygit-0.3.1/messygit/agent/tools.py

@@ -1,82 +0,0 @@
-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",
-        },
-    },
-)