giton 0.1.2__py3-none-any.whl

giton/__init__.py

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

giton/__main__.py

@@ -0,0 +1,4 @@
+from giton.cli import app
+
+if __name__ == "__main__":
+    app()

giton/catalog.py

@@ -0,0 +1,173 @@
+"""Built-in plugin catalog.
+
+Defaults bundle three local-ecosystem plugins that are most useful in a
+day-to-day commit -> push loop. Extra entries are grouped into categories
+so the user can quickly install more via `giton plugin install <name>` or
+`giton plugin add-category <category>`.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from giton.config import PluginRecord
+
+
+@dataclass(frozen=True)
+class CatalogEntry:
+    record: PluginRecord
+    pip_local_path: str | None = None  # sibling repo path under semcod/
+
+
+# --- Defaults: three plugins activated by `giton init` ---------------------
+DEFAULT_PLUGIN_NAMES: tuple[str, ...] = ("pyqual", "vallm", "pretest")
+
+
+def _entry(
+    name: str,
+    desc: str,
+    *,
+    category: str,
+    triggers: list[str],
+    command: str,
+    pypi: str | None = None,
+    local: str | None = None,
+) -> CatalogEntry:
+    return CatalogEntry(
+        record=PluginRecord(
+            name=name,
+            description=desc,
+            category=category,
+            exec_type="cli",
+            command=command,
+            triggers=triggers,
+            install=pypi or local,
+            source="default",
+        ),
+        pip_local_path=local,
+    )
+
+
+CATALOG: dict[str, CatalogEntry] = {
+    # --- Default plugins -------------------------------------------------
+    "pyqual": _entry(
+        "pyqual",
+        "Python code quality checks (lint, types, complexity).",
+        category="lang:python",
+        triggers=["pre-commit"],
+        command="pyqual check {paths}",
+        pypi="pyqual",
+        local="../pyqual",
+    ),
+    "vallm": _entry(
+        "vallm",
+        "Validate LLM-generated code/patches before they land in history.",
+        category="task:validate",
+        triggers=["post-commit"],
+        command="vallm check --diff {diff_file}",
+        pypi="vallm",
+        local="../vallm",
+    ),
+    "pretest": _entry(
+        "pretest",
+        "Run / generate tests before push.",
+        category="task:test",
+        triggers=["pre-push"],
+        command="pretest run",
+        pypi="pretest",
+        local="../pretest",
+    ),
+
+    # --- Quick-extend: language plugins ---------------------------------
+    "domd": _entry(
+        "domd",
+        "Markdown / docs linter and fixer.",
+        category="lang:markdown",
+        triggers=["pre-commit"],
+        command="domd lint {paths}",
+        pypi="domd",
+        local="../domd",
+    ),
+    "code2llm": _entry(
+        "code2llm",
+        "Pack the repo into LLM-ready context for AI plugins.",
+        category="lang:any",
+        triggers=["post-commit"],
+        command="code2llm pack --staged",
+        pypi="code2llm",
+        local="../code2llm",
+    ),
+
+    # --- Quick-extend: task plugins -------------------------------------
+    "prefact": _entry(
+        "prefact",
+        "AI refactoring suggestions as fixup! commits.",
+        category="task:refactor",
+        triggers=["post-commit"],
+        command="prefact suggest --diff {diff_file}",
+        pypi="prefact",
+        local="../prefact",
+    ),
+    "redsl": _entry(
+        "redsl",
+        "Auto-fix lint/style issues and stage as fixup.",
+        category="task:autofix",
+        triggers=["pre-commit"],
+        command="redsl autofix {paths}",
+        pypi="redsl",
+        local="../redsl",
+    ),
+    "pfix": _entry(
+        "pfix",
+        "Generic patch fixer — apply small AI-proposed patches.",
+        category="task:fix",
+        triggers=["post-commit"],
+        command="pfix apply --diff {diff_file}",
+        pypi="pfix",
+        local="../pfix",
+    ),
+    "todocs": _entry(
+        "todocs",
+        "Generate / update docs from staged changes.",
+        category="task:docs",
+        triggers=["pre-push"],
+        command="todocs sync --staged",
+        pypi="todocs",
+        local="../todocs",
+    ),
+    "prellm": _entry(
+        "prellm",
+        "Pre-LLM gate: redact secrets / shrink context before AI calls.",
+        category="task:security",
+        triggers=["pre-commit"],
+        command="prellm scan {paths}",
+        pypi="prellm",
+        local="../prellm",
+    ),
+
+    # --- Quick-extend: integrations -------------------------------------
+    "git-commit-mcp": _entry(
+        "git-commit-mcp",
+        "External MCP server for Conventional Commit messages.",
+        category="integration:mcp",
+        triggers=["pre-push"],
+        command="git-commit-mcp-server --once",
+        pypi="git-commit-mcp-server",
+    ),
+}
+
+
+def list_categories() -> dict[str, list[str]]:
+    out: dict[str, list[str]] = {}
+    for name, entry in CATALOG.items():
+        out.setdefault(entry.record.category, []).append(name)
+    for v in out.values():
+        v.sort()
+    return dict(sorted(out.items()))
+
+
+def find(name: str) -> CatalogEntry | None:
+    return CATALOG.get(name)
+
+
+def defaults() -> list[CatalogEntry]:
+    return [CATALOG[n] for n in DEFAULT_PLUGIN_NAMES]

giton/cli.py

@@ -0,0 +1,171 @@
+"""giton CLI — Typer entry point."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from giton import __version__, plugins as plug, shell as giton_shell
+from giton.context import collect, repo_root
+from giton.hooks import install as install_hooks, uninstall as uninstall_hooks
+from giton.runner import run_trigger
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="giton — local AI layer for git, between commit and push.",
+)
+plugin_app = typer.Typer(no_args_is_help=True, help="Manage plugins")
+hook_app = typer.Typer(no_args_is_help=True, help="Run hook logic (used by .git/hooks)")
+app.add_typer(plugin_app, name="plugin")
+app.add_typer(hook_app, name="hook")
+
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def _root(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Show version and exit."),
+):
+    if version:
+        console.print(f"giton {__version__}")
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+# --- top-level commands -----------------------------------------------------
+
+@app.command()
+def init(
+    install_default_plugins: bool = typer.Option(
+        True, "--with-defaults/--no-defaults",
+        help="Also install the 3 default plugins.",
+    ),
+):
+    """Install giton git hooks in the current repository."""
+    root = repo_root()
+    if not root:
+        console.print("[red]not inside a git repository[/red]")
+        raise typer.Exit(1)
+    written = install_hooks(root)
+    console.print(f"[green]✓ installed {len(written)} hook(s) in {root}/.git/hooks[/green]")
+    for w in written:
+        console.print(f"  • {w.name}")
+    if install_default_plugins:
+        console.print("\n[bold]Installing default plugins…[/bold]")
+        plug.install_defaults()
+    console.print(
+        "\n[dim]Tip: open the interactive shell with `giton shell`.[/dim]"
+    )
+
+
+@app.command()
+def uninit():
+    """Remove giton hooks from the current repository (restore backups)."""
+    root = repo_root()
+    if not root:
+        console.print("[red]not inside a git repository[/red]")
+        raise typer.Exit(1)
+    removed = uninstall_hooks(root)
+    console.print(f"[green]removed {len(removed)} giton hook(s)[/green]")
+
+
+@app.command()
+def status():
+    """Show repo summary."""
+    ctx = collect()
+    if not ctx:
+        console.print("[yellow]not inside a git repository[/yellow]")
+        raise typer.Exit(1)
+    console.print(f"[bold]repo[/bold]    {ctx.root}")
+    console.print(f"[bold]last[/bold]    {ctx.last_commit_subject or '(no commits yet)'}")
+    console.print(f"[bold]staged[/bold]  {len(ctx.staged_paths)} file(s)")
+    for p in ctx.staged_paths:
+        console.print(f"   • {p}")
+
+
+@app.command()
+def shell():
+    """Launch the interactive giton shell."""
+    giton_shell.run()
+
+
+@app.command()
+def doctor():
+    """Quick environment check."""
+    import shutil
+    git_ok = shutil.which("git") is not None
+    console.print(f"git available: {'[green]yes[/green]' if git_ok else '[red]no[/red]'}")
+    root = repo_root()
+    console.print(f"git repo:      {root if root else '[yellow]not in a repo[/yellow]'}")
+    plug.show_table()
+
+
+# --- plugin subcommands -----------------------------------------------------
+
+@plugin_app.command("list")
+def plugin_list():
+    """List registered plugins."""
+    plug.show_table()
+
+
+@plugin_app.command("catalog")
+def plugin_catalog():
+    """Show the catalog of available plugins."""
+    plug.show_catalog()
+
+
+@plugin_app.command("install")
+def plugin_install(name: str):
+    """Install a plugin by catalog name."""
+    plug.install_from_catalog(name)
+
+
+@plugin_app.command("install-defaults")
+def plugin_install_defaults():
+    """Install the 3 default plugins (pyqual, vallm, pretest)."""
+    plug.install_defaults()
+
+
+@plugin_app.command("install-category")
+def plugin_install_category(category: str):
+    """Install every plugin in the given catalog category (e.g. lang:python)."""
+    n = plug.install_category(category)
+    console.print(f"[green]installed {n} plugin(s) from category '{category}'[/green]")
+
+
+@plugin_app.command("remove")
+def plugin_remove(name: str):
+    """Unregister a plugin."""
+    plug.uninstall(name)
+
+
+# --- hook subcommands -------------------------------------------------------
+
+@hook_app.command("pre-commit")
+def hook_pre_commit():
+    """Run pre-commit plugins."""
+    results = run_trigger("pre-commit")
+    if any(not r.ok for r in results):
+        raise typer.Exit(1)
+
+
+@hook_app.command("post-commit")
+def hook_post_commit():
+    """Run post-commit plugins (never blocks the commit)."""
+    run_trigger("post-commit")
+
+
+@hook_app.command("pre-push")
+def hook_pre_push():
+    """Run pre-push plugins."""
+    results = run_trigger("pre-push")
+    if any(not r.ok for r in results):
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

giton/config.py

@@ -0,0 +1,74 @@
+"""User and repository config for giton."""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+def _xdg_config_home() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")
+
+
+USER_CONFIG_DIR = _xdg_config_home() / "giton"
+USER_PLUGINS_FILE = USER_CONFIG_DIR / "plugins.json"
+REPO_CONFIG_PATH = ".giton/config.yaml"
+
+
+@dataclass
+class PluginRecord:
+    name: str
+    description: str = ""
+    category: str = "task"  # "lang" | "task" | "integration"
+    exec_type: str = "cli"  # "cli" | "mcp" | "rest"
+    command: str = ""        # shell command template, e.g. "pyqual check {paths}"
+    triggers: list[str] = field(default_factory=lambda: ["pre-commit"])
+    install: str | None = None  # pip target (PyPI name, VCS URL, or local path)
+    enabled: bool = True
+    source: str = "user"     # "default" | "user"
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.__dict__.copy()
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "PluginRecord":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+
+def ensure_user_dirs() -> None:
+    USER_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_plugins() -> list[PluginRecord]:
+    ensure_user_dirs()
+    if not USER_PLUGINS_FILE.exists():
+        return []
+    try:
+        raw = json.loads(USER_PLUGINS_FILE.read_text())
+    except json.JSONDecodeError:
+        return []
+    return [PluginRecord.from_dict(p) for p in raw.get("plugins", [])]
+
+
+def save_plugins(plugins: list[PluginRecord]) -> None:
+    ensure_user_dirs()
+    payload = {"plugins": [p.to_dict() for p in plugins]}
+    USER_PLUGINS_FILE.write_text(json.dumps(payload, indent=2))
+
+
+def upsert_plugin(plugin: PluginRecord) -> None:
+    plugins = load_plugins()
+    plugins = [p for p in plugins if p.name != plugin.name]
+    plugins.append(plugin)
+    save_plugins(plugins)
+
+
+def remove_plugin(name: str) -> bool:
+    plugins = load_plugins()
+    new = [p for p in plugins if p.name != name]
+    if len(new) == len(plugins):
+        return False
+    save_plugins(new)
+    return True

giton/context.py

@@ -0,0 +1,66 @@
+"""Collect git context (status, staged diff, recent commits)."""
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def _run(cmd: list[str], cwd: Path | None = None) -> str:
+    res = subprocess.run(
+        cmd, cwd=cwd, check=False, capture_output=True, text=True
+    )
+    return res.stdout
+
+
+def repo_root(cwd: Path | None = None) -> Path | None:
+    out = _run(["git", "rev-parse", "--show-toplevel"], cwd=cwd).strip()
+    return Path(out) if out else None
+
+
+@dataclass
+class GitContext:
+    root: Path
+    staged_paths: list[str] = field(default_factory=list)
+    staged_diff: str = ""
+    last_commit_subject: str = ""
+    last_commit_body: str = ""
+    upstream_range: str = ""
+
+    def diff_file(self) -> Path:
+        f = self.root / ".giton" / "last_diff.patch"
+        f.parent.mkdir(parents=True, exist_ok=True)
+        f.write_text(self.staged_diff)
+        return f
+
+    def paths_arg(self) -> str:
+        return " ".join(self.staged_paths) if self.staged_paths else "."
+
+
+def collect(cwd: Path | None = None) -> GitContext | None:
+    root = repo_root(cwd)
+    if not root:
+        return None
+    staged_names = [
+        p.strip()
+        for p in _run(
+            ["git", "diff", "--cached", "--name-only"], cwd=root
+        ).splitlines()
+        if p.strip()
+    ]
+    staged_diff = _run(["git", "diff", "--cached"], cwd=root)
+    last_subject = _run(["git", "log", "-1", "--pretty=%s"], cwd=root).strip()
+    last_body = _run(["git", "log", "-1", "--pretty=%b"], cwd=root).strip()
+    upstream = _run(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cwd=root,
+    ).strip()
+    rng = f"{upstream}..HEAD" if upstream else ""
+    return GitContext(
+        root=root,
+        staged_paths=staged_names,
+        staged_diff=staged_diff,
+        last_commit_subject=last_subject,
+        last_commit_body=last_body,
+        upstream_range=rng,
+    )

giton/hooks.py

@@ -0,0 +1,48 @@
+"""Install / uninstall git hooks that delegate to `giton hook <name>`."""
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+
+HOOKS = ("pre-commit", "post-commit", "pre-push")
+
+HOOK_TEMPLATE = """#!/bin/sh
+# Installed by giton — delegates to: giton hook {name}
+exec giton hook {name} "$@"
+"""
+
+
+def hooks_dir(repo_root: Path) -> Path:
+    return repo_root / ".git" / "hooks"
+
+
+def install(repo_root: Path) -> list[Path]:
+    hd = hooks_dir(repo_root)
+    if not hd.exists():
+        raise FileNotFoundError(f"Not a git repository: {repo_root}")
+    written: list[Path] = []
+    for hook in HOOKS:
+        target = hd / hook
+        if target.exists():
+            backup = target.with_suffix(target.suffix + ".giton-backup")
+            if not backup.exists():
+                target.rename(backup)
+        target.write_text(HOOK_TEMPLATE.format(name=hook))
+        target.chmod(target.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        written.append(target)
+    return written
+
+
+def uninstall(repo_root: Path) -> list[Path]:
+    hd = hooks_dir(repo_root)
+    removed: list[Path] = []
+    for hook in HOOKS:
+        target = hd / hook
+        if target.exists() and "giton hook" in target.read_text():
+            target.unlink()
+            backup = target.with_suffix(target.suffix + ".giton-backup")
+            if backup.exists():
+                backup.rename(target)
+            removed.append(target)
+    return removed

giton/plugins.py

@@ -0,0 +1,120 @@
+"""Plugin install / list / enable management."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from giton import catalog
+from giton.config import (
+    PluginRecord,
+    load_plugins,
+    remove_plugin,
+    upsert_plugin,
+)
+
+console = Console()
+
+
+def _pip_install(target: str) -> int:
+    cmd = [sys.executable, "-m", "pip", "install", target]
+    console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
+    return subprocess.run(cmd, check=False).returncode
+
+
+def install_from_catalog(name: str, *, prefer_local: bool = True) -> bool:
+    entry = catalog.find(name)
+    if entry is None:
+        console.print(f"[red]Unknown plugin: {name}[/red]")
+        return False
+
+    target: str | None = None
+    if prefer_local and entry.pip_local_path:
+        local = (Path(__file__).resolve().parents[2] / entry.pip_local_path).resolve()
+        if local.exists() and (local / "pyproject.toml").exists():
+            target = str(local)
+    if target is None:
+        target = entry.record.install or name
+
+    rc = _pip_install(target)
+    if rc != 0:
+        console.print(
+            f"[yellow]pip install failed for {name}; "
+            f"registering plugin record anyway[/yellow]"
+        )
+    upsert_plugin(entry.record)
+    console.print(f"[green]✓ registered plugin '{name}'[/green]")
+    return rc == 0
+
+
+def install_defaults() -> None:
+    for entry in catalog.defaults():
+        install_from_catalog(entry.record.name)
+
+
+def install_category(category: str) -> int:
+    matches = [e for e in catalog.CATALOG.values() if e.record.category == category]
+    if not matches:
+        console.print(f"[red]No plugins in category '{category}'[/red]")
+        return 0
+    n = 0
+    for e in matches:
+        if install_from_catalog(e.record.name):
+            n += 1
+    return n
+
+
+def uninstall(name: str) -> bool:
+    if remove_plugin(name):
+        console.print(f"[green]✓ removed plugin '{name}'[/green]")
+        return True
+    console.print(f"[yellow]plugin '{name}' was not registered[/yellow]")
+    return False
+
+
+def show_table() -> None:
+    plugins = load_plugins()
+    table = Table(title="giton plugins", show_lines=False)
+    table.add_column("name", style="bold")
+    table.add_column("category")
+    table.add_column("triggers")
+    table.add_column("command", style="dim")
+    table.add_column("status")
+    for p in plugins:
+        present = "✓" if shutil.which(p.command.split()[0]) else "✗"
+        status = f"{'enabled' if p.enabled else 'disabled'} / cmd:{present}"
+        table.add_row(
+            p.name,
+            p.category,
+            ",".join(p.triggers),
+            p.command,
+            status,
+        )
+    if not plugins:
+        console.print("[dim]No plugins registered. Try: giton plugin install-defaults[/dim]")
+    else:
+        console.print(table)
+
+
+def show_catalog() -> None:
+    table = Table(title="giton catalog (available plugins)")
+    table.add_column("name", style="bold")
+    table.add_column("category")
+    table.add_column("default", justify="center")
+    table.add_column("description")
+    defaults = set(catalog.DEFAULT_PLUGIN_NAMES)
+    for name, entry in catalog.CATALOG.items():
+        table.add_row(
+            name,
+            entry.record.category,
+            "★" if name in defaults else "",
+            entry.record.description,
+        )
+    console.print(table)
+    console.print("\n[bold]Categories[/bold]")
+    for cat, names in catalog.list_categories().items():
+        console.print(f"  [cyan]{cat}[/cyan]: {', '.join(names)}")

giton/runner.py

@@ -0,0 +1,85 @@
+"""Run plugins for a given hook trigger."""
+from __future__ import annotations
+
+import shlex
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.console import Console
+
+from giton.config import PluginRecord, load_plugins
+from giton.context import GitContext, collect
+
+console = Console()
+
+
+@dataclass
+class PluginResult:
+    plugin: str
+    returncode: int
+    stdout: str
+    stderr: str
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+
+def _format_command(cmd: str, ctx: GitContext) -> str:
+    return cmd.format(
+        paths=ctx.paths_arg(),
+        diff_file=str(ctx.diff_file()),
+        root=str(ctx.root),
+    )
+
+
+def run_trigger(trigger: str, cwd: Path | None = None) -> list[PluginResult]:
+    ctx = collect(cwd)
+    if ctx is None:
+        console.print("[yellow]giton: not inside a git repository[/yellow]")
+        return []
+
+    plugins = [p for p in load_plugins() if p.enabled and trigger in p.triggers]
+    if not plugins:
+        console.print(f"[dim]giton: no plugins registered for {trigger}[/dim]")
+        return []
+
+    results: list[PluginResult] = []
+    for plugin in plugins:
+        results.append(_run_plugin(plugin, ctx))
+    return results
+
+
+def _run_plugin(plugin: PluginRecord, ctx: GitContext) -> PluginResult:
+    if plugin.exec_type != "cli":
+        console.print(
+            f"[yellow]giton: exec_type '{plugin.exec_type}' not yet "
+            f"implemented for plugin {plugin.name}[/yellow]"
+        )
+        return PluginResult(plugin.name, 0, "", "skipped")
+
+    cmd_str = _format_command(plugin.command, ctx)
+    console.print(f"[bold cyan]› {plugin.name}[/bold cyan] [dim]{cmd_str}[/dim]")
+    try:
+        proc = subprocess.run(
+            shlex.split(cmd_str),
+            cwd=ctx.root,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        console.print(
+            f"[red]giton: plugin '{plugin.name}' not installed "
+            f"(command: {cmd_str.split()[0]})[/red]"
+        )
+        return PluginResult(plugin.name, 127, "", "command not found")
+
+    if proc.stdout:
+        console.print(proc.stdout.rstrip())
+    if proc.stderr:
+        console.print(f"[dim]{proc.stderr.rstrip()}[/dim]")
+    status = "[green]ok[/green]" if proc.returncode == 0 else f"[red]fail ({proc.returncode})[/red]"
+    console.print(f"  → {status}")
+    return PluginResult(plugin.name, proc.returncode, proc.stdout, proc.stderr)

giton/shell.py

@@ -0,0 +1,168 @@
+"""Interactive `giton shell` REPL.
+
+Lightweight, dependency-free (uses builtin `input`). Provides shortcuts for
+the most common operations: managing plugins, running hooks, inspecting
+the current repo. Type `help` to see commands.
+"""
+from __future__ import annotations
+
+import shlex
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+
+from giton import catalog, plugins as plug
+from giton.context import collect, repo_root
+from giton.hooks import install as install_hooks
+from giton.runner import run_trigger
+
+console = Console()
+
+BANNER = """[bold cyan]giton[/bold cyan] interactive shell — local AI layer for git
+type [bold]help[/bold] for commands, [bold]exit[/bold] to quit
+"""
+
+HELP = """\
+[bold]Plugins[/bold]
+  ls                       list registered plugins
+  catalog                  show available plugins + categories
+  install <name>           install a plugin from the catalog
+  install-defaults         install the 3 default plugins (pyqual, vallm, pretest)
+  install-category <cat>   install all plugins of a category (e.g. lang:python)
+  remove <name>            unregister a plugin
+  enable <name> / disable <name>
+
+[bold]Repo / hooks[/bold]
+  init                     install git hooks in the current repo
+  status                   show repo + staged-files summary
+  hook <pre-commit|post-commit|pre-push>
+                           run all plugins for that trigger
+
+[bold]Misc[/bold]
+  help                     show this help
+  exit / quit              leave the shell
+"""
+
+
+def _set_enabled(name: str, value: bool) -> None:
+    from giton.config import load_plugins, save_plugins
+    plugins = load_plugins()
+    found = False
+    for p in plugins:
+        if p.name == name:
+            p.enabled = value
+            found = True
+    if found:
+        save_plugins(plugins)
+        console.print(f"[green]{'enabled' if value else 'disabled'} {name}[/green]")
+    else:
+        console.print(f"[yellow]plugin '{name}' not registered[/yellow]")
+
+
+def _cmd_status() -> None:
+    ctx = collect()
+    if not ctx:
+        console.print("[yellow]not inside a git repo[/yellow]")
+        return
+    console.print(
+        Panel.fit(
+            f"[bold]repo[/bold]   {ctx.root}\n"
+            f"[bold]last[/bold]   {ctx.last_commit_subject or '(no commits yet)'}\n"
+            f"[bold]staged[/bold] {len(ctx.staged_paths)} file(s)"
+            + ("\n  " + "\n  ".join(ctx.staged_paths) if ctx.staged_paths else ""),
+            title="giton status",
+        )
+    )
+
+
+def _cmd_init() -> None:
+    root = repo_root()
+    if not root:
+        console.print("[red]not inside a git repository[/red]")
+        return
+    written = install_hooks(root)
+    console.print(f"[green]installed {len(written)} hook(s) in {root}/.git/hooks[/green]")
+    for w in written:
+        console.print(f"  • {w.name}")
+
+
+COMMANDS = {
+    "ls", "catalog", "install", "install-defaults", "install-category",
+    "remove", "enable", "disable", "init", "status", "hook",
+    "help", "exit", "quit",
+}
+
+
+def dispatch(line: str) -> bool:
+    """Return False if the shell should exit."""
+    line = line.strip()
+    if not line:
+        return True
+    parts = shlex.split(line)
+    cmd, args = parts[0], parts[1:]
+
+    if cmd in {"exit", "quit"}:
+        return False
+    if cmd == "help":
+        console.print(HELP)
+    elif cmd == "ls":
+        plug.show_table()
+    elif cmd == "catalog":
+        plug.show_catalog()
+    elif cmd == "install":
+        if not args:
+            console.print("[yellow]usage: install <name>[/yellow]")
+        else:
+            plug.install_from_catalog(args[0])
+    elif cmd == "install-defaults":
+        plug.install_defaults()
+    elif cmd == "install-category":
+        if not args:
+            console.print("[yellow]usage: install-category <category>[/yellow]")
+            console.print("Categories: " + ", ".join(catalog.list_categories()))
+        else:
+            plug.install_category(args[0])
+    elif cmd == "remove":
+        if not args:
+            console.print("[yellow]usage: remove <name>[/yellow]")
+        else:
+            plug.uninstall(args[0])
+    elif cmd == "enable":
+        if not args:
+            console.print("[yellow]usage: enable <name>[/yellow]")
+        else:
+            _set_enabled(args[0], True)
+    elif cmd == "disable":
+        if not args:
+            console.print("[yellow]usage: disable <name>[/yellow]")
+        else:
+            _set_enabled(args[0], False)
+    elif cmd == "init":
+        _cmd_init()
+    elif cmd == "status":
+        _cmd_status()
+    elif cmd == "hook":
+        if not args or args[0] not in {"pre-commit", "post-commit", "pre-push"}:
+            console.print("[yellow]usage: hook <pre-commit|post-commit|pre-push>[/yellow]")
+        else:
+            run_trigger(args[0])
+    else:
+        console.print(f"[red]unknown command: {cmd}[/red] — try 'help'")
+    return True
+
+
+def run() -> None:
+    console.print(Panel(BANNER, border_style="cyan"))
+    while True:
+        try:
+            line = input("giton> ")
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            break
+        try:
+            if not dispatch(line):
+                break
+        except Exception as e:  # pragma: no cover - defensive
+            console.print(f"[red]error:[/red] {e}")
+    console.print("[dim]bye.[/dim]")

giton-0.1.2.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: giton
+Version: 0.1.2
+Summary: Local AI layer for git: orchestrates policies & plugins between commit and push.
+Author: semcod
+Author-email: Tom Sapletta <tom@sapletta.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: costs>=0.1.20; extra == 'dev'
+Requires-Dist: goal>=2.1.0; extra == 'dev'
+Requires-Dist: pfix>=0.1.60; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# giton
+
+
+## AI Cost Tracking
+
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.2-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.41-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-3.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+
+- 🤖 **LLM usage:** $0.4093 (6 commits)
+- 👤 **Human dev:** ~$300 (3.0h @ $100/h, 30min dedup)
+
+Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+
+---
+
+`giton` is a local AI layer for Git that works between `commit` and `push`.
+It helps standardize commits, propose safe code fixes, and orchestrate external tools via plugins.
+
+## Does something like this already exist?
+
+Partially: there are tools for AI commit messages, git hooks, and commit-history rewriting.
+What is still missing is one local operator that:
+
+- interacts with the user right after commit,
+- proposes code fixes as additional commits (`fixup!`),
+- cleans up history before `push`,
+- integrates plugins via MCP/REST/CLI/gRPC.
+
+## Proposed direction for `gix`
+
+1. **Local-first with safe defaults**
+   - AI proposes changes, user approves them.
+   - Prefer `fixup!` commits over automatic history rewriting.
+
+2. **Git hook layer**
+   - `pre-commit`: policy validation and quick fixes.
+   - `post-commit`: inspect the fresh commit and propose follow-up patches.
+   - `pre-push`: standardize history (`autosquash`, commit naming, final checks).
+
+3. **Plugin architecture**
+   - Shared input/output contract (JSON schema).
+   - Plugin adapters: MCP, REST, CLI shell, gRPC/protobuf.
+
+## MVP usage example
+
+After `giton init`, hooks are installed and run automatically from Git lifecycle events.
+The commands below show equivalent manual execution for demonstration/debugging.
+
+```bash
+# 1) initialize hooks in the repository
+giton init
+
+# 2) user makes a normal commit
+git add -p
+git commit -m "update stuff"
+
+# 3) equivalent manual run: post-commit hook logic
+giton hook post-commit
+
+# 4) equivalent manual run: pre-push hook logic
+giton hook pre-push
+```
+
+Example interaction:
+
+```text
+giton: Found 2 issues (example: null check, commit message policy).
+giton: Apply patch and add commit "fixup! ..."? [Y/n]
+```
+
+## MVP plan
+
+- MVP 1: hooks + policy engine + interactive CLI
+- MVP 2: patching + fixup workflow + pre-push autosquash
+- MVP 3: stable plugin API and MCP/REST/CLI/gRPC integrations
+
+## Install
+
+```bash
+pip install giton
+```
+
+## Quick start
+
+```bash
+giton init                # install git hooks + 3 default plugins
+giton shell               # interactive REPL
+giton plugin catalog      # browse all available plugins
+giton plugin install domd # install a specific extension
+giton plugin install-category lang:python   # install everything for a language
+```
+
+### Default plugins
+
+The 3 plugins activated by `gix init` cover the most common
+day-to-day needs in a `commit → push` loop:
+
+| name      | category        | trigger      | role                                       |
+| --------- | --------------- | ------------ | ------------------------------------------ |
+| `pyqual`  | `lang:python`   | `pre-commit` | Python lint / type / complexity checks      |
+| `vallm`   | `task:validate` | `post-commit`| Validate AI-generated code/patches          |
+| `pretest` | `task:test`     | `pre-push`   | Run / generate tests before push            |
+
+### Quick-extend categories
+
+Each plugin in the catalog is tagged with a category, so you can install
+groups at once:
+
+- **languages:** `lang:python`, `lang:markdown`, `lang:any`
+- **tasks:** `task:validate`, `task:test`, `task:refactor`,
+  `task:autofix`, `task:fix`, `task:docs`, `task:security`
+- **integrations:** `integration:mcp`
+
+```bash
+giton plugin install-category task:autofix
+```
+
+### Interactive shell
+
+```text
+$ giton shell
+giton> help
+giton> install-defaults
+giton> hook pre-commit
+giton> catalog
+giton> install prefact
+```
+
+### Plugin contract
+
+A plugin is any executable command (CLI). The catalog entry declares its
+trigger, category, install target (PyPI/local path) and command template.
+The runner expands `{paths}`, `{diff_file}` and `{root}` placeholders
+with the current git context before invocation.
+
+Future exec types (`mcp`, `rest`) will share the same JSON in/out
+contract: input = git context + policy findings, output = list of
+proposed actions (patches, fixup commits, warnings).
+
+
+## License
+
+Licensed under Apache-2.0.

giton-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+giton/__init__.py,sha256=y-NNnl_lgT4vtmm9UzbpyR2x2bUM1Y0u8lM8CVV0uVk,88
+giton/__main__.py,sha256=heJWDTM0XZjRAsWupjf4c4gB5f-T-KdtqJAqtQtnFhw,64
+giton/catalog.py,sha256=Q_rmEofo47o9qp1HtngjK3WnxpkFLjekcNLzi1UQs6o,4931
+giton/cli.py,sha256=T1XI-8wIOCAxwXq9Hlk6-47QPFwLj_lxJAcpyt8xw1E,4977
+giton/config.py,sha256=0COeuXAO7iTObSwuVao9fVU5FjalJ2jLg2t3Yoz4g-I,2190
+giton/context.py,sha256=oyhLV0_A_2bCYIUuwvtJqCw_qzWeAa39iB2YuC8NOVA,1979
+giton/hooks.py,sha256=UtGnbycg6f4_vYFfFIe7kxlcoI7aACWtzo_fdvNVMN8,1480
+giton/plugins.py,sha256=0L1palw9afn6TnTy3dC4tW_LwgPTWV75xdQkaifyhPo,3639
+giton/runner.py,sha256=_CBMsp51Y7d6zNp9Mr_MmSxa87HJRF5S3QsTYHyi_uc,2511
+giton/shell.py,sha256=wY3jMSzQSpcHLM5pF9RyLWDFeyNM5F-l7TQl83W8yMc,5367
+giton-0.1.2.dist-info/METADATA,sha256=9wPeZj9aZTLBQEwiVxz2mzdAjC-RYBl2VKjk2SD00SM,5236
+giton-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+giton-0.1.2.dist-info/entry_points.txt,sha256=qAbV6Ovw8-ES88rDx6xlWYtPi1zh-EDFA4WBgn1ZmdE,40
+giton-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+giton-0.1.2.dist-info/RECORD,,

giton-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

giton-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+giton = giton.cli:app

giton-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.