luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/backup.py

@@ -0,0 +1,237 @@
+"""Backup system — git-based snapshots before destructive operations.
+
+Creates a timestamped git commit (or stash if git commits aren't desired)
+so that /self-improve and /debug can always be fully reverted.
+
+Usage from CLI:
+    /backup              — snapshot now with auto message
+    /backup <message>    — snapshot with custom message
+    /backup list         — show recent backup snapshots
+    /backup restore      — restore the most recent backup snapshot
+    /backup restore <n>  — restore backup snapshot N (from /backup list)
+"""
+
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+# Tag prefix used to identify backup commits so we can list/restore them
+BACKUP_TAG_PREFIX = "dsc-backup/"
+
+
+def _git(*args: str, cwd: Optional[str] = None) -> tuple[int, str, str]:
+    """Run a git command. Returns (returncode, stdout, stderr)."""
+    try:
+        result = subprocess.run(
+            ["git"] + list(args),
+            capture_output=True,
+            text=True,
+            timeout=30,
+            cwd=cwd or str(Path.cwd()),
+        )
+        return result.returncode, result.stdout.strip(), result.stderr.strip()
+    except FileNotFoundError:
+        return 1, "", "git not found in PATH"
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def _is_git_repo(cwd: Optional[str] = None) -> bool:
+    code, _, _ = _git("rev-parse", "--is-inside-work-tree", cwd=cwd)
+    return code == 0
+
+
+def _has_changes(cwd: Optional[str] = None) -> bool:
+    """Returns True if there are any tracked or untracked changes."""
+    _, out, _ = _git("status", "--porcelain", cwd=cwd)
+    return bool(out.strip())
+
+
+def _current_branch(cwd: Optional[str] = None) -> str:
+    _, out, _ = _git("rev-parse", "--abbrev-ref", "HEAD", cwd=cwd)
+    return out or "unknown"
+
+
+def _short_hash(cwd: Optional[str] = None) -> str:
+    _, out, _ = _git("rev-parse", "--short", "HEAD", cwd=cwd)
+    return out or "unknown"
+
+
+def create_backup(message: str = "", cwd: Optional[str] = None) -> dict:
+    """Create a git backup snapshot of the current working tree.
+
+    Strategy:
+      1. `git add -A`  — stage everything (new, modified, deleted)
+      2. `git commit`  — commit with a timestamped message
+      3. `git tag`     — tag it with dsc-backup/<timestamp> for easy lookup
+
+    If there is nothing to commit, returns success with a note.
+
+    Returns a dict with keys: ok, message, tag, hash, error
+    """
+    result = {"ok": False, "message": "", "tag": "", "hash": "", "error": ""}
+
+    if not _is_git_repo(cwd):
+        result["error"] = (
+            "No git repository found. Run `git init` in your project root to enable backups."
+        )
+        return result
+
+    if not _has_changes(cwd):
+        # Nothing dirty — point at the current HEAD as the backup
+        h = _short_hash(cwd)
+        result["ok"] = True
+        result["hash"] = h
+        result["message"] = f"Nothing to commit — working tree is clean (HEAD is {h})"
+        return result
+
+    # Stage everything
+    code, _, err = _git("add", "-A", cwd=cwd)
+    if code != 0:
+        result["error"] = f"git add failed: {err}"
+        return result
+
+    # Build commit message
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    label = message.strip() or "pre-operation snapshot"
+    commit_msg = f"[dsc-backup] {label} ({ts})"
+
+    code, _, err = _git("commit", "-m", commit_msg, cwd=cwd)
+    if code != 0:
+        result["error"] = f"git commit failed: {err}"
+        return result
+
+    # Tag it so we can find it later
+    tag_name = BACKUP_TAG_PREFIX + datetime.now().strftime("%Y%m%d_%H%M%S")
+    _git("tag", tag_name, cwd=cwd)  # best-effort, don't fail if tagging fails
+
+    h = _short_hash(cwd)
+    result["ok"] = True
+    result["hash"] = h
+    result["tag"] = tag_name
+    result["message"] = f"Backup created: {h}  tag: {tag_name}"
+    return result
+
+
+def list_backups(limit: int = 10, cwd: Optional[str] = None) -> list[dict]:
+    """Return a list of recent backup commits (newest first).
+
+    Each entry: {n, hash, tag, date, subject}
+    """
+    # List tags matching our prefix, sorted by creation date descending
+    _, tag_out, _ = _git(
+        "tag", "--list", f"{BACKUP_TAG_PREFIX}*",
+        "--sort=-creatordate",
+        "--format=%(refname:short)|%(objectname:short)|%(creatordate:short)",
+        cwd=cwd,
+    )
+
+    entries = []
+    for i, line in enumerate(tag_out.splitlines()[:limit]):
+        parts = line.split("|")
+        if len(parts) >= 3:
+            entries.append({
+                "n": i + 1,
+                "tag": parts[0],
+                "hash": parts[1],
+                "date": parts[2],
+                "subject": parts[0].replace(BACKUP_TAG_PREFIX, ""),
+            })
+        elif len(parts) == 2:
+            entries.append({
+                "n": i + 1,
+                "tag": parts[0],
+                "hash": parts[1],
+                "date": "",
+                "subject": parts[0].replace(BACKUP_TAG_PREFIX, ""),
+            })
+
+    # Fallback: search commit log for [dsc-backup] messages
+    if not entries:
+        _, log_out, _ = _git(
+            "log", f"--max-count={limit}",
+            "--pretty=format:%h|%ad|%s",
+            "--date=short",
+            "--grep=[dsc-backup]",
+            cwd=cwd,
+        )
+        for i, line in enumerate(log_out.splitlines()):
+            parts = line.split("|", 2)
+            if len(parts) == 3:
+                entries.append({
+                    "n": i + 1,
+                    "tag": "",
+                    "hash": parts[0],
+                    "date": parts[1],
+                    "subject": parts[2],
+                })
+
+    return entries
+
+
+def restore_backup(ref: str, cwd: Optional[str] = None) -> dict:
+    """Restore working tree to a backup snapshot.
+
+    Uses `git checkout <ref> -- .` so it only touches the working tree
+    (does NOT move HEAD), leaving you on the same branch. Any currently
+    staged/unstaged changes are overwritten.
+
+    Args:
+        ref: A tag name, commit hash, or index number (as string) from list_backups()
+
+    Returns a dict with keys: ok, message, error
+    """
+    result = {"ok": False, "message": "", "error": ""}
+
+    if not _is_git_repo(cwd):
+        result["error"] = "No git repository found."
+        return result
+
+    # Resolve numeric index to a real ref
+    if ref.isdigit():
+        backups = list_backups(cwd=cwd)
+        idx = int(ref)
+        match = next((b for b in backups if b["n"] == idx), None)
+        if not match:
+            result["error"] = f"No backup #{idx} found. Run /backup list to see options."
+            return result
+        ref = match["tag"] or match["hash"]
+
+    # Stash any current dirty state first so we don't lose it
+    dirty = _has_changes(cwd)
+    stash_msg = ""
+    if dirty:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        code, _, _ = _git("stash", "push", "-m", f"pre-restore-{ts}", cwd=cwd)
+        if code == 0:
+            stash_msg = " (current changes stashed — run `git stash pop` to recover them)"
+
+    # Checkout the files from the backup ref into the working tree
+    code, _, err = _git("checkout", ref, "--", ".", cwd=cwd)
+    if code != 0:
+        # Try to recover stash
+        if dirty:
+            _git("stash", "pop", cwd=cwd)
+        result["error"] = f"git checkout failed: {err}"
+        return result
+
+    result["ok"] = True
+    result["message"] = f"Restored to {ref}{stash_msg}"
+    return result
+
+
+def format_backup_list(backups: list[dict]) -> str:
+    """Format backup list for display."""
+    if not backups:
+        return "No backups found. Run /backup to create one."
+    lines = ["[bold]Recent backups:[/bold]\n"]
+    for b in backups:
+        date_str = f"  {b['date']}" if b["date"] else ""
+        tag_str = f"  [{b['tag']}]" if b["tag"] else ""
+        lines.append(f"  [cyan]#{b['n']}[/cyan]  {b['hash']}{date_str}{tag_str}")
+        if b["subject"] and not b["subject"].startswith("dsc-backup/"):
+            lines.append(f"       [dim]{b['subject'][:80]}[/dim]")
+    lines.append("\n[dim]Use /backup restore <#> to restore any of these[/dim]")
+    return "\n".join(lines)

luckyd_code/brain/__init__.py

@@ -0,0 +1,84 @@
+"""Persistent Codebase Brain — knowledge graph and RAG system for code understanding."""
+import os
+from .graph import KnowledgeGraph
+from .parser import parse_project
+from .chunker import chunk_file, chunk_project
+from .embedder import Embedder, get_embedder
+from .indexer import VectorIndexer
+from .retriever import Retriever
+from .assembler import ContextAssembler
+
+__all__ = [
+    "KnowledgeGraph",
+    "parse_project",
+    "chunk_file",
+    "chunk_project",
+    "Embedder",
+    "get_embedder",
+    "VectorIndexer",
+    "Retriever",
+    "ContextAssembler",
+    "rebuild_project",
+    "find_dependents",
+]
+
+find_dependents = KnowledgeGraph.find_dependents
+
+
+def rebuild_project(project_root: str | None = None) -> dict:
+    """Rebuild both the vector index and the knowledge graph for a project.
+
+    Args:
+        project_root: Root directory to index. Defaults to current working directory.
+
+    Returns:
+        Dict with keys: chunks, files, node_count, files_parsed, languages
+    """
+    if project_root is None:
+        project_root = os.getcwd()
+
+    result = {"chunks": 0, "files": 0, "node_count": 0, "files_parsed": 0, "languages": {}}
+
+    # Build vector index
+    chunks = chunk_project(project_root)
+    if chunks:
+        indexer = VectorIndexer()
+        stats = indexer.build(chunks)  # type: ignore[arg-type]
+        # Track mtimes
+        from .chunker import LANGUAGE_MAP
+        from .constants import SKIP_DIRS, should_skip
+        from pathlib import Path
+        from .indexer import BRAIN_DIR, MTIMES_FILE
+        import json as _json
+
+        mtimes: dict = {}
+        for dirpath, dirnames, filenames in os.walk(Path(project_root).resolve()):
+            dirnames[:] = [d for d in dirnames if not should_skip(d)]
+            for fname in filenames:
+                suffix = Path(fname).suffix.lower()
+                if suffix not in LANGUAGE_MAP:
+                    continue
+                fpath = Path(dirpath) / fname
+                try:
+                    st = fpath.stat()
+                    mtimes[str(fpath)] = (st.st_mtime, st.st_size)
+                except OSError:
+                    continue
+        indexer.file_mtimes = mtimes
+        indexer.save()
+
+        result["chunks"] = stats.get("chunks", 0)
+        result["files"] = stats.get("files", 0)
+        result["languages"] = stats.get("languages", {})
+
+    # Build old graph (backward compatible)
+    parsed, _ = parse_project(project_root)
+    if parsed:
+        brain = KnowledgeGraph()
+        brain.build(project_root, parsed)
+        brain.save()
+        result["node_count"] = brain.stats.get("node_count", 0)
+        result["files_parsed"] = brain.stats.get("files_parsed", 0)
+
+    return result
+

luckyd_code/brain/assembler.py

@@ -0,0 +1,100 @@
+"""Context assembler — takes ranked chunks and produces prompt-ready context blocks."""
+
+from typing import Any
+
+
+
+def _token_count(text: str) -> int:
+    return len(text) // 4
+
+
+class ContextAssembler:
+    """Assembles ranked chunks into a prompt-ready XML context block."""
+
+    def assemble(
+        self,
+        chunks: list[dict[str, Any]],
+        max_tokens: int = 8000,
+        max_chunks: int = 20,
+    ) -> str:
+        if not chunks:
+            return ""
+
+        deduped = self._deduplicate(chunks)
+        return self._format_chunks(deduped, max_tokens, max_chunks)
+
+    def _deduplicate(self, chunks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        if not chunks:
+            return []
+
+        by_file: dict[str, list[dict[str, Any]]] = {}
+        for c in chunks:
+            by_file.setdefault(c["file_path"], []).append(c)
+
+        result: list[dict[str, Any]] = []
+        for file_path, file_chunks in by_file.items():
+            file_chunks.sort(key=lambda c: c.get("score", 0), reverse=True)
+
+            keep: list[dict[str, Any]] = []
+            for c in file_chunks:
+                c_start = c.get("start_line", 0)
+                c_end = c.get("end_line", 0)
+                overlapping = False
+                for kept in keep:
+                    k_start = kept.get("start_line", 0)
+                    k_end = kept.get("end_line", 0)
+                    if not (c_end < k_start or c_start > k_end):
+                        if c.get("score", 0) > kept.get("score", 0):
+                            keep.remove(kept)
+                            keep.append(c)
+                        overlapping = True
+                        break
+                if not overlapping:
+                    keep.append(c)
+
+            result.extend(keep)
+
+        result.sort(key=lambda c: c.get("score", 0), reverse=True)
+        return result
+
+    def _format_chunks(
+        self,
+        chunks: list[dict[str, Any]],
+        max_tokens: int,
+        max_chunks: int,
+    ) -> str:
+        parts: list[str] = []
+        total_tokens = 0
+
+        for chunk in chunks[:max_chunks]:
+            score = chunk.get("score", 0)
+            file_path = chunk.get("file_path", "")
+            start_line = chunk.get("start_line", 0)
+            end_line = chunk.get("end_line", 0)
+            content = chunk.get("content", "").strip()
+
+            if not content:
+                continue
+
+            chunk_tokens = _token_count(content)
+            remaining = max_tokens - total_tokens - _token_count("<context></context>")
+
+            if remaining <= 0:
+                break
+
+            if chunk_tokens > remaining:
+                truncated_chars = remaining * 4
+                content = content[:truncated_chars] + "..."
+
+            score_str = f'{score:.2f}' if score else "0.00"
+            context_tag = (
+                f'<context file="{file_path}" lines="{start_line}-{end_line}" '
+                f'relevance="{score_str}">\n'
+                f"{content}\n"
+                f"</context>"
+            )
+
+            parts.append(context_tag)
+            total_tokens += _token_count(context_tag)
+
+        return "\n\n".join(parts)