cerebro-code-memory 0.1.0__py3-none-any.whl

cerebro/gitsync.py

@@ -0,0 +1,124 @@
+"""Git-aware freshness.
+
+The post-edit hook only catches edits made *through* Claude Code. Branch switches,
+`git pull`, rebases, and edits in the raw editor go unnoticed until a manual reindex.
+This diffs git state since the last sync and incrementally reindexes only the changed
+files. It handles a single repo at the root OR several nested repos (e.g. a folder of
+sub-app repos, like a Fenix-style multi-repo workspace).
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from . import indexer
+
+
+def _git(repo_abs: Path, *args: str, timeout: int = 15) -> str | None:
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(repo_abs), *args],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        if out.returncode == 0:
+            return out.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def find_git_repos(config, max_depth: int = 3) -> list[str]:
+    """Repo dirs relative to root. Returns [''] when the root itself is a repo."""
+    root = config.root
+    if (root / ".git").exists():
+        return [""]
+    repos: list[str] = []
+    for dirpath, dirnames, _files in os.walk(root):
+        d = Path(dirpath)
+        depth = len(d.relative_to(root).parts)
+        if depth >= max_depth:
+            dirnames[:] = []
+            continue
+        dirnames[:] = [dn for dn in dirnames if not config.is_ignored(d / dn)]
+        if (d / ".git").exists():
+            repos.append(d.relative_to(root).as_posix())
+            dirnames[:] = []  # a repo is one unit — don't descend for nested repos
+    return repos
+
+
+def _porcelain_paths(status: str) -> set[str]:
+    paths = set()
+    for line in status.splitlines():
+        path = line[3:]
+        if " -> " in path:  # rename: "old -> new"
+            path = path.split(" -> ", 1)[1]
+        path = path.strip().strip('"')
+        if path:
+            paths.add(path)
+    return paths
+
+
+def sync(config, conn) -> dict:
+    """Reindex files changed via git since the last sync, across all repos under
+    the root. First run just records each repo's HEAD as a baseline."""
+    repos = find_git_repos(config)
+    if not repos:
+        return {"git": False, "changed": 0}
+
+    changed_root_rel: set[str] = set()
+    new_heads: dict[str, str] = {}
+    for repo_rel in repos:
+        repo_abs = config.root / repo_rel if repo_rel else config.root
+        head = _git(repo_abs, "rev-parse", "HEAD")
+        if head is None:
+            continue
+        key = f"git_head:{repo_rel}"
+        row = conn.execute("SELECT value FROM meta WHERE key=?", (key,)).fetchone()
+        old = row["value"] if row else None
+
+        files: set[str] = set()
+        if old and old != head:
+            diff = _git(repo_abs, "diff", "--name-only", old, head)
+            if diff:
+                files.update(diff.splitlines())
+        status = _git(repo_abs, "status", "--porcelain")
+        if status:
+            files.update(_porcelain_paths(status))
+
+        for f in files:
+            rel = f"{repo_rel}/{f}" if repo_rel else f
+            if not config.is_ignored(config.root / rel):
+                changed_root_rel.add(rel)
+        new_heads[key] = head
+
+    rels = sorted(changed_root_rel)
+    if rels:
+        indexer.reindex_paths(config, conn, rels)
+    for key, head in new_heads.items():
+        conn.execute(
+            "INSERT INTO meta(key,value) VALUES(?,?) "
+            "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+            (key, head),
+        )
+    conn.commit()
+    return {"git": True, "repos": len(new_heads), "changed": len(rels)}
+
+
+def main():  # `cerebro-sync` entry point
+    import json
+
+    from . import config as cfg
+    from . import db
+
+    config = cfg.Config.load()
+    conn = db.connect(config.db_path)
+    result = sync(config, conn)
+    result["root"] = str(config.root)
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

cerebro/graph.py

@@ -0,0 +1,77 @@
+"""Dependency-graph analysis over the `edges` table.
+
+An edge src -> dst means "src imports dst". PageRank therefore scores
+widely-imported files (shared utilities, core modules) highest, which is what we
+want to surface first in the map. NOT shortest-path / Dijkstra — code knowledge
+is a relevance problem, not a routing one.
+"""
+from __future__ import annotations
+
+import networkx as nx
+
+from . import db
+
+
+def build_graph(conn, exclude_kinds: tuple[str, ...] = ()) -> nx.DiGraph:
+    """Build the import digraph. Pass exclude_kinds=('type',) to drop edges that
+    are elided at runtime (TS type-only imports) — e.g. for cycle detection, where
+    a type-only cycle is cosmetic, not a real startup-order problem."""
+    g = nx.DiGraph()
+    for row in conn.execute("SELECT path FROM files"):
+        g.add_node(row["path"])
+    if exclude_kinds:
+        ph = ",".join("?" * len(exclude_kinds))
+        rows = conn.execute(
+            f"SELECT src_path, dst_path FROM edges WHERE kind NOT IN ({ph})", exclude_kinds
+        )
+    else:
+        rows = conn.execute("SELECT src_path, dst_path FROM edges")
+    for row in rows:
+        g.add_edge(row["src_path"], row["dst_path"])
+    return g
+
+
+def _pagerank(g, damping: float = 0.85, iters: int = 50, tol: float = 1e-6):
+    """Pure-Python power-iteration PageRank.
+
+    Kept dependency-light on purpose: networkx's own pagerank requires scipy,
+    which would be a heavy add for ~15 lines of standard math. Dangling nodes
+    (no outgoing edges) redistribute their rank uniformly.
+    """
+    nodes = list(g.nodes)
+    n = len(nodes)
+    if n == 0:
+        return {}
+    out_deg = {v: g.out_degree(v) for v in nodes}
+    rank = {v: 1.0 / n for v in nodes}
+    for _ in range(iters):
+        dangling = sum(rank[v] for v in nodes if out_deg[v] == 0)
+        nxt = {}
+        for v in nodes:
+            inflow = sum(rank[u] / out_deg[u] for u in g.predecessors(v) if out_deg[u])
+            nxt[v] = (1 - damping) / n + damping * (inflow + dangling / n)
+        delta = sum(abs(nxt[v] - rank[v]) for v in nodes)
+        rank = nxt
+        if delta < tol:
+            break
+    return rank
+
+
+def rank(conn, top: int | None = None):
+    """Return [(path, score), ...] ordered by importance (descending)."""
+    g = build_graph(conn)
+    scores = _pagerank(g)
+    ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
+    return ranked[:top] if top else ranked
+
+
+def dependents(conn, path: str) -> list[str]:
+    """Files that import `path` (impact analysis: change `path`, these may break)."""
+    g = build_graph(conn)
+    return sorted(g.predecessors(path)) if path in g else []
+
+
+def dependencies(conn, path: str) -> list[str]:
+    """Files that `path` imports."""
+    g = build_graph(conn)
+    return sorted(g.successors(path)) if path in g else []