commitstash 0.3.0__py3-none-any.whl

autocommit/providers.py

@@ -0,0 +1,119 @@
+"""LLM provider backends.
+
+Each provider turns a prompt into text. New backends (Gemini, Groq, a
+company-internal gateway, ...) plug in by subclassing LLMProvider and
+calling register() — no core code changes needed.
+"""
+
+import os
+from abc import ABC, abstractmethod
+
+
+class LLMProvider(ABC):
+    """One completion backend."""
+
+    name: str = ""
+
+    @abstractmethod
+    def complete(self, prompt: str, config: dict, max_tokens: int = 1024) -> str:
+        """Return the model's text response for a prompt."""
+
+
+class AnthropicProvider(LLMProvider):
+    name = "anthropic"
+
+    def complete(self, prompt: str, config: dict, max_tokens: int = 1024) -> str:
+        try:
+            import anthropic
+        except ImportError:
+            raise ImportError("Install the Anthropic SDK:  pip install anthropic")
+
+        if not os.getenv("ANTHROPIC_API_KEY"):
+            raise EnvironmentError(
+                "ANTHROPIC_API_KEY is not set.\nExport it:  export ANTHROPIC_API_KEY=sk-ant-..."
+            )
+
+        client = anthropic.Anthropic()
+        message = client.messages.create(
+            model=config.get("anthropic_model", "claude-opus-4-8"),
+            max_tokens=max_tokens,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        text = next((b.text for b in message.content if b.type == "text"), "")
+        return text.strip()
+
+
+class OpenAIProvider(LLMProvider):
+    name = "openai"
+
+    def complete(self, prompt: str, config: dict, max_tokens: int = 1024) -> str:
+        try:
+            from openai import OpenAI
+        except ImportError:
+            raise ImportError("Install the OpenAI SDK:  pip install openai")
+
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise EnvironmentError(
+                "OPENAI_API_KEY is not set.\nExport it:  export OPENAI_API_KEY=sk-..."
+            )
+
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model=config.get("openai_model", "gpt-4o-mini"),
+            max_tokens=max_tokens,
+            temperature=0.3,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return response.choices[0].message.content.strip()
+
+
+class OllamaProvider(LLMProvider):
+    """Local LLM via Ollama's native HTTP API — stdlib only, no SDK, no API key."""
+
+    name = "ollama"
+
+    def complete(self, prompt: str, config: dict, max_tokens: int = 1024) -> str:
+        import json
+        import urllib.error
+        import urllib.request
+
+        host = config.get("ollama_host", "http://localhost:11434")
+        payload = json.dumps(
+            {
+                "model": config.get("ollama_model", "llama3.2"),
+                "prompt": prompt,
+                "stream": False,
+                "options": {"num_predict": max_tokens},
+            }
+        ).encode()
+        req = urllib.request.Request(
+            f"{host}/api/generate", data=payload, headers={"Content-Type": "application/json"}
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                return json.load(resp)["response"].strip()
+        except urllib.error.URLError as e:
+            raise EnvironmentError(
+                f"Cannot reach Ollama at {host} ({e.reason}).\n"
+                "Is Ollama running?  Start it with:  ollama serve\n"
+                f"And pull the model:  ollama pull {config.get('ollama_model', 'llama3.2')}"
+            )
+
+
+PROVIDERS: dict = {}
+
+
+def register(provider: LLMProvider) -> None:
+    PROVIDERS[provider.name] = provider
+
+
+def get(name: str) -> LLMProvider:
+    try:
+        return PROVIDERS[name]
+    except KeyError:
+        raise ValueError(f"Unknown provider: {name}") from None
+
+
+for _p in (AnthropicProvider(), OpenAIProvider(), OllamaProvider()):
+    register(_p)

autocommit/review.py

@@ -0,0 +1,83 @@
+"""Code review of the staged diff.
+
+AI providers get a structured review prompt. Local mode runs deterministic
+checks only — leftover debug statements, conflict markers, new TODOs —
+and says so, rather than pretending a heuristic can judge correctness.
+"""
+
+import re
+from collections import namedtuple
+
+from .llm import LOCAL_PROVIDERS, complete
+
+Issue = namedtuple("Issue", ["file", "line", "kind", "detail"])
+
+REVIEW_PROMPT = """You are a senior engineer reviewing a git diff before it is committed.
+
+Changed files:
+{files}
+
+Staged diff:
+```
+{diff}
+```
+
+Review ONLY the changed lines. Report:
+1. Bugs — logic errors, off-by-one, unhandled edge cases, broken error handling
+2. Security issues — injection, unsafe deserialization, path traversal
+3. Clear mistakes — leftover debug code, dead code, wrong variable used
+
+Rules:
+- Be specific: name the file and quote the problematic line
+- Do NOT comment on style, formatting, or naming preferences
+- Do NOT suggest speculative refactors
+- If the diff looks correct, say exactly: "No issues found."
+- Order findings most severe first
+- Keep each finding to 1-3 sentences"""
+
+_DEBUG_PATTERNS = [
+    ("debug statement", re.compile(r"^\s*(print\(|console\.(log|debug)\(|debugger\b|breakpoint\(\)|pdb\.set_trace)")),
+    ("merge conflict marker", re.compile(r"^(<{7}|={7}|>{7})( |$)")),
+    ("new TODO/FIXME", re.compile(r"\b(TODO|FIXME|XXX)\b")),
+]
+
+_HUNK_HEADER = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+
+
+def offline_review(diff):
+    """Deterministic checks over added lines. Returns a list of Issues."""
+    issues = []
+    current_file = None
+    line_no = 0
+
+    for raw in diff.split("\n"):
+        if raw.startswith("diff --git "):
+            _, _, rest = raw.partition(" b/")
+            current_file = rest or None
+            continue
+        header = _HUNK_HEADER.match(raw)
+        if header:
+            line_no = int(header.group(1)) - 1
+            continue
+        if raw.startswith("-"):
+            continue
+        if raw.startswith("+") and not raw.startswith("+++"):
+            line_no += 1
+            content = raw[1:]
+            for kind, pattern in _DEBUG_PATTERNS:
+                if pattern.search(content):
+                    issues.append(Issue(current_file or "?", line_no, kind, content.strip()[:80]))
+                    break
+        elif not raw.startswith("\\"):
+            line_no += 1
+
+    return issues
+
+
+def review(diff, files, config):
+    """Return (text, is_offline). AI text for AI providers, None for local mode
+    (callers render offline_review() Issues instead)."""
+    if config.get("provider") in LOCAL_PROVIDERS:
+        return None, True
+    files_str = "\n".join(f"  - {f}" for f in files)
+    return complete(REVIEW_PROMPT.format(files=files_str, diff=diff), config, max_tokens=2000), False

autocommit/secrets.py

@@ -0,0 +1,85 @@
+"""Secret scanner — regex-based, deterministic, no network, no LLM.
+
+Scans only lines being ADDED in a diff, so pre-existing (already-committed)
+secrets don't block unrelated commits. Findings carry file, line number,
+rule name, and a redacted preview — the full secret is never printed.
+"""
+
+import re
+from collections import namedtuple
+
+Finding = namedtuple("Finding", ["file", "line", "rule", "preview"])
+
+# Each rule: (name, compiled pattern). Patterns target well-known token
+# formats first (low false-positive rate), then a generic assignment
+# catch-all last.
+RULES = [
+    ("AWS access key ID", re.compile(r"\bAKIA[0-9A-Z]{16}\b")),
+    ("GitHub token", re.compile(r"\bgh[pousr]_[A-Za-z0-9]{36,}\b")),
+    ("GitHub fine-grained PAT", re.compile(r"\bgithub_pat_[A-Za-z0-9_]{22,}\b")),
+    ("Anthropic API key", re.compile(r"\bsk-ant-[A-Za-z0-9_-]{20,}\b")),
+    ("OpenAI API key", re.compile(r"\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}\b")),
+    ("Slack token", re.compile(r"\bxox[baprs]-[A-Za-z0-9-]{10,}\b")),
+    ("Stripe live key", re.compile(r"\b[rs]k_live_[A-Za-z0-9]{20,}\b")),
+    ("Google API key", re.compile(r"\bAIza[0-9A-Za-z_-]{35}\b")),
+    ("Private key block", re.compile(r"-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY")),
+    ("JWT", re.compile(r"\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b")),
+    (
+        "Hardcoded credential assignment",
+        re.compile(
+            r"""(?ix)
+            \b(password|passwd|secret|api_?key|auth_?token|access_?token)\b
+            \s*[:=]\s*
+            ["'][^"'\s]{8,}["']
+            """
+        ),
+    ),
+]
+
+# Values that look like credentials but are clearly placeholders.
+PLACEHOLDER = re.compile(
+    r"(?i)(xxx+|\.\.\.|<[^>]+>|\{\{.*\}\}|\$\{.*\}|your[_-]|example|changeme|dummy|placeholder)"
+)
+
+HUNK_HEADER = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+
+
+def _redact(text, match):
+    """Show enough of the match to locate it, never the whole secret."""
+    secret = match.group(0)
+    if len(secret) <= 12:
+        return secret[:4] + "…"
+    return f"{secret[:8]}…{secret[-4:]}"
+
+
+def scan_diff(diff):
+    """Return a list of Findings for secrets in the ADDED lines of a unified diff."""
+    findings = []
+    current_file = None
+    line_no = 0
+
+    for raw in diff.split("\n"):
+        if raw.startswith("diff --git "):
+            _, _, rest = raw.partition(" b/")
+            current_file = rest or None
+            continue
+        header = HUNK_HEADER.match(raw)
+        if header:
+            line_no = int(header.group(1)) - 1
+            continue
+        if raw.startswith("-"):
+            continue  # removed line — doesn't count toward new-file line numbers...
+        if raw.startswith("+") and not raw.startswith("+++"):
+            line_no += 1
+            content = raw[1:]
+            for rule, pattern in RULES:
+                m = pattern.search(content)
+                if m and not PLACEHOLDER.search(m.group(0)):
+                    findings.append(
+                        Finding(current_file or "?", line_no, rule, _redact(content, m))
+                    )
+                    break  # one finding per line is enough
+        elif not raw.startswith("\\"):
+            line_no += 1  # context line
+
+    return findings

autocommit/split.py

@@ -0,0 +1,106 @@
+"""Intelligent commit splitting.
+
+Clusters the staged files into coherent commit groups — source changes by
+scope, then tests, docs, and config — so one oversized `git add .` becomes
+a clean series of atomic commits. AI providers propose the grouping from
+the diff; local mode uses the same deterministic classifiers the heuristic
+message generator uses. Splitting is file-level: a single file's hunks are
+never divided across commits, so no group can produce a broken in-between
+state that the file itself didn't have.
+"""
+
+import json
+import re
+from collections import namedtuple
+
+from .llm import LOCAL_PROVIDERS, _infer_scope, _is_config, _is_doc, _is_test, complete
+
+Group = namedtuple("Group", ["label", "files", "reason"])
+
+SPLIT_PROMPT = """You are splitting one large staged git change into atomic commits.
+
+Staged files:
+{files}
+
+Staged diff:
+```
+{diff}
+```
+
+Group the files into 2-6 logical commits. Files that implement one change
+belong together; unrelated concerns (docs, tests for other areas, config,
+separate features) belong apart. Source changes come before their tests.
+
+Respond with ONLY this JSON, no other text:
+{{"groups": [{{"reason": "<short description of the commit>", "files": ["path", ...]}}, ...]}}
+
+Every staged file must appear in exactly one group."""
+
+
+def _classify(path):
+    """Return (sort_key, label) for a file. Source scopes sort first."""
+    if _is_test(path):
+        return (2, "tests")
+    if _is_doc(path):
+        return (3, "docs")
+    if _is_config(path):
+        return (4, "config")
+    return (1, _infer_scope([path]) or "core")
+
+
+def propose_groups(files):
+    """Deterministic grouping: source files bucketed by scope, then tests, docs, config."""
+    buckets: dict = {}
+    for f in files:
+        key = _classify(f)
+        buckets.setdefault(key, []).append(f)
+
+    groups = []
+    for (order, label), members in sorted(buckets.items()):
+        reason = {
+            2: "test changes",
+            3: "documentation",
+            4: "config and tooling",
+        }.get(order, f"{label} changes")
+        groups.append(Group(label, members, reason))
+    return groups
+
+
+def _parse_ai_groups(raw, files):
+    """Parse the model's JSON. Returns groups only if they exactly partition files."""
+    fenced = re.search(r"\{.*\}", raw, re.DOTALL)
+    if not fenced:
+        return None
+    try:
+        data = json.loads(fenced.group(0))
+    except json.JSONDecodeError:
+        return None
+
+    groups = []
+    seen = []
+    for g in data.get("groups", []):
+        members = [f for f in g.get("files", []) if isinstance(f, str)]
+        if not members:
+            return None
+        groups.append(Group(_infer_scope(members) or "change", members, g.get("reason", "")))
+        seen.extend(members)
+
+    if sorted(seen) != sorted(files):
+        return None  # missing, duplicated, or invented files — don't trust it
+    return groups
+
+
+def propose_groups_ai(diff, files, config):
+    """AI grouping with strict validation; falls back to the heuristic.
+
+    Returns (groups, used_ai).
+    """
+    if config.get("provider") in LOCAL_PROVIDERS:
+        return propose_groups(files), False
+
+    files_str = "\n".join(f"  - {f}" for f in files)
+    raw = complete(SPLIT_PROMPT.format(files=files_str, diff=diff), config, max_tokens=1500)
+    groups = _parse_ai_groups(raw, files)
+    if groups is None:
+        return propose_groups(files), False
+    return groups, True