giton 0.1.7__tar.gz → 0.1.8__tar.gz

{giton-0.1.7 → giton-0.1.8}/.idea/workspace.xml

@@ -5,9 +5,7 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="9532a670-1f01-4d5e-9501-f3491f105c64" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/project.sh" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/tree.sh" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/TODO.md" beforeDir="false" afterPath="$PROJECT_DIR$/TODO.md" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/giton/catalog.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/giton/catalog.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />

{giton-0.1.7 → giton-0.1.8}/CHANGELOG.md

@@ -54,6 +54,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.8] - 2026-05-27
+
+### Docs
+- Update README.md
+- Update examples/plugins/README.md
+
+### Test
+- Update tests/test_plugin_runner.py
+
+### Other
+- Update examples/plugins/test_plugin_lifecycle.py
+
 ## [0.1.7] - 2026-05-27
 
 ### Docs

{giton-0.1.7 → giton-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: giton
-Version: 0.1.7
+Version: 0.1.8
 Summary: Local AI layer for git: orchestrates policies & plugins between commit and push.
 Author: semcod
 Author-email: Tom Sapletta <tom@sapletta.com>
@@ -22,11 +22,11 @@ Description-Content-Type: text/markdown
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.7-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.96-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.8-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.96-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.4h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $0.9589 (10 commits)
-- 👤 **Human dev:** ~$334 (3.3h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.9599 (11 commits)
+- 👤 **Human dev:** ~$339 (3.4h @ $100/h, 30min dedup)
 
 Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

{giton-0.1.7 → giton-0.1.8}/README.md

@@ -3,11 +3,11 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.7-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.96-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.8-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.96-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.4h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $0.9589 (10 commits)
-- 👤 **Human dev:** ~$334 (3.3h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $0.9599 (11 commits)
+- 👤 **Human dev:** ~$339 (3.4h @ $100/h, 30min dedup)
 
 Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

giton-0.1.8/VERSION

@@ -0,0 +1 @@
+0.1.8

giton-0.1.8/examples/plugins/README.md

@@ -0,0 +1,46 @@
+# Plugin example
+
+End-to-end demonstration of a custom giton plugin.
+
+This example registers a tiny shell-script plugin (`my_lint`) that simply
+echoes the staged paths it received. It then stages a file, runs the
+`pre-commit` trigger, and asserts the plugin actually executed and the
+`{paths}` placeholder was correctly expanded.
+
+## Running
+
+```bash
+# from the repo root
+python -m pytest examples/plugins/test_plugin_lifecycle.py -v
+```
+
+You should see:
+
+```
+PASSED  test_register_run_and_unregister
+PASSED  test_default_catalog_pyqual_command_is_valid
+```
+
+## What it covers
+
+| Step                           | API used                                        |
+| ------------------------------ | ----------------------------------------------- |
+| Build a fake plugin executable | plain `chmod +x`                                |
+| Register a plugin record       | `giton.config.upsert_plugin`                    |
+| Run the hook trigger           | `giton.runner.run_trigger("pre-commit")`        |
+| Inspect placeholder expansion  | reading the file the fake plugin wrote         |
+| Unregister                     | `giton.config.remove_plugin`                    |
+
+## Verifying the real default catalog
+
+The catalog ships three default plugins (`pyqual`, `vallm`, `pretest`)
+that point at sibling repos under `semcod/`. They are real Python
+packages with real CLIs, so you can install one and run it for real:
+
+```bash
+giton plugin install pyqual
+giton hook pre-commit          # runs `pyqual gates --workdir <repo>`
+```
+
+If `pyqual` reports a missing `pyqual.yaml`, run `pyqual init` first —
+that's a `pyqual` configuration step, unrelated to giton.

giton-0.1.8/examples/plugins/test_plugin_lifecycle.py

@@ -0,0 +1,116 @@
+"""End-to-end example: register a custom plugin, run it, observe the result.
+
+Run with:
+    pytest examples/plugins/test_plugin_lifecycle.py -v
+"""
+from __future__ import annotations
+
+import os
+import stat
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+def _git(args, cwd):
+    return subprocess.run(
+        ["git", *args], cwd=cwd, check=True, capture_output=True, text=True
+    )
+
+
+@pytest.fixture
+def isolated_repo(tmp_path, monkeypatch):
+    """A fresh git repo + isolated XDG_CONFIG_HOME so we don't touch
+    the real user's giton plugins."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    import importlib
+    from giton import config as _cfg
+    importlib.reload(_cfg)
+    from giton import plugins as _pl, runner as _rn
+    importlib.reload(_pl)
+    importlib.reload(_rn)
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(["init", "-q"], repo)
+    _git(["config", "user.email", "demo@example.com"], repo)
+    _git(["config", "user.name", "demo"], repo)
+    (repo / "README.md").write_text("# demo\n")
+    _git(["add", "README.md"], repo)
+    _git(["commit", "-q", "-m", "chore: seed"], repo)
+    return repo
+
+
+def test_register_run_and_unregister(isolated_repo, tmp_path, monkeypatch):
+    # 1) build a fake plugin executable that records its argv to a log
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    plugin = bin_dir / "my_lint"
+    log = tmp_path / "my_lint.log"
+    plugin.write_text(
+        "#!/bin/sh\n"
+        f"echo \"argv:$@\" > '{log}'\n"
+        "echo 'my_lint: ok'\n"
+        "exit 0\n"
+    )
+    plugin.chmod(plugin.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    monkeypatch.setenv("PATH", f"{bin_dir}:{os.environ['PATH']}")
+
+    # 2) register it as a giton plugin firing on pre-commit
+    from giton.config import PluginRecord, upsert_plugin, load_plugins, remove_plugin
+    upsert_plugin(PluginRecord(
+        name="my_lint",
+        description="example plugin",
+        category="lang:python",
+        exec_type="cli",
+        command="my_lint {paths}",
+        triggers=["pre-commit"],
+        install=None,
+        source="user",
+        enabled=True,
+    ))
+    assert any(p.name == "my_lint" for p in load_plugins())
+
+    # 3) stage a python file and fire the pre-commit trigger
+    (isolated_repo / "module.py").write_text("def f():\n    return 42\n")
+    _git(["add", "module.py"], isolated_repo)
+
+    from giton.runner import run_trigger
+    outcome = run_trigger("pre-commit", cwd=isolated_repo)
+
+    # 4) the plugin must have actually run
+    assert len(outcome.plugin_results) == 1
+    pr = outcome.plugin_results[0]
+    assert pr.plugin == "my_lint"
+    assert pr.ok, pr.stderr
+    assert "my_lint: ok" in pr.stdout
+
+    # 5) {paths} placeholder must have been expanded to the staged file
+    argv_line = log.read_text().strip()
+    assert "module.py" in argv_line, argv_line
+
+    # 6) unregister cleanly
+    assert remove_plugin("my_lint")
+    assert not any(p.name == "my_lint" for p in load_plugins())
+
+
+def test_default_catalog_pyqual_command_is_valid():
+    """Smoke-test the catalog metadata for the three default plugins."""
+    from giton import catalog
+
+    expected = {"pyqual", "vallm", "pretest"}
+    actual = {e.record.name for e in catalog.defaults()}
+    assert expected == actual
+
+    for entry in catalog.defaults():
+        cmd = entry.record.command
+        # every default command must declare which binary to invoke and
+        # the binary name must equal the plugin name
+        first_token = cmd.split()[0]
+        assert first_token == entry.record.name, (
+            f"plugin {entry.record.name!r} command starts with "
+            f"{first_token!r}; commands should always invoke their own binary"
+        )
+        # placeholders must format cleanly with reasonable values
+        cmd.format(paths="a.py", diff_file="/tmp/d.patch", root="/tmp/r")

{giton-0.1.7 → giton-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "giton"
-version = "0.1.7"
+version = "0.1.8"
 description = "Local AI layer for git: orchestrates policies & plugins between commit and push."
 readme = "README.md"
 requires-python = ">=3.10"

{giton-0.1.7 → giton-0.1.8}/src/giton/__init__.py

@@ -1,3 +1,3 @@
 """giton — local AI layer for git, between commit and push."""
 
-__version__ = "0.1.7"
+__version__ = "0.1.8"

{giton-0.1.7 → giton-0.1.8}/src/giton/catalog.py

@@ -54,7 +54,7 @@ CATALOG: dict[str, CatalogEntry] = {
         "Python code quality checks (lint, types, complexity).",
         category="lang:python",
         triggers=["pre-commit"],
-        command="pyqual check {paths}",
+        command="pyqual gates --workdir {root}",
         pypi="pyqual",
         local="../pyqual",
     ),
@@ -63,7 +63,7 @@ CATALOG: dict[str, CatalogEntry] = {
         "Validate LLM-generated code/patches before they land in history.",
         category="task:validate",
         triggers=["post-commit"],
-        command="vallm check --diff {diff_file}",
+        command="vallm batch {paths}",
         pypi="vallm",
         local="../vallm",
     ),
@@ -72,7 +72,7 @@ CATALOG: dict[str, CatalogEntry] = {
         "Run / generate tests before push.",
         category="task:test",
         triggers=["pre-push"],
-        command="pretest run",
+        command="pretest scan",
         pypi="pretest",
         local="../pretest",
     ),

giton-0.1.8/tests/test_plugin_runner.py

@@ -0,0 +1,208 @@
+"""End-to-end tests for the plugin runner using a real fake-plugin script.
+
+These tests verify that:
+  - `{paths}`, `{diff_file}`, `{root}` placeholders are correctly expanded
+  - Plugin stdout/stderr/exit-code are propagated into `TriggerOutcome`
+  - `enabled=False` plugins are skipped
+  - `unknown command` plugins are reported, not crashed
+  - `commit-msg` plugin trigger is honoured
+"""
+from __future__ import annotations
+
+import os
+import stat
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from giton.config import PluginRecord, USER_PLUGINS_FILE, load_plugins, save_plugins
+from giton.runner import run_trigger
+
+
+def _git(args, cwd):
+    return subprocess.run(
+        ["git", *args], cwd=cwd, check=True, capture_output=True, text=True
+    )
+
+
+@pytest.fixture
+def repo(tmp_path, monkeypatch):
+    """Initialise a clean repo + isolated giton config root."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    # reload config so USER_PLUGINS_FILE picks up the new XDG path
+    import importlib
+    from giton import config as _cfg
+    importlib.reload(_cfg)
+    from giton import plugins as _pl, runner as _rn
+    importlib.reload(_pl)
+    importlib.reload(_rn)
+
+    r = tmp_path / "r"
+    r.mkdir()
+    _git(["init", "-q"], r)
+    _git(["config", "user.email", "t@t"], r)
+    _git(["config", "user.name", "t"], r)
+    (r / "seed.txt").write_text("seed\n")
+    _git(["add", "seed.txt"], r)
+    _git(["commit", "-q", "-m", "feat: seed"], r)
+    return r
+
+
+def _write_fake_plugin(tmp_path: Path, name: str = "fakeplugin") -> Path:
+    """A real executable that records its argv and stdin to a file."""
+    script = tmp_path / name
+    log = tmp_path / f"{name}.log"
+    script.write_text(
+        "#!/bin/sh\n"
+        f"echo \"args:$@\" > '{log}'\n"
+        f"echo \"cwd:$PWD\" >> '{log}'\n"
+        "echo 'fake plugin ran'\n"
+        "exit ${FAKE_EXIT:-0}\n"
+    )
+    script.chmod(script.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    return script
+
+
+def _register(name: str, command: str, trigger: str, *, enabled: bool = True):
+    from giton import config as _cfg
+    plugins = _cfg.load_plugins()
+    plugins = [p for p in plugins if p.name != name]
+    plugins.append(PluginRecord(
+        name=name,
+        description="fake",
+        category="task:test",
+        exec_type="cli",
+        command=command,
+        triggers=[trigger],
+        install=None,
+        source="user",
+        enabled=enabled,
+    ))
+    _cfg.save_plugins(plugins)
+
+
+def test_plugin_executes_and_expands_paths(repo, tmp_path, monkeypatch):
+    fake = _write_fake_plugin(tmp_path)
+    log = tmp_path / "fakeplugin.log"
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    _register("fakeplugin", "fakeplugin {paths}", "pre-commit")
+
+    # stage a couple of files
+    (repo / "a.py").write_text("a=1\n")
+    (repo / "b.py").write_text("b=2\n")
+    _git(["add", "a.py", "b.py"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    assert len(out.plugin_results) == 1
+    pr = out.plugin_results[0]
+    assert pr.ok, pr.stderr
+    assert "fake plugin ran" in pr.stdout
+    # placeholder expansion: {paths} → "a.py b.py"
+    args_line = log.read_text().splitlines()[0]
+    assert "a.py" in args_line and "b.py" in args_line
+
+
+def test_plugin_diff_file_placeholder(repo, tmp_path, monkeypatch):
+    fake = _write_fake_plugin(tmp_path, "diffplug")
+    log = tmp_path / "diffplug.log"
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    _register("diffplug", "diffplug --diff {diff_file}", "post-commit")
+
+    (repo / "x.py").write_text("x=1\n")
+    _git(["add", "x.py"], repo)
+    _git(["commit", "-q", "-m", "feat: x"], repo)
+
+    out = run_trigger("post-commit", cwd=repo)
+    assert out.plugin_results and out.plugin_results[0].ok
+    args_line = log.read_text().splitlines()[0]
+    assert "--diff" in args_line
+    # diff_file path always resolves under .giton/
+    assert ".giton" in args_line
+
+
+def test_plugin_root_placeholder(repo, tmp_path, monkeypatch):
+    fake = _write_fake_plugin(tmp_path, "rootplug")
+    log = tmp_path / "rootplug.log"
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    _register("rootplug", "rootplug --workdir {root}", "pre-commit")
+
+    (repo / "z.txt").write_text("z\n")
+    _git(["add", "z.txt"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    assert out.plugin_results[0].ok
+    args_line = log.read_text().splitlines()[0]
+    assert str(repo) in args_line
+
+
+def test_plugin_failure_propagates_to_outcome(repo, tmp_path, monkeypatch):
+    _write_fake_plugin(tmp_path, "failplug")
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    monkeypatch.setenv("FAKE_EXIT", "3")
+    _register("failplug", "failplug", "pre-commit")
+
+    (repo / "f.txt").write_text("f\n")
+    _git(["add", "f.txt"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    assert out.plugin_results[0].returncode == 3
+    assert not out.plugin_results[0].ok
+    assert not out.ok
+
+
+def test_plugin_disabled_is_skipped(repo, tmp_path, monkeypatch):
+    _write_fake_plugin(tmp_path, "skipplug")
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    _register("skipplug", "skipplug", "pre-commit", enabled=False)
+
+    (repo / "g.txt").write_text("g\n")
+    _git(["add", "g.txt"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    assert out.plugin_results == []
+
+
+def test_plugin_command_not_found(repo):
+    # do NOT alter PATH (git must remain available); use a binary name that
+    # is overwhelmingly unlikely to exist anywhere on the system.
+    _register(
+        "ghostplug", "giton-nonexistent-fake-binary-xyz123", "pre-commit"
+    )
+
+    (repo / "h.txt").write_text("h\n")
+    _git(["add", "h.txt"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    assert out.plugin_results[0].returncode == 127
+    assert not out.ok
+
+
+def test_multiple_plugins_run_in_order(repo, tmp_path, monkeypatch):
+    _write_fake_plugin(tmp_path, "p1")
+    _write_fake_plugin(tmp_path, "p2")
+    monkeypatch.setenv("PATH", f"{tmp_path}:{os.environ['PATH']}")
+    _register("p1", "p1", "pre-commit")
+    _register("p2", "p2", "pre-commit")
+
+    (repo / "i.txt").write_text("i\n")
+    _git(["add", "i.txt"], repo)
+
+    out = run_trigger("pre-commit", cwd=repo)
+    names = [r.plugin for r in out.plugin_results]
+    assert names == ["p1", "p2"]
+    assert all(r.ok for r in out.plugin_results)
+
+
+def test_default_catalog_commands_are_well_formed():
+    """Catch regressions where a default plugin's command refers to a
+    non-existent subcommand. We can't run them in CI without the deps
+    installed, but we can verify the placeholder syntax parses."""
+    from giton import catalog
+    for entry in catalog.defaults():
+        cmd = entry.record.command
+        # placeholder substitution must succeed with reasonable inputs
+        formatted = cmd.format(paths="a.py", diff_file="/tmp/d.patch", root="/tmp/r")
+        assert formatted  # non-empty
+        # and the binary name (first token) must equal the entry name
+        assert formatted.split()[0] == entry.record.name

{giton-0.1.7 → giton-0.1.8}/uv.lock

@@ -819,7 +819,7 @@ wheels = [
 
 [[package]]
 name = "giton"
-version = "0.1.7"
+version = "0.1.8"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },

giton-0.1.7/VERSION

@@ -1 +0,0 @@
-0.1.7