dug-cli 0.1.0__py3-none-any.whl

dug/__main__.py

@@ -0,0 +1,297 @@
+import sys
+from pathlib import Path
+
+import click
+
+from .config import load_config, save_config, set_config_value, get_dug_dir, DEFAULTS, find_repo_root
+
+
+class DefaultToQueryGroup(click.Group):
+    """Routes `dug "some error"` to the query command when first arg isn't a subcommand."""
+
+    def parse_args(self, ctx, args):
+        if args and not args[0].startswith("-") and args[0] not in self.commands:
+            args = ["query"] + args
+        return super().parse_args(ctx, args)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+LANG_EXTENSIONS = {
+    "python": [".py"],
+    "java": [".java"],
+    "typescript": [".ts", ".tsx"],
+    "javascript": [".js", ".jsx"],
+}
+
+
+def _detect_languages(root: Path) -> list[str]:
+    detected = []
+    for lang, exts in LANG_EXTENSIONS.items():
+        for ext in exts:
+            if any(root.rglob(f"*{ext}")):
+                detected.append(lang)
+                break
+    return detected or ["python"]
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+@click.group(cls=DefaultToQueryGroup, invoke_without_command=True)
+@click.pass_context
+def cli(ctx):
+    """dug — dig into any bug with full codebase context."""
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@cli.command()
+def init():
+    """First-time setup — wizard + full index build."""
+    click.echo("\nWelcome to dug.\n")
+
+    # Embedding mode
+    click.echo("Embedding mode:")
+    click.echo("  1. Local  — no API key, runs on CPU  (recommended)")
+    click.echo("  2. OpenAI — needs API key, faster")
+    choice = click.prompt("\n>", default="1").strip()
+
+    cfg = load_config()
+
+    if choice == "2":
+        api_key = click.prompt("OpenAI API key").strip()
+        cfg["embedding_mode"] = "openai"
+        cfg["api_key"] = api_key
+        click.echo("\n✓ Using OpenAI embeddings.")
+    else:
+        cfg["embedding_mode"] = "local"
+        cfg["api_key"] = None
+        click.echo("\n✓ Using local embeddings. No API key needed.")
+
+    # Language detection
+    root = find_repo_root()
+    detected = _detect_languages(root)
+    click.echo(f"\nLanguages detected: {', '.join(detected)}")
+    cfg["languages"] = detected
+
+    # Ignore paths
+    click.echo(f"Ignore paths: {', '.join(cfg['ignore_paths'])}")
+
+    save_config(cfg)
+    click.echo(f"\nConfig saved to {get_dug_dir() / 'config.json'}")
+
+    # Build index
+    click.echo("\nStarting initial index...")
+    try:
+        from .indexer import run_init
+        from .embeddings import get_embedder
+        from .hooks import install_git_hooks, ensure_gitignore
+        gi_status = ensure_gitignore(root)
+        click.echo(f"  .gitignore: {gi_status}")
+        embedder = get_embedder(cfg)
+        stats = run_init(root, embedder=embedder)
+        files   = stats["nodes"].get("FILE", 0)
+        symbols = stats["nodes"].get("SYMBOL", 0)
+        commits = stats["nodes"].get("COMMIT", 0)
+        edges   = stats["edges"]
+        chunks  = stats.get("chunks", 0)
+        click.echo(f"  FILE nodes:   {files}")
+        click.echo(f"  SYMBOL nodes: {symbols}")
+        click.echo(f"  COMMIT nodes: {commits}")
+        click.echo(f"  Total edges:  {edges}")
+        click.echo(f"  Chunks embedded: {chunks}")
+
+        # Install git hooks
+        hook_results = install_git_hooks(root)
+        if "error" not in hook_results:
+            click.echo(f"\n  Git hooks:")
+            for hook, status in hook_results.items():
+                click.echo(f"    {hook}: {status}")
+
+        click.echo("\n✓ dug is ready. Run: dug \"your error here\"")
+    except Exception as e:
+        click.echo(f"\n✗ Index failed: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command(name="query")
+@click.argument("bug_input")
+def query(bug_input):
+    """Query the index with a bug or stack trace."""
+    cfg = load_config()
+    dug_dir = get_dug_dir()
+
+    if not (dug_dir / "graph.json").exists():
+        click.echo("No index found. Run: dug init", err=True)
+        sys.exit(1)
+
+    from .graph import CodeGraph
+    from .embeddings import get_embedder
+    from .vector_store import get_or_create_table
+    from .retriever import hybrid_search
+    from .verifier import verify_files
+    from .prompt_builder import build_prompt
+    from .git_context import get_git_history
+
+    graph = CodeGraph()
+    graph.load(dug_dir / "graph.json")
+
+    embedder = get_embedder(cfg)
+    table = get_or_create_table(dug_dir / "embeddings", cfg.get("embedding_mode", "local"))
+
+    ranked, signals = hybrid_search(
+        embedder, graph, table, bug_input,
+        top_k=cfg.get("max_files_in_prompt", 5),
+    )
+
+    # Verify candidates actually contain extracted symbols / bug words
+    root = find_repo_root()
+    verified_paths = verify_files(
+        [f.path for f in ranked], signals.get("symbols", []), root, bug_input
+    )
+    ranked = [f for f in ranked if f.path in verified_paths]
+
+    git_commits = get_git_history(root, depth=cfg.get("git_history_depth", 50))
+
+    prompt = build_prompt(bug_input, ranked, git_commits, signals)
+    click.echo(prompt)
+
+    # Save for `dug solved`
+    from .history import save_last_query
+    save_last_query(bug_input, [f.path for f in ranked], signals)
+
+
+@cli.command()
+@click.option("--changed-only", is_flag=True, help="Reindex only git-changed files.")
+@click.option("--branch-switch", is_flag=True, hidden=True)
+@click.option("--from", "from_ref", default="HEAD~1", hidden=True)
+@click.option("--to", "to_ref", default="HEAD", hidden=True)
+def update(changed_only, branch_switch, from_ref, to_ref):
+    """Refresh the graph and index."""
+    root = find_repo_root()
+    try:
+        if changed_only or branch_switch:
+            from .indexer import update_changed_files
+            result = update_changed_files(
+                root, from_ref=from_ref, to_ref=to_ref
+            )
+            pruned  = result.get("pruned", [])
+            updated = result.get("updated", [])
+            skipped = result.get("skipped", [])
+            if pruned:
+                click.echo(f"  Pruned {len(pruned)} deleted file(s).")
+            click.echo(f"✓ Updated {len(updated)} file(s), skipped {len(skipped)} unchanged.")
+        else:
+            click.echo("Rebuilding full index...")
+            from .indexer import run_init
+            from .hooks import ensure_gitignore
+            ensure_gitignore(root)
+            stats = run_init(root)
+            click.echo(f"✓ Done — {stats['nodes'].get('FILE', 0)} files, "
+                       f"{stats.get('chunks', 0)} chunks.")
+    except Exception as e:
+        click.echo(f"✗ Update failed: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+def watch():
+    """Start background file watcher — reindexes on save (1.5s debounce)."""
+    dug_dir = get_dug_dir()
+    if not (dug_dir / "graph.json").exists():
+        click.echo("No index found. Run: dug init first.", err=True)
+        sys.exit(1)
+    from .watcher import start_watch
+    start_watch(Path.cwd())
+
+
+@cli.command()
+@click.option("--files", "-f", default=None,
+              help="Comma-separated file paths that contained the fix.")
+def solved(files):
+    """Record which files fixed the last bug — improves future rankings."""
+    from .history import load_last_query, record_resolved
+
+    last = load_last_query()
+    if not last:
+        click.echo("No recent query found. Run: dug \"your error\" first.", err=True)
+        sys.exit(1)
+
+    click.echo(f"\nLast query: \"{last['bug_input']}\"")
+    click.echo(f"Suggested files were:")
+    for f in last.get("ranked_files", []):
+        click.echo(f"  - {f}")
+
+    if files:
+        resolved = [f.strip() for f in files.split(",") if f.strip()]
+    else:
+        click.echo("\nWhich files actually contained the bug? (comma-separated paths)")
+        click.echo("Press Enter to accept the suggestions above, or type new paths.")
+        raw = click.prompt(">", default=",".join(last.get("ranked_files", [])))
+        resolved = [f.strip() for f in raw.split(",") if f.strip()]
+
+    if not resolved:
+        click.echo("No files recorded.", err=True)
+        sys.exit(1)
+
+    record_resolved(last["bug_input"], resolved, last.get("signals", {}))
+
+    click.echo(f"\n✓ Saved. These files will rank higher for similar errors next time:")
+    for f in resolved:
+        click.echo(f"  - {f}")
+
+
+@cli.command()
+def stats():
+    """Print graph stats."""
+    dug_dir = get_dug_dir()
+    if not (dug_dir / "graph.json").exists():
+        click.echo("No index found. Run: dug init", err=True)
+        sys.exit(1)
+
+    from .graph import CodeGraph
+    from .vector_store import get_or_create_table
+    cfg = load_config()
+    graph = CodeGraph()
+    graph.load(dug_dir / "graph.json")
+    s = graph.stats()
+    click.echo("\nGraph stats:")
+    for kind, count in s["nodes"].items():
+        click.echo(f"  {kind}: {count}")
+    click.echo(f"  Edges: {s['edges']}")
+    try:
+        table = get_or_create_table(dug_dir / "embeddings", cfg.get("embedding_mode", "local"))
+        click.echo(f"  Chunks (embedded): {table.count_rows()}")
+    except Exception:
+        click.echo("  Chunks (embedded): n/a")
+
+
+@cli.group()
+def config():
+    """Manage dug configuration."""
+
+
+@config.command(name="set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key, value):
+    """Set a config value. Example: dug config set embedding-mode openai"""
+    key = key.replace("-", "_")
+    set_config_value(key, value)
+    click.echo(f"✓ {key} = {value}")
+
+
+@config.command(name="show")
+def config_show():
+    """Show current config."""
+    cfg = load_config()
+    import json
+    click.echo(json.dumps(cfg, indent=2))
+
+
+if __name__ == "__main__":
+    cli()

dug/chunker.py

@@ -0,0 +1,137 @@
+"""Tree-sitter based function/method extractor — produces chunks for embedding."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+from tree_sitter import Language, Parser, Node
+
+import tree_sitter_python as tspython
+import tree_sitter_java as tsjava
+import tree_sitter_javascript as tsjavascript
+import tree_sitter_typescript as tstypescript
+
+# ---------------------------------------------------------------------------
+# Language parsers
+# ---------------------------------------------------------------------------
+
+_LANGUAGES: dict[str, Language] = {
+    "python":     Language(tspython.language()),
+    "java":       Language(tsjava.language()),
+    "javascript": Language(tsjavascript.language()),
+    "typescript": Language(tstypescript.language_typescript()),
+    "tsx":        Language(tstypescript.language_tsx()),
+}
+
+_EXT_TO_LANG: dict[str, str] = {
+    ".py":  "python",
+    ".java": "java",
+    ".js":  "javascript",
+    ".jsx": "javascript",
+    ".ts":  "typescript",
+    ".tsx": "tsx",
+}
+
+# Node types that represent callable units worth embedding
+_FUNCTION_NODE_TYPES: dict[str, set[str]] = {
+    "python":     {"function_definition", "decorated_definition"},
+    "java":       {"method_declaration", "constructor_declaration"},
+    "javascript": {"function_declaration", "method_definition", "arrow_function",
+                   "function_expression"},
+    "typescript": {"function_declaration", "method_definition", "arrow_function",
+                   "function_expression", "method_signature"},
+    "tsx":        {"function_declaration", "method_definition", "arrow_function",
+                   "function_expression", "method_signature"},
+}
+
+MIN_CHUNK_CHARS = 30
+MAX_CHUNK_CHARS = 8000
+
+
+# ---------------------------------------------------------------------------
+# Chunk dataclass
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Chunk:
+    chunk_id: str       # md5(file_path + function_name + str(start_line))
+    file_path: str      # relative to repo root
+    function_name: str
+    start_line: int     # 1-indexed
+    end_line: int
+    code: str
+    language: str
+
+
+def _make_chunk_id(file_path: str, name: str, start_line: int) -> str:
+    key = f"{file_path}:{name}:{start_line}"
+    return hashlib.md5(key.encode()).hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# AST walker
+# ---------------------------------------------------------------------------
+
+def _get_function_name(node: Node, code_bytes: bytes, language: str) -> str:
+    """Extract the best available name for a function/method node."""
+    # decorated_definition wraps the actual function — recurse one level
+    if node.type == "decorated_definition":
+        for child in node.children:
+            if child.type == "function_definition":
+                return _get_function_name(child, code_bytes, language)
+
+    name_node = node.child_by_field_name("name")
+    if name_node:
+        return code_bytes[name_node.start_byte:name_node.end_byte].decode(errors="replace")
+
+    # arrow functions often have no name — use parent context if available
+    return "<anonymous>"
+
+
+def _walk(node: Node, code_bytes: bytes, language: str,
+          target_types: set[str], results: list[Chunk], file_path: str) -> None:
+    if node.type in target_types:
+        name = _get_function_name(node, code_bytes, language)
+        code = code_bytes[node.start_byte:node.end_byte].decode(errors="replace")
+        if MIN_CHUNK_CHARS <= len(code) <= MAX_CHUNK_CHARS and name != "<anonymous>":
+            results.append(Chunk(
+                chunk_id=_make_chunk_id(file_path, name, node.start_point[0] + 1),
+                file_path=file_path,
+                function_name=name,
+                start_line=node.start_point[0] + 1,
+                end_line=node.end_point[0] + 1,
+                code=code,
+                language=language,
+            ))
+        # still recurse — nested functions/methods should also be extracted
+    for child in node.children:
+        _walk(child, code_bytes, language, target_types, results, file_path)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def extract_chunks(file_path: Path, root: Path) -> list[Chunk]:
+    """Parse `file_path` with tree-sitter and return one Chunk per function/method."""
+    lang = _EXT_TO_LANG.get(file_path.suffix)
+    if lang is None or lang not in _LANGUAGES:
+        return []
+
+    language = _LANGUAGES[lang]
+    parser = Parser(language)
+
+    try:
+        code_bytes = file_path.read_bytes()
+    except OSError:
+        return []
+
+    tree = parser.parse(code_bytes)
+    rel = str(file_path.relative_to(root))
+    target_types = _FUNCTION_NODE_TYPES.get(lang, set())
+
+    results: list[Chunk] = []
+    _walk(tree.root_node, code_bytes, lang, target_types, results, rel)
+    return results

dug/config.py

@@ -0,0 +1,77 @@
+import json
+import subprocess
+from pathlib import Path
+
+DEFAULTS = {
+    "embedding_mode": "local",
+    "api_key": None,
+    "languages": ["python", "java", "typescript", "javascript"],
+    "ignore_paths": ["node_modules", ".git", "build", "dist", "vendor", "__pycache__", ".venv", "venv", ".tox", "eggs", ".eggs"],
+    "git_history_depth": 50,
+    "max_files_in_prompt": 5,
+    "exclude_test_files": True,
+}
+
+
+def find_repo_root() -> Path:
+    """
+    Walk up from cwd looking for .git/. Falls back to cwd if not in a git repo.
+    Also accepts a repo root that already has .dug/ (supports non-git projects
+    that ran dug init manually).
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            cwd=Path.cwd(),
+        )
+        if result.returncode == 0:
+            return Path(result.stdout.strip())
+    except FileNotFoundError:
+        pass
+
+    # Fallback: walk up looking for an existing .dug/ directory
+    current = Path.cwd()
+    for parent in [current, *current.parents]:
+        if (parent / ".dug").exists():
+            return parent
+
+    return Path.cwd()
+
+
+def get_dug_dir() -> Path:
+    return find_repo_root() / ".dug"
+
+
+def get_config_path() -> Path:
+    return get_dug_dir() / "config.json"
+
+
+def load_config() -> dict:
+    path = get_config_path()
+    if not path.exists():
+        return dict(DEFAULTS)
+    with open(path) as f:
+        data = json.load(f)
+    return {**DEFAULTS, **data}
+
+
+def save_config(cfg: dict) -> None:
+    path = get_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(cfg, f, indent=2)
+
+
+def set_config_value(key: str, value: str) -> None:
+    cfg = load_config()
+    # coerce booleans and nulls
+    if value.lower() == "null":
+        cfg[key] = None
+    elif value.lower() in ("true", "false"):
+        cfg[key] = value.lower() == "true"
+    else:
+        cfg[key] = value
+    save_config(cfg)
+# phase 4 test comment

dug/embeddings.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+import warnings
+
+# Suppress HuggingFace noise before any library import
+os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+os.environ.setdefault("HF_HUB_VERBOSITY", "error")
+warnings.filterwarnings("ignore", category=UserWarning, module="huggingface_hub")
+warnings.filterwarnings("ignore", category=FutureWarning, module="transformers")
+
+for _noisy in ("sentence_transformers", "huggingface_hub", "transformers",
+               "torch", "tokenizers"):
+    logging.getLogger(_noisy).setLevel(logging.ERROR)
+
+# ---------------------------------------------------------------------------
+# Dependency installer
+# ---------------------------------------------------------------------------
+
+_LOCAL_DEPS  = ["sentence-transformers"]
+_OPENAI_DEPS = ["openai"]
+
+
+def _ensure_installed(packages: list[str], label: str) -> None:
+    """Check if packages are importable; pip-install them if not."""
+    import importlib
+    missing = []
+    for pkg in packages:
+        module = pkg.replace("-", "_").split("[")[0]
+        try:
+            importlib.import_module(module)
+        except ImportError:
+            missing.append(pkg)
+
+    if not missing:
+        return
+
+    print(f"\n[dug] {label} dependencies not found: {', '.join(missing)}")
+    print(f"[dug] Installing (one-time download)...\n")
+
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--quiet", *missing],
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        print(f"\n[dug] ✓ {label} dependencies installed.\n")
+    except subprocess.CalledProcessError:
+        print(f"\n[dug] ✗ Auto-install failed. Run manually:")
+        print(f"      pip install {' '.join(missing)}")
+        sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Embedders
+# ---------------------------------------------------------------------------
+
+class LocalEmbedder:
+    def __init__(self):
+        _ensure_installed(_LOCAL_DEPS, "Local embedding")
+        from sentence_transformers import SentenceTransformer
+        self.model = SentenceTransformer("all-MiniLM-L6-v2")
+
+    def embed(self, text: str) -> list[float]:
+        return self.model.encode(text).tolist()
+
+
+class OpenAIEmbedder:
+    def __init__(self, api_key: str):
+        _ensure_installed(_OPENAI_DEPS, "OpenAI")
+        from openai import OpenAI
+        self.client = OpenAI(api_key=api_key)
+
+    def embed(self, text: str) -> list[float]:
+        response = self.client.embeddings.create(
+            model="text-embedding-3-small",
+            input=text,
+        )
+        return response.data[0].embedding
+
+
+_cache: dict = {}
+
+
+def get_embedder(config: dict) -> LocalEmbedder | OpenAIEmbedder:
+    mode = config.get("embedding_mode", "local")
+    if mode not in _cache:
+        if mode == "openai":
+            _cache[mode] = OpenAIEmbedder(api_key=config["api_key"])
+        else:
+            _cache[mode] = LocalEmbedder()
+    return _cache[mode]

dug/git_context.py

@@ -0,0 +1,56 @@
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+@dataclass
+class Commit:
+    hash: str
+    message: str
+    timestamp: datetime
+    files_touched: list[str] = field(default_factory=list)
+
+    @property
+    def days_ago(self) -> int:
+        delta = datetime.now(timezone.utc) - self.timestamp.astimezone(timezone.utc)
+        return delta.days
+
+
+def get_git_history(root: Path, depth: int = 50) -> list[Commit]:
+    try:
+        result = subprocess.run(
+            ["git", "log", "--name-only", "--format=%H|%s|%aI", f"-n{depth}"],
+            capture_output=True,
+            text=True,
+            cwd=root,
+        )
+    except FileNotFoundError:
+        return []
+
+    if result.returncode != 0:
+        return []
+
+    commits: list[Commit] = []
+    current: Commit | None = None
+
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if "|" in line and len(line.split("|")) >= 3:
+            parts = line.split("|", 2)
+            try:
+                ts = datetime.fromisoformat(parts[2])
+            except ValueError:
+                ts = datetime.now(timezone.utc)
+            if current:
+                commits.append(current)
+            current = Commit(hash=parts[0], message=parts[1], timestamp=ts)
+        elif current is not None:
+            current.files_touched.append(line)
+
+    if current:
+        commits.append(current)
+
+    return commits