commitstash 0.3.0__py3-none-any.whl

autocommit/config.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+
+CONFIG_PATH = Path.home() / ".autocommit" / "config.json"
+
+DEFAULTS = {
+    "provider": "anthropic",
+    "anthropic_model": "claude-opus-4-8",
+    "openai_model": "gpt-4o-mini",
+    "ollama_model": "llama3.2",
+    "ollama_host": "http://localhost:11434",
+    "style": "conventional",
+    "include_scope": True,
+    "include_body": False,
+    "emoji": False,
+    "max_diff_lines": 500,
+    "scan_secrets": True,
+}
+
+
+def load_config():
+    config = DEFAULTS.copy()
+    if CONFIG_PATH.exists():
+        with open(CONFIG_PATH) as f:
+            config.update(json.load(f))
+    return config
+
+
+def save_config(config):
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    # Never persist API keys to disk
+    safe = {k: v for k, v in config.items() if "api_key" not in k}
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(safe, f, indent=2)
+    return CONFIG_PATH

autocommit/explain.py

@@ -0,0 +1,43 @@
+"""Explain the staged diff in plain language.
+
+Needs a real model — there is no offline mode; the heuristic can classify
+a change but cannot explain intent.
+"""
+
+from .llm import LOCAL_PROVIDERS, complete
+
+EXPLAIN_PROMPT = """Explain this staged git diff to a reviewer who hasn't seen the codebase today.
+
+Changed files:
+{files}
+
+Staged diff:
+```
+{diff}
+```
+
+Output exactly these markdown sections:
+
+## What changed
+<2-4 sentences describing the change in plain language>
+
+## Why (inferred)
+<the most likely motivation, inferred from the code — say "unclear" if it is>
+
+## Impact
+<what behavior changes for users or callers>
+
+## Risk
+<Low, Medium, or High — one line explaining the rating; call out missing tests>
+
+Rules:
+- Plain language, no file-by-file narration
+- Be honest about uncertainty; never invent intent the diff doesn't support"""
+
+
+def explain(diff, files, config):
+    """Return a markdown explanation, or None if the provider is offline-only."""
+    if config.get("provider") in LOCAL_PROVIDERS:
+        return None
+    files_str = "\n".join(f"  - {f}" for f in files)
+    return complete(EXPLAIN_PROMPT.format(files=files_str, diff=diff), config, max_tokens=1500)

autocommit/git.py

@@ -0,0 +1,167 @@
+import subprocess
+from pathlib import Path
+
+
+def is_git_repo():
+    result = subprocess.run(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def get_staged_diff():
+    result = subprocess.run(
+        ["git", "diff", "--cached"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None, result.stderr
+    return result.stdout, None
+
+
+def get_staged_files():
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--name-only"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return [], result.stderr
+    files = [f for f in result.stdout.strip().split("\n") if f]
+    return files, None
+
+
+def stage_all():
+    result = subprocess.run(["git", "add", "-A"], capture_output=True, text=True)
+    return result.returncode == 0
+
+
+def make_commit(message):
+    result = subprocess.run(
+        ["git", "commit", "-m", message],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0, result.stdout, result.stderr
+
+
+def get_current_branch():
+    result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def get_default_branch():
+    """Best-effort base branch: origin/HEAD if set, else main/master if they exist."""
+    result = subprocess.run(
+        ["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        return result.stdout.strip().removeprefix("origin/")
+    for name in ("main", "master"):
+        check = subprocess.run(
+            ["git", "rev-parse", "--verify", "--quiet", name],
+            capture_output=True,
+            text=True,
+        )
+        if check.returncode == 0:
+            return name
+    return None
+
+
+def get_branch_commits(base):
+    """Commit subjects on HEAD that are not on base, oldest first."""
+    result = subprocess.run(
+        ["git", "log", "--reverse", "--pretty=%s", f"{base}..HEAD"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return [], result.stderr
+    return [ln for ln in result.stdout.strip().split("\n") if ln], None
+
+
+def get_branch_diff(base):
+    """Diff of HEAD against the merge-base with base (what a PR would show)."""
+    result = subprocess.run(
+        ["git", "diff", f"{base}...HEAD"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None, result.stderr
+    return result.stdout, None
+
+
+def get_recent_commit_subjects(n=20):
+    """Subjects of the last n commits, newest first. Empty list on any failure."""
+    result = subprocess.run(
+        ["git", "log", f"-{n}", "--pretty=%s"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return []
+    return [ln for ln in result.stdout.strip().split("\n") if ln]
+
+
+def get_last_tag():
+    result = subprocess.run(
+        ["git", "describe", "--tags", "--abbrev=0"],
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def get_commit_subjects_since(ref):
+    """Subjects after ref (exclusive) up to HEAD, oldest first. ref=None -> all commits."""
+    rev_range = f"{ref}..HEAD" if ref else "HEAD"
+    result = subprocess.run(
+        ["git", "log", "--reverse", "--pretty=%s", rev_range],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return [], result.stderr
+    return [ln for ln in result.stdout.strip().split("\n") if ln], None
+
+
+def get_unstaged_files():
+    result = subprocess.run(
+        ["git", "diff", "--name-only"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return []
+    return [f for f in result.stdout.strip().split("\n") if f]
+
+
+def unstage_all():
+    result = subprocess.run(["git", "reset", "-q"], capture_output=True, text=True)
+    return result.returncode == 0
+
+
+def stage_files(files):
+    result = subprocess.run(["git", "add", "--", *files], capture_output=True, text=True)
+    return result.returncode == 0
+
+
+def get_repo_name():
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        return Path(result.stdout.strip()).name
+    return None

autocommit/llm.py

@@ -0,0 +1,298 @@
+import os
+from pathlib import PurePosixPath
+
+from . import providers
+
+
+STYLE_INSTRUCTIONS = {
+    "conventional": """\
+Generate a conventional commit message.
+
+Format:  <type>(<scope>): <description>
+
+Types: feat, fix, docs, style, refactor, test, chore, perf, ci, build
+- feat: a new feature
+- fix: a bug fix
+- refactor: code change that neither fixes a bug nor adds a feature
+- chore: tooling, deps, config changes
+- docs: documentation only
+- perf: performance improvement
+- test: adding or fixing tests
+
+Rules:
+- First line must be under 72 characters
+- Description is lowercase, no trailing period
+- Scope is the module or component affected (e.g. auth, orders, cli)""",
+    "angular": """\
+Generate an Angular-style commit message.
+
+Format:  <type>(<scope>): <subject>
+
+Types: feat, fix, docs, style, refactor, test, chore
+Subject is imperative, present tense, lowercase, no trailing period.
+First line under 72 characters.""",
+    "simple": """\
+Generate a short, plain-English commit message.
+No special format. Imperative mood. Under 72 characters.
+Example: "Add user authentication" or "Fix null pointer in order view" """,
+}
+
+
+def _build_prompt(diff, files, config, recent_subjects=None):
+    style = config.get("style", "conventional")
+    include_scope = config.get("include_scope", True)
+    include_body = config.get("include_body", False)
+    emoji = config.get("emoji", False)
+
+    files_str = "\n".join(f"  - {f}" for f in files)
+    style_block = STYLE_INSTRUCTIONS.get(style, STYLE_INSTRUCTIONS["conventional"])
+
+    recent_block = ""
+    if recent_subjects:
+        joined = "\n".join(f"  {s}" for s in recent_subjects[:20])
+        recent_block = (
+            "\nRecent commit messages in this repository — match their tone, "
+            f"scope naming, and conventions:\n{joined}\n"
+        )
+
+    scope_note = "" if include_scope else "Do NOT include a scope."
+    body_note = (
+        "After the first line, add one blank line then a short body explaining WHY (not what) the change was made."
+        if include_body
+        else "Do NOT include a body. First line only."
+    )
+    emoji_note = (
+        "Prepend a single relevant emoji before the type (e.g. ✨ feat, 🐛 fix, ♻️ refactor)."
+        if emoji
+        else ""
+    )
+
+    return f"""You are an expert developer writing a git commit message.
+
+Changed files:
+{files_str}
+
+Staged diff:
+```
+{diff}
+```
+
+{style_block}
+{scope_note}
+{body_note}
+{emoji_note}
+{recent_block}
+
+Additional rules:
+- Be specific, not generic ("fix bug" is bad, "fix null check in order serializer" is good)
+- Output ONLY the commit message — no explanation, no markdown, no backticks
+- Never include Co-Authored-By lines"""
+
+
+LOCAL_PROVIDERS = ("local", "none", "heuristic")
+
+
+def complete(prompt, config, max_tokens=1024):
+    """Send a prompt to the configured AI provider and return the text response.
+
+    Shared by every AI feature (commit messages, review, PR descriptions).
+    Local/heuristic mode has no completion backend — callers handle it themselves.
+    """
+    return providers.get(config.get("provider", "anthropic")).complete(prompt, config, max_tokens)
+
+
+def generate(diff, files, config, recent_subjects=None):
+    provider = config.get("provider", "anthropic")
+    if provider in LOCAL_PROVIDERS:
+        return _heuristic(diff, files, config)
+    return complete(_build_prompt(diff, files, config, recent_subjects), config, max_tokens=300)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Local heuristic generator — no API key, no network, works fully offline
+# ──────────────────────────────────────────────────────────────────────────────
+
+EMOJI = {
+    "feat": "✨",
+    "fix": "🐛",
+    "docs": "📝",
+    "refactor": "♻️",
+    "test": "✅",
+    "chore": "🔧",
+}
+
+GENERIC_DIRS = {"src", "lib", "app", "source", "pkg", "internal", "."}
+
+DOC_STEMS = {"readme", "license", "licence", "changelog", "contributing", "authors", "notice"}
+DOC_EXTS = {".md", ".rst", ".txt", ".adoc"}
+
+CONFIG_EXTS = {".toml", ".yml", ".yaml", ".ini", ".cfg", ".lock", ".json", ".conf"}
+CONFIG_NAMES = {
+    "dockerfile",
+    "makefile",
+    ".gitignore",
+    ".dockerignore",
+    ".editorconfig",
+    "requirements.txt",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "poetry.lock",
+    "cargo.toml",
+    "go.mod",
+    "go.sum",
+}
+
+
+def _is_test(path):
+    p = path.lower()
+    name = PurePosixPath(p).name
+    return (
+        "/test" in p
+        or p.startswith("test")
+        or "/tests/" in p
+        or name.startswith("test_")
+        or name.endswith("_test.py")
+        or ".test." in name
+        or ".spec." in name
+    )
+
+
+def _is_doc(path):
+    p = PurePosixPath(path.lower())
+    return p.stem in DOC_STEMS or p.suffix in DOC_EXTS or "docs/" in path.lower()
+
+
+def _is_config(path):
+    p = PurePosixPath(path.lower())
+    return p.name in CONFIG_NAMES or p.suffix in CONFIG_EXTS
+
+
+def _parse_diff_status(diff):
+    """Map each file path to 'A' (added), 'D' (deleted), or 'M' (modified)."""
+    status = {}
+    current = None
+    for line in diff.split("\n"):
+        if line.startswith("diff --git "):
+            _, _, rest = line.partition(" b/")
+            current = rest or None
+            if current:
+                status[current] = "M"
+        elif current and line.startswith("new file mode"):
+            status[current] = "A"
+        elif current and line.startswith("deleted file mode"):
+            status[current] = "D"
+    return status
+
+
+def _count_lines(diff):
+    adds = sum(1 for ln in diff.split("\n") if ln.startswith("+") and not ln.startswith("+++"))
+    dels = sum(1 for ln in diff.split("\n") if ln.startswith("-") and not ln.startswith("---"))
+    return adds, dels
+
+
+def _infer_type(files, added, deleted, adds, dels):
+    if files and all(_is_test(f) for f in files):
+        return "test"
+    if files and all(_is_doc(f) for f in files):
+        return "docs"
+    if files and all(_is_config(f) for f in files):
+        return "chore"
+    if added and not [f for f in files if f not in added]:
+        return "feat"  # only brand-new files
+    if deleted and len(deleted) == len(files):
+        return "chore"  # pure removals
+    if adds > dels * 3:
+        return "feat"
+    if dels > adds * 3:
+        return "refactor"
+    return "fix"
+
+
+def _deepest_scope(parts):
+    for comp in reversed(list(parts)):
+        c = comp.lower()
+        if c and c not in GENERIC_DIRS and not c.startswith("."):
+            return c
+    return None
+
+
+def _infer_scope(files):
+    if len(files) == 1:
+        return _deepest_scope(PurePosixPath(files[0]).parent.parts)
+    try:
+        common = os.path.commonpath(files)
+    except ValueError:
+        return None
+    return _deepest_scope([p for p in common.split("/") if p])
+
+
+def _display_name(path):
+    p = PurePosixPath(path)
+    return p.stem or p.name
+
+
+def _join(items):
+    if len(items) == 1:
+        return items[0]
+    if len(items) == 2:
+        return f"{items[0]} and {items[1]}"
+    return ", ".join(items[:-1]) + f", and {items[-1]}"
+
+
+def _name_list(files, limit=2):
+    names = list(dict.fromkeys(_display_name(f) for f in files))
+    if len(names) <= limit:
+        return _join(names)
+    return f"{len(files)} files"
+
+
+def _build_subject(ctype, files, added, deleted):
+    if deleted and len(deleted) == len(files):
+        return f"remove {_name_list(deleted)}"
+
+    verb = {
+        "feat": "add",
+        "fix": "fix",
+        "docs": "update",
+        "test": "add",
+        "chore": "update",
+        "refactor": "refactor",
+    }.get(ctype, "update")
+
+    if len(files) == 1:
+        name = _display_name(files[0])
+        if files[0] in added:
+            return f"add {name}"
+        return f"{verb} {name}"
+
+    return f"{verb} {_name_list(files)}"
+
+
+def _format_message(ctype, scope, subject, config):
+    style = config.get("style", "conventional")
+    if style == "simple":
+        msg = subject[:1].upper() + subject[1:]
+    else:
+        head = f"{ctype}({scope})" if scope else ctype
+        prefix = f"{EMOJI[ctype]} " if config.get("emoji") and ctype in EMOJI else ""
+        msg = f"{prefix}{head}: {subject}"
+    return msg[:72]
+
+
+def _heuristic(diff, files, config):
+    status = _parse_diff_status(diff)
+    for f in files:  # binary / untracked files may not appear in the diff body
+        status.setdefault(f, "M")
+
+    added = [f for f in files if status.get(f) == "A"]
+    deleted = [f for f in files if status.get(f) == "D"]
+    adds, dels = _count_lines(diff)
+
+    ctype = _infer_type(files, added, deleted, adds, dels)
+    scope = _infer_scope(files) if config.get("include_scope", True) else None
+    subject = _build_subject(ctype, files, added, deleted)
+    return _format_message(ctype, scope, subject, config)

autocommit/pr.py

@@ -0,0 +1,78 @@
+"""PR description writer.
+
+Builds a title + markdown body from the branch's commits and diff against
+the base branch. AI providers write the prose; local mode assembles a
+serviceable description from the commit subjects alone.
+"""
+
+from .llm import LOCAL_PROVIDERS, complete
+
+PR_PROMPT = """Write a pull request title and description for this branch.
+
+Branch: {branch}  (base: {base})
+
+Commits on this branch, oldest first:
+{commits}
+
+Full diff against the base branch:
+```
+{diff}
+```
+
+Output format — exactly this structure, no other text:
+
+TITLE: <one line, under 72 characters, imperative mood>
+
+## Summary
+<2-4 sentences: what this PR does and why>
+
+## Changes
+<bulleted list of the concrete changes, grouped logically>
+
+## Testing
+<how these changes were or should be verified; write "Not specified" if the diff contains no tests>
+
+Rules:
+- Describe WHAT changed and WHY, not a file-by-file narration
+- No marketing language, no filler
+- Mention breaking changes prominently if any"""
+
+
+def _offline_pr(branch, base, commits):
+    title = commits[-1] if commits else f"Merge {branch} into {base}"
+    if len(title) > 72:
+        title = title[:69] + "..."
+    bullets = "\n".join(f"- {c}" for c in commits) or "- (no commits found)"
+    body = (
+        "## Summary\n"
+        f"Changes from `{branch}` targeting `{base}` "
+        f"({len(commits)} commit{'s' if len(commits) != 1 else ''}).\n\n"
+        "## Changes\n"
+        f"{bullets}\n\n"
+        "## Testing\n"
+        "Not specified.\n"
+    )
+    return title, body
+
+
+def write_pr(branch, base, commits, diff, config):
+    """Return (title, body)."""
+    if config.get("provider") in LOCAL_PROVIDERS:
+        return _offline_pr(branch, base, commits)
+
+    commits_str = "\n".join(f"  - {c}" for c in commits) or "  (none)"
+    raw = complete(
+        PR_PROMPT.format(branch=branch, base=base, commits=commits_str, diff=diff),
+        config,
+        max_tokens=2000,
+    )
+
+    title, body = "", raw
+    for i, line in enumerate(raw.split("\n")):
+        if line.startswith("TITLE:"):
+            title = line.removeprefix("TITLE:").strip()
+            body = "\n".join(raw.split("\n")[i + 1 :]).strip()
+            break
+    if not title:
+        title, _ = _offline_pr(branch, base, commits)
+    return title, body