dug-cli 0.1.0__py3-none-any.whl

dug/hooks.py

@@ -0,0 +1,112 @@
+"""Git hook installer — writes post-commit and post-checkout hooks."""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+
+_RESOLVE_DUG = """\
+# Resolve dug — works whether installed via pipx, brew, uv, or binary
+_dug_cmd() {
+  if command -v dug >/dev/null 2>&1; then
+    dug "$@"
+  elif command -v uvx >/dev/null 2>&1; then
+    uvx dug-cli "$@"
+  elif command -v pipx >/dev/null 2>&1; then
+    pipx run dug-cli "$@"
+  else
+    echo "[dug] dug not found on PATH. Install with: pipx install dug-cli" >&2
+    exit 0   # exit 0 so git commit still succeeds
+  fi
+}
+"""
+
+_POST_COMMIT = """\
+#!/bin/sh
+# dug: reindex files changed in this commit
+""" + _RESOLVE_DUG + """
+_dug_cmd update --changed-only
+"""
+
+_POST_CHECKOUT = """\
+#!/bin/sh
+# dug: reindex files that differ after a branch switch
+""" + _RESOLVE_DUG + """
+PREV_HEAD="$1"
+NEW_HEAD="$2"
+IS_BRANCH="$3"
+if [ "$IS_BRANCH" = "1" ]; then
+  _dug_cmd update --branch-switch --from="$PREV_HEAD" --to="$NEW_HEAD"
+fi
+"""
+
+_DUG_MARKER = "# dug:"
+
+
+def _write_hook(hook_path: Path, content: str) -> str:
+    """Append dug block to an existing hook or create a new one."""
+    if hook_path.exists():
+        existing = hook_path.read_text()
+        if _DUG_MARKER in existing:
+            return "already installed"
+        # Append to existing hook
+        updated = existing.rstrip() + "\n\n" + content
+        hook_path.write_text(updated)
+        return "appended to existing hook"
+    else:
+        hook_path.write_text(content)
+        # Make executable
+        hook_path.chmod(hook_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        return "created"
+
+
+def install_git_hooks(root: Path) -> dict[str, str]:
+    """Install post-commit and post-checkout hooks. Returns status per hook."""
+    hooks_dir = root / ".git" / "hooks"
+    if not hooks_dir.exists():
+        return {"error": "not a git repo or .git/hooks missing"}
+
+    results = {}
+    results["post-commit"] = _write_hook(hooks_dir / "post-commit", _POST_COMMIT)
+    results["post-checkout"] = _write_hook(hooks_dir / "post-checkout", _POST_CHECKOUT)
+    return results
+
+
+def ensure_gitignore(root: Path) -> str:
+    """Add .dug/ to .gitignore if not already present. Returns status string."""
+    gitignore = root / ".gitignore"
+    entry = ".dug/"
+
+    if gitignore.exists():
+        lines = gitignore.read_text().splitlines()
+        # Check for exact match or glob that already covers it
+        if any(line.strip() in (entry, ".dug", "**/.dug/", "**/.dug") for line in lines):
+            return "already in .gitignore"
+        # Append with a section comment
+        with open(gitignore, "a") as f:
+            f.write(f"\n# dug local index — machine-specific, never commit\n{entry}\n")
+        return "added to existing .gitignore"
+    else:
+        gitignore.write_text(f"# dug local index — machine-specific, never commit\n{entry}\n")
+        return "created .gitignore"
+
+
+def uninstall_git_hooks(root: Path) -> dict[str, str]:
+    """Remove the dug block from hooks (leaves other hook content intact)."""
+    hooks_dir = root / ".git" / "hooks"
+    results = {}
+    for name, content in [("post-commit", _POST_COMMIT), ("post-checkout", _POST_CHECKOUT)]:
+        hook_path = hooks_dir / name
+        if not hook_path.exists():
+            results[name] = "not found"
+            continue
+        existing = hook_path.read_text()
+        if _DUG_MARKER not in existing:
+            results[name] = "not installed"
+            continue
+        # Remove the dug block
+        cleaned = existing.replace("\n\n" + content, "").replace(content, "")
+        hook_path.write_text(cleaned)
+        results[name] = "removed"
+    return results

dug/indexer.py

@@ -0,0 +1,294 @@
+"""Indexer — full init and incremental per-file updates."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+from pathlib import Path
+
+from .config import get_dug_dir, load_config
+from .graph import (CodeGraph, build_graph, walk_repo, _ext_to_lang,
+                    extract_symbols_ripgrep, extract_imports,
+                    _resolve_import_to_file)
+from .chunker import extract_chunks, Chunk
+from .vector_store import get_or_create_table, upsert_chunks, delete_file_chunks
+
+
+# ---------------------------------------------------------------------------
+# Persistence helpers
+# ---------------------------------------------------------------------------
+
+def get_hashes_path() -> Path:
+    return get_dug_dir() / "hashes.json"
+
+
+def get_chunk_cache_path() -> Path:
+    return get_dug_dir() / "chunk_cache.json"
+
+
+def load_hashes() -> dict[str, str]:
+    p = get_hashes_path()
+    if not p.exists():
+        return {}
+    with open(p) as f:
+        return json.load(f)
+
+
+def save_hashes(hashes: dict[str, str]) -> None:
+    p = get_hashes_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    with open(p, "w") as f:
+        json.dump(hashes, f, indent=2)
+
+
+def load_chunk_cache() -> dict[str, list[float]]:
+    p = get_chunk_cache_path()
+    if not p.exists():
+        return {}
+    with open(p) as f:
+        return json.load(f)
+
+
+def save_chunk_cache(cache: dict[str, list[float]]) -> None:
+    p = get_chunk_cache_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    with open(p, "w") as f:
+        json.dump(cache, f)
+
+
+def file_hash(path: Path) -> str:
+    return hashlib.md5(path.read_bytes()).hexdigest()
+
+
+def needs_reindex(path: Path, hashes: dict[str, str]) -> bool:
+    return file_hash(path) != hashes.get(str(path))
+
+
+# ---------------------------------------------------------------------------
+# Embedding helper
+# ---------------------------------------------------------------------------
+
+def _embed_chunks(chunks: list[Chunk], embedder, cache: dict) -> list[dict]:
+    rows = []
+    for chunk in chunks:
+        code_hash = hashlib.md5(chunk.code.encode()).hexdigest()
+        if code_hash in cache:
+            vector = cache[code_hash]
+        else:
+            vector = embedder.embed(chunk.code)
+            cache[code_hash] = vector
+        rows.append({
+            "chunk_id":      chunk.chunk_id,
+            "file_path":     chunk.file_path,
+            "function_name": chunk.function_name,
+            "start_line":    chunk.start_line,
+            "end_line":      chunk.end_line,
+            "language":      chunk.language,
+            "vector":        vector,
+        })
+    return rows
+
+
+# ---------------------------------------------------------------------------
+# Full init (rebuilds everything)
+# ---------------------------------------------------------------------------
+
+def run_init(root: Path | None = None, embedder=None, progress: bool = True) -> dict:
+    from .config import find_repo_root
+    root = root or find_repo_root()
+    config = load_config()
+
+    # Phase 1: structural graph
+    graph = build_graph(root, config)
+    graph_path = get_dug_dir() / "graph.json"
+    graph.save(graph_path)
+
+    # Phase 2: semantic index
+    if embedder is None:
+        from .embeddings import get_embedder
+        embedder = get_embedder(config)
+
+    cache = load_chunk_cache()
+    db_path = get_dug_dir() / "embeddings"
+    table = get_or_create_table(db_path, config.get("embedding_mode", "local"))
+
+    files = walk_repo(root, config.get("ignore_paths", []), config.get("languages", []))
+    all_chunks: list[Chunk] = []
+    for f in files:
+        all_chunks.extend(extract_chunks(f, root))
+
+    rows = []
+    cache_hits = 0
+    for i, chunk in enumerate(all_chunks):
+        if progress:
+            print(f"\r  Embedding functions... {i + 1}/{len(all_chunks)}", end="", flush=True)
+        code_hash = hashlib.md5(chunk.code.encode()).hexdigest()
+        if code_hash in cache:
+            vector = cache[code_hash]
+            cache_hits += 1
+        else:
+            vector = embedder.embed(chunk.code)
+            cache[code_hash] = vector
+        rows.append({
+            "chunk_id":      chunk.chunk_id,
+            "file_path":     chunk.file_path,
+            "function_name": chunk.function_name,
+            "start_line":    chunk.start_line,
+            "end_line":      chunk.end_line,
+            "language":      chunk.language,
+            "vector":        vector,
+        })
+
+    if progress and all_chunks:
+        print()
+
+    # Full rebuild: wipe existing chunks and reinsert
+    for f in files:
+        delete_file_chunks(table, str(f.relative_to(root)))
+    upsert_chunks(table, rows)
+    save_chunk_cache(cache)
+
+    # Save file hashes for incremental guard
+    hashes = {str(f): file_hash(f) for f in files}
+    save_hashes(hashes)
+
+    return {
+        **graph.stats(),
+        "chunks": len(all_chunks),
+        "cache_hits": cache_hits,
+        "embedded": len(all_chunks) - cache_hits,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Single-file incremental update
+# ---------------------------------------------------------------------------
+
+def update_file(file_path: Path, root: Path, embedder=None) -> dict:
+    """Reindex one file — cleanup stale data, re-extract, re-embed."""
+    config = load_config()
+    rel_path = str(file_path.relative_to(root))
+
+    # Guard 1: skip if content unchanged
+    hashes = load_hashes()
+    if file_path.exists() and not needs_reindex(file_path, hashes):
+        return {"skipped": True, "path": rel_path}
+
+    # Load graph
+    graph = CodeGraph()
+    graph.load(get_dug_dir() / "graph.json")
+
+    # Get current file set for import resolution
+    all_file_rels: set[str] = {
+        d["path"]
+        for _, d in graph.g.nodes(data=True)
+        if d.get("kind") == "FILE"
+    }
+    all_file_rels.add(rel_path)
+
+    # Stale cleanup + re-add to graph
+    graph.update_file_data(file_path, root, all_file_rels)
+    graph.save(get_dug_dir() / "graph.json")
+
+    # LanceDB: delete old chunks for this file, insert new ones
+    db_path = get_dug_dir() / "embeddings"
+    table = get_or_create_table(db_path, config.get("embedding_mode", "local"))
+    delete_file_chunks(table, rel_path)
+
+    chunk_count = 0
+    if file_path.exists():
+        if embedder is None:
+            from .embeddings import get_embedder
+            embedder = get_embedder(config)
+
+        cache = load_chunk_cache()
+        chunks = extract_chunks(file_path, root)
+        rows = _embed_chunks(chunks, embedder, cache)
+        if rows:
+            upsert_chunks(table, rows)
+        save_chunk_cache(cache)
+
+        # Update hash
+        hashes[str(file_path)] = file_hash(file_path)
+        save_hashes(hashes)
+        chunk_count = len(chunks)
+
+    return {"updated": rel_path, "chunks": chunk_count}
+
+
+# ---------------------------------------------------------------------------
+# Git-driven multi-file update
+# ---------------------------------------------------------------------------
+
+def _git_changed_files(root: Path, base: str = "HEAD~1", head: str = "HEAD") -> list[Path]:
+    """Return absolute paths of files changed between two git refs."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", base, head],
+            capture_output=True, text=True, cwd=root,
+        )
+    except FileNotFoundError:
+        return []
+    if result.returncode != 0:
+        return []
+
+    config = load_config()
+    valid_exts: set[str] = set()
+    from .graph import LANG_EXTENSIONS
+    for lang in config.get("languages", []):
+        valid_exts.update(LANG_EXTENSIONS.get(lang, []))
+
+    paths = []
+    for line in result.stdout.splitlines():
+        p = root / line.strip()
+        if p.suffix in valid_exts:
+            paths.append(p)
+    return paths
+
+
+def update_changed_files(
+    root: Path,
+    embedder=None,
+    from_ref: str = "HEAD~1",
+    to_ref: str = "HEAD",
+    progress: bool = True,
+) -> dict:
+    """Reindex only files that changed between two git refs + prune deleted."""
+    graph = CodeGraph()
+    graph.load(get_dug_dir() / "graph.json")
+
+    # Prune deleted files first
+    config = load_config()
+    db_path = get_dug_dir() / "embeddings"
+    table = get_or_create_table(db_path, config.get("embedding_mode", "local"))
+
+    stale = graph.prune_stale_nodes(root)
+    for rel in stale:
+        delete_file_chunks(table, rel)
+    if stale:
+        graph.save(get_dug_dir() / "graph.json")
+
+    # Reindex changed files
+    changed = _git_changed_files(root, from_ref, to_ref)
+    if not changed:
+        return {"pruned": stale, "updated": [], "skipped": []}
+
+    if embedder is None:
+        from .embeddings import get_embedder
+        embedder = get_embedder(config)
+
+    updated, skipped = [], []
+    for i, f in enumerate(changed):
+        if progress:
+            print(f"\r  Updating {i + 1}/{len(changed)}: {f.name}   ", end="", flush=True)
+        result = update_file(f, root, embedder)
+        if result.get("skipped"):
+            skipped.append(str(f.relative_to(root)))
+        else:
+            updated.append(result["updated"])
+
+    if progress and changed:
+        print()
+
+    return {"pruned": stale, "updated": updated, "skipped": skipped}

dug/prompt_builder.py

@@ -0,0 +1,106 @@
+"""Prompt builder — assembles the Claude Code prompt. Pure Python, zero LLM."""
+
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+
+from .retriever import RankedFile
+from .git_context import Commit
+
+
+def _ago(ts: float) -> str:
+    if not ts:
+        return "unknown"
+    dt = datetime.datetime.fromtimestamp(ts)
+    delta = datetime.datetime.now() - dt
+    if delta.days == 0:
+        hours = delta.seconds // 3600
+        return f"{hours}h ago" if hours > 0 else "just now"
+    if delta.days == 1:
+        return "1 day ago"
+    return f"{delta.days} days ago"
+
+
+def _commit_ago(commit: Commit) -> str:
+    return f"{commit.days_ago}d ago"
+
+
+def build_prompt(
+    bug_input: str,
+    ranked_files: list[RankedFile],
+    git_commits: list[Commit],
+    signals: dict,
+) -> str:
+    # --- Files section ---
+    files_lines = []
+    for f in ranked_files:
+        reason_str = ", ".join(f.reasons) if f.reasons else "semantic match"
+        modified_str = _ago(f.last_modified)
+        files_lines.append(f"  - {f.path}  ({reason_str}, modified {modified_str})")
+    files_section = "\n".join(files_lines) if files_lines else "  (none found)"
+
+    # --- Import chain ---
+    chain = ranked_files[0].import_chain if ranked_files else []
+    chain_section = " → ".join(chain) if len(chain) > 1 else (chain[0] if chain else "n/a")
+
+    # --- Commits touching ranked files ---
+    ranked_paths = {f.path for f in ranked_files}
+    relevant_commits = [
+        c for c in git_commits
+        if any(fp in ranked_paths for fp in c.files_touched)
+    ][:3]
+
+    if relevant_commits:
+        commits_lines = [
+            f"  {c.hash[:7]}: \"{c.message}\"  ({_commit_ago(c)})"
+            for c in relevant_commits
+        ]
+    elif git_commits:
+        commits_lines = [
+            f"  {c.hash[:7]}: \"{c.message}\"  ({_commit_ago(c)})"
+            for c in git_commits[:3]
+        ]
+    else:
+        commits_lines = ["  (no git history found)"]
+    commits_section = "\n".join(commits_lines)
+
+    # --- Starting point ---
+    if ranked_files:
+        start = ranked_files[0]
+        imports_str = (
+            ", ".join(start.imports[:3]) if start.imports
+            else "no tracked imports"
+        )
+        line_hint = ""
+        if signals.get("line_numbers"):
+            line_hint = f" (line {signals['line_numbers'][0]} mentioned in input)"
+        start_section = (
+            f"Begin at {start.path}{line_hint}.\n"
+            f"  Modified {_ago(start.last_modified)}. "
+            f"Imports: {imports_str}."
+        )
+    else:
+        start_section = "No clear starting point found."
+
+    # --- Error type hint ---
+    error_hint = ""
+    if signals.get("error_type"):
+        error_hint = f"\n**Error type:** `{signals['error_type']}`\n"
+
+    return f"""## Bug Report
+
+**Error:** {bug_input}
+{error_hint}
+**Files to investigate (ranked by relevance):**
+{files_section}
+
+**Import chain:**
+  {chain_section}
+
+**Recent commits touching these files:**
+{commits_section}
+
+**Suggested starting point:**
+  {start_section}
+"""