llm-commit-helper 0.1.0__py3-none-any.whl

llm_commit_helper/formatters/verilog_fmt.py

@@ -0,0 +1,116 @@
+"""Verilog formatter: delete AUTO-generated sections before diffing."""
+
+import re
+import sys
+from typing import Optional
+
+from llm_commit_helper.utils import make_temp_file, run_command
+from llm_commit_helper.diff_engine import annotate_formatting_hunks
+from llm_commit_helper.formatters.generic_fmt import _hunk_is_formatting_only
+
+
+# Regex for AUTO* macro keywords
+AUTO_PATTERN = re.compile(
+    r"\b(AUTOARG|AUTOINPUT|AUTOOUTPUT|AUTOINOUT|AUTOINSTPARAM|AUTOINST"
+    r"|AUTOWIRE|AUTOREG|AUTOREGINPUT|AUTOLOGIC|AUTOASCIIENUM|AUTOSENSE"
+    r"|AUTOUNUSED|AUTOTEMPLATE|AUTO_LISP)\b"
+)
+
+
+def _has_auto_macros(content: str) -> bool:
+    """Return True if content uses any AUTO* Verilog macros."""
+    return bool(AUTO_PATTERN.search(content))
+
+
+def _run_emacs_delete_auto(file_path: str) -> bool:
+    """Delete all AUTO-generated sections from file using emacs verilog-batch-delete-auto.
+
+    This strips the expanded output (AUTOWIRE, AUTOINST, etc.) so that only
+    the hand-written source remains, making diffs independent of AUTO ordering.
+    Returns True on success.
+    """
+    rc, _, err = run_command(
+        [
+            "emacs",
+            "--batch",
+            file_path,
+            "-f",
+            "verilog-batch-delete-auto",
+            "-f",
+            "save-buffer",
+        ]
+    )
+    return rc == 0
+
+
+def format_verilog_diff(
+    path: str,
+    old_content: Optional[str],
+    new_content: Optional[str],
+) -> tuple[str, bool]:
+    """Format Verilog diff by deleting AUTO-generated sections before comparing.
+
+    verilog-batch-delete-auto removes all AUTO-expanded blocks (AUTOWIRE,
+    AUTOINST, etc.), leaving only hand-written source. Diffing the stripped
+    versions avoids spurious ordering differences in generated code.
+
+    Returns (diff_text, is_formatting_only).
+    Falls back to generic if emacs is not available or no AUTO* macros found.
+    """
+    combined = (old_content or "") + (new_content or "")
+    has_auto = _has_auto_macros(combined)
+
+    old_tmp = None
+    new_tmp = None
+    try:
+        ext = ".sv" if path.endswith(".sv") else ".v"
+        old_tmp = make_temp_file(suffix=ext, content=old_content or "")
+        new_tmp = make_temp_file(suffix=ext, content=new_content or "")
+
+        if has_auto:
+            old_ok = _run_emacs_delete_auto(str(old_tmp))
+            new_ok = _run_emacs_delete_auto(str(new_tmp))
+
+            if not old_ok or not new_ok:
+                print(
+                    f"[llm-commit-helper] emacs not available or failed for {path}, falling back to generic",
+                    file=sys.stderr,
+                )
+                from llm_commit_helper.formatters.generic_fmt import format_generic_diff
+
+                return format_generic_diff(path, old_content, new_content)
+
+            old_processed = old_tmp.read_text(encoding="utf-8")
+            new_processed = new_tmp.read_text(encoding="utf-8")
+        else:
+            old_processed = old_content or ""
+            new_processed = new_content or ""
+
+        old_lines = old_processed.splitlines(keepends=True)
+        new_lines = new_processed.splitlines(keepends=True)
+
+        diff_lines, all_formatting = annotate_formatting_hunks(
+            old_lines, new_lines, _hunk_is_formatting_only
+        )
+
+        if not diff_lines:
+            if has_auto:
+                return "[all changes are AUTO-generated - no user code changes]", True
+            return "", True
+
+        diff_text = "".join(diff_lines)
+        if has_auto and all_formatting:
+            diff_text = f"[formatting-only after AUTO deletion]\n{diff_text}"
+
+        return diff_text, all_formatting
+
+    finally:
+        if old_tmp and old_tmp.exists():
+            old_tmp.unlink()
+        if new_tmp and new_tmp.exists():
+            new_tmp.unlink()
+
+
+# Local Variables:
+# eval: (blacken-mode)
+# End:

llm_commit_helper/git_staged.py

@@ -0,0 +1,244 @@
+"""Git interaction: staged file listing, classification, content retrieval."""
+
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from llm_commit_helper.config import Config
+from llm_commit_helper.utils import find_git_root, glob_match, run_command
+
+
+class FileStatus(Enum):
+    ADDED = "added"
+    MODIFIED = "modified"
+    DELETED = "deleted"
+    RENAMED = "renamed"
+
+
+class FileKind(Enum):
+    EXCLUDED = "excluded"        # matched exclude rule or too large
+    TOO_LARGE = "too_large"      # file size exceeds max_file_size
+    ADDED = "added"              # new file - don't show content
+    DELETED = "deleted"          # deleted file
+    SUBMODULE = "submodule"      # gitlink / submodule
+    MODIFIED = "modified"        # regular diff
+    BINARY = "binary"            # binary file
+
+
+@dataclass
+class StagedFile:
+    path: str                        # relative to git root
+    status: FileStatus
+    is_submodule: bool = False
+    old_hash: Optional[str] = None   # for submodules: previous commit
+    new_hash: Optional[str] = None   # for submodules: new commit
+    kind: Optional[FileKind] = None  # set by classify_file()
+    old_content: Optional[str] = None
+    new_content: Optional[str] = None
+
+
+def _parse_name_status(output: str) -> list[tuple[str, str, Optional[str]]]:
+    """Parse git diff --name-status output into (status_char, path, old_path) tuples."""
+    results = []
+    for line in output.splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        status_char = parts[0][0]  # A, M, D, R, C, etc.
+        if status_char in ("R", "C") and len(parts) >= 3:
+            # Renamed: R100\told_path\tnew_path
+            results.append((status_char, parts[2], parts[1]))
+        elif len(parts) >= 2:
+            results.append((status_char, parts[1], None))
+    return results
+
+
+def _get_submodule_hashes(git_root: Path) -> dict[str, tuple[str, str]]:
+    """Return {path: (old_hash, new_hash)} for staged submodule changes."""
+    rc, out, err = run_command(
+        ["git", "diff", "--staged", "--raw"],
+        cwd=git_root,
+    )
+    hashes: dict[str, tuple[str, str]] = {}
+    if rc != 0:
+        return hashes
+
+    for line in out.splitlines():
+        # Format: :old_mode new_mode old_hash new_hash status\tpath
+        if not line.startswith(":"):
+            continue
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        meta = parts[0].split()
+        if len(meta) < 5:
+            continue
+        old_mode, new_mode, old_hash, new_hash, status = meta[0], meta[1], meta[2], meta[3], meta[4]
+        path = parts[1]
+        # Submodule mode is 160000
+        if old_mode == ":160000" or new_mode == "160000" or old_mode == "160000":
+            hashes[path] = (old_hash, new_hash)
+        # Also check via the leading : format
+        old_mode_clean = old_mode.lstrip(":")
+        if old_mode_clean == "160000" or new_mode == "160000":
+            hashes[path] = (old_hash, new_hash)
+
+    return hashes
+
+
+def _get_submodule_set(git_root: Path) -> set[str]:
+    """Return the set of all submodule paths registered in .gitmodules."""
+    rc, out, _ = run_command(
+        ["git", "config", "--file", ".gitmodules", "--get-regexp", "path"],
+        cwd=git_root,
+    )
+    paths = set()
+    if rc != 0:
+        return paths
+    for line in out.splitlines():
+        parts = line.split()
+        if len(parts) >= 2:
+            paths.add(parts[1])
+    return paths
+
+
+def get_staged_files(git_root: Optional[Path] = None) -> list[StagedFile]:
+    """Return StagedFile list for all currently staged changes."""
+    if git_root is None:
+        git_root = find_git_root()
+    if git_root is None:
+        print("[llm-commit-helper] Error: not inside a git repository", file=sys.stderr)
+        return []
+
+    rc, out, err = run_command(
+        ["git", "diff", "--staged", "--name-status"],
+        cwd=git_root,
+    )
+    if rc != 0:
+        print(f"[llm-commit-helper] git diff failed: {err}", file=sys.stderr)
+        return []
+
+    parsed = _parse_name_status(out)
+    submodule_paths = _get_submodule_set(git_root)
+    submodule_hashes = _get_submodule_hashes(git_root)
+
+    status_map = {
+        "A": FileStatus.ADDED,
+        "M": FileStatus.MODIFIED,
+        "D": FileStatus.DELETED,
+        "R": FileStatus.RENAMED,
+        "C": FileStatus.MODIFIED,
+    }
+
+    files = []
+    for status_char, path, old_path in parsed:
+        status = status_map.get(status_char, FileStatus.MODIFIED)
+        is_sub = path in submodule_paths
+        old_h, new_h = submodule_hashes.get(path, (None, None))
+        files.append(
+            StagedFile(
+                path=path,
+                status=status,
+                is_submodule=is_sub,
+                old_hash=old_h,
+                new_hash=new_h,
+            )
+        )
+
+    return files
+
+
+def _file_size_in_index(path: str, git_root: Path) -> int:
+    """Return the size (bytes) of the staged version of a file, or 0 on error."""
+    rc, out, _ = run_command(
+        ["git", "cat-file", "-s", f":0:{path}"],
+        cwd=git_root,
+    )
+    if rc != 0:
+        return 0
+    try:
+        return int(out.strip())
+    except ValueError:
+        return 0
+
+
+def _is_binary(path: str, git_root: Path) -> bool:
+    """Heuristic: check if the staged file is binary."""
+    rc, out, _ = run_command(
+        ["git", "diff", "--staged", "--numstat", "--", path],
+        cwd=git_root,
+    )
+    if rc == 0 and out.startswith("-\t-"):
+        return True
+    return False
+
+
+def classify_file(f: StagedFile, config: Config, git_root: Path) -> FileKind:
+    """Assign a FileKind to a StagedFile based on config rules."""
+    # Submodule takes priority
+    if f.is_submodule:
+        return FileKind.SUBMODULE
+
+    # Exclude patterns
+    for pattern in config.exclude_patterns:
+        if glob_match(pattern, f.path):
+            return FileKind.EXCLUDED
+
+    # Added files — no content shown
+    if f.status == FileStatus.ADDED:
+        return FileKind.ADDED
+
+    # Deleted files
+    if f.status == FileStatus.DELETED:
+        return FileKind.DELETED
+
+    # Size check (staged version)
+    size = _file_size_in_index(f.path, git_root)
+    if size > config.max_file_size:
+        return FileKind.TOO_LARGE
+
+    # Binary check
+    if _is_binary(f.path, git_root):
+        return FileKind.BINARY
+
+    return FileKind.MODIFIED
+
+
+def get_file_content(path: str, git_root: Path, staged: bool = True) -> Optional[str]:
+    """Retrieve file content from git: staged (index) or committed (HEAD)."""
+    if staged:
+        ref = f":0:{path}"
+    else:
+        ref = f"HEAD:{path}"
+
+    rc, out, err = run_command(["git", "show", ref], cwd=git_root)
+    if rc != 0:
+        return None
+    return out
+
+
+def load_file_contents(f: StagedFile, git_root: Path) -> StagedFile:
+    """Load old and new content into StagedFile for MODIFIED/DELETED files."""
+    if f.kind not in (FileKind.MODIFIED, FileKind.DELETED):
+        return f
+
+    old = get_file_content(f.path, git_root, staged=False)
+    new = get_file_content(f.path, git_root, staged=True) if f.kind == FileKind.MODIFIED else None
+
+    return StagedFile(
+        path=f.path,
+        status=f.status,
+        is_submodule=f.is_submodule,
+        old_hash=f.old_hash,
+        new_hash=f.new_hash,
+        kind=f.kind,
+        old_content=old,
+        new_content=new,
+    )
+
+
+# Local Variables:
+# eval: (blacken-mode)
+# End:

llm_commit_helper/output.py

@@ -0,0 +1,83 @@
+"""Output assembly: size-budgeted output builder."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class FileSummary:
+    path: str
+    label: str          # e.g. "modified", "added", "excluded", ...
+    content: str        # the body text for this file section
+    truncated: bool = False
+
+
+class OutputBuilder:
+    """Assembles output sections while respecting max_total_size budget."""
+
+    def __init__(self, max_total_size: int) -> None:
+        self._max = max_total_size
+        self._sections: list[str] = []
+        self._current_size: int = 0
+        self._truncated: bool = False
+        self._truncated_files: list[str] = []
+
+    def _remaining(self) -> int:
+        return self._max - self._current_size
+
+    def add_section(self, text: str, file_path: Optional[str] = None) -> bool:
+        """Add a text section. Returns True if added in full, False if budget exceeded."""
+        if self._truncated:
+            if file_path:
+                self._truncated_files.append(file_path)
+            return False
+
+        size = len(text)
+        if self._current_size + size > self._max:
+            self._truncated = True
+            if file_path:
+                self._truncated_files.append(file_path)
+            return False
+
+        self._sections.append(text)
+        self._current_size += size
+        return True
+
+    def build(self, header: str, footer_template: str) -> str:
+        """Build the final output string."""
+        parts = [header]
+        parts.extend(self._sections)
+
+        if self._truncated:
+            parts.append("\n[OUTPUT TRUNCATED - budget exceeded]\n")
+            if self._truncated_files:
+                parts.append("Remaining files (not shown):\n")
+                for p in self._truncated_files:
+                    parts.append(f"  {p}\n")
+
+        total_chars = sum(len(p) for p in parts)
+        footer = footer_template.format(total_chars=total_chars)
+        parts.append(footer)
+        return "".join(parts)
+
+    @property
+    def is_truncated(self) -> bool:
+        return self._truncated
+
+    @property
+    def current_size(self) -> int:
+        return self._current_size
+
+
+def format_file_header(path: str, label: str, extra: str = "") -> str:
+    """Format a file section header line."""
+    parts = [f"--- File: {path} [{label}]"]
+    if extra:
+        parts.append(f" [{extra}]")
+    parts.append(" ---\n")
+    return "".join(parts)
+
+
+# Local Variables:
+# eval: (blacken-mode)
+# End:

llm_commit_helper/submodule.py

@@ -0,0 +1,96 @@
+"""Submodule log: fetch commit log between old and new hashes."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from llm_commit_helper.utils import run_command
+
+
+_NULL_HASH = set(["0" * 7, "0" * 8, "0" * 40])
+
+
+def _is_null_hash(h: str) -> bool:
+    """Return True if hash is the all-zeros null hash (new submodule addition)."""
+    return not h.strip("0")
+
+
+def get_submodule_log(
+    submodule_path: str,
+    old_hash: Optional[str],
+    new_hash: Optional[str],
+    git_root: Path,
+) -> list[str]:
+    """Return one-line log entries for a submodule update.
+
+    For a newly added submodule (old hash is null), returns the last few
+    commits of new_hash instead of an old..new range.
+    Returns an empty list if the submodule is uninitialized or hashes are missing.
+    """
+    if not old_hash or not new_hash:
+        return []
+
+    abs_path = git_root / submodule_path
+    if not abs_path.is_dir():
+        print(
+            f"[llm-commit-helper] Submodule not initialized: {submodule_path}",
+            file=sys.stderr,
+        )
+        return []
+
+    if _is_null_hash(old_hash):
+        # Newly added submodule — show the tip commit only
+        rc, out, err = run_command(
+            ["git", "log", "--oneline", "-5", new_hash],
+            cwd=abs_path,
+        )
+    else:
+        rc, out, err = run_command(
+            ["git", "log", "--oneline", f"{old_hash}..{new_hash}"],
+            cwd=abs_path,
+        )
+
+    if rc != 0:
+        print(
+            f"[llm-commit-helper] Could not get submodule log for {submodule_path}: {err.strip()}",
+            file=sys.stderr,
+        )
+        return []
+
+    lines = [line for line in out.splitlines() if line.strip()]
+    return lines
+
+
+def format_submodule_section(
+    submodule_path: str,
+    old_hash: Optional[str],
+    new_hash: Optional[str],
+    log_lines: list[str],
+) -> str:
+    """Format the submodule section for output."""
+    new_short = (new_hash or "?")[:8]
+    is_new = not old_hash or _is_null_hash(old_hash)
+
+    if is_new:
+        lines = [
+            f"--- Submodule: {submodule_path} ---",
+            f"Added at: {new_short}",
+        ]
+    else:
+        old_short = (old_hash or "?")[:8]
+        lines = [
+            f"--- Submodule: {submodule_path} ---",
+            f"Updated: {old_short} -> {new_short}",
+        ]
+
+    if log_lines:
+        for entry in log_lines:
+            lines.append(f"  {entry}")
+    else:
+        lines.append("  [no log available]")
+    return "\n".join(lines)
+
+
+# Local Variables:
+# eval: (blacken-mode)
+# End:

llm_commit_helper/utils.py

@@ -0,0 +1,124 @@
+"""Utility functions: subprocess, size parsing, glob matching, git root."""
+
+import fnmatch
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+
+COMMAND_TIMEOUT = 30  # seconds
+
+
+def run_command(
+    args: list[str],
+    cwd: Optional[Path] = None,
+    check: bool = False,
+) -> tuple[int, str, str]:
+    """Run a subprocess command and return (returncode, stdout, stderr).
+
+    Never raises on non-zero exit unless check=True.
+    Always enforces a 30-second timeout.
+    """
+    try:
+        result = subprocess.run(
+            args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=COMMAND_TIMEOUT,
+            check=check,
+        )
+        return result.returncode, result.stdout, result.stderr
+    except subprocess.TimeoutExpired:
+        print(f"[llm-commit-helper] Timeout running: {' '.join(args)}", file=sys.stderr)
+        return 1, "", "timeout"
+    except FileNotFoundError:
+        return 1, "", f"command not found: {args[0]}"
+
+
+def parse_size(value: str | int | float) -> int:
+    """Parse a human-readable size string into bytes.
+
+    Accepts: 200MB, 20KB, 4096, 1.5GB, etc.
+    Returns the size in bytes as an integer.
+    """
+    if isinstance(value, (int, float)):
+        return int(value)
+
+    s = str(value).strip().upper()
+    suffixes = {
+        "GB": 1024**3,
+        "MB": 1024**2,
+        "KB": 1024,
+        "B": 1,
+    }
+    for suffix, multiplier in suffixes.items():
+        if s.endswith(suffix):
+            number = s[: -len(suffix)].strip()
+            return int(float(number) * multiplier)
+    return int(float(s))
+
+
+def glob_match(pattern: str, path: str) -> bool:
+    """Return True if path matches a glob pattern.
+
+    Supports ** for directory wildcards via fnmatch with path normalization.
+    """
+    # Normalize separators
+    path = path.replace("\\", "/")
+    pattern = pattern.replace("\\", "/")
+
+    # Try direct match
+    if fnmatch.fnmatch(path, pattern):
+        return True
+
+    # Try matching just the filename against the pattern
+    filename = Path(path).name
+    if fnmatch.fnmatch(filename, pattern):
+        return True
+
+    # For ** patterns, check each path segment
+    if "**" in pattern:
+        parts = pattern.split("**")
+        if len(parts) == 2:
+            prefix, suffix = parts
+            prefix = prefix.rstrip("/")
+            suffix = suffix.lstrip("/")
+            if prefix and not path.startswith(prefix):
+                return False
+            if suffix and not fnmatch.fnmatch(path, f"*{suffix}"):
+                return False
+            if prefix or suffix:
+                return True
+
+    return False
+
+
+def find_git_root(start: Optional[Path] = None) -> Optional[Path]:
+    """Walk up from start (or cwd) to find the git repository root."""
+    current = (start or Path.cwd()).resolve()
+    for parent in [current, *current.parents]:
+        if (parent / ".git").exists():
+            return parent
+    return None
+
+
+def make_temp_file(suffix: str = "", content: str = "") -> Path:
+    """Create a named temp file with the given content, return its Path."""
+    fd, path = tempfile.mkstemp(suffix=suffix)
+    try:
+        with open(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+    except Exception:
+        import os
+
+        os.close(fd)
+        raise
+    return Path(path)
+
+
+# Local Variables:
+# eval: (blacken-mode)
+# End: