cortex-local 2.0.7__tar.gz → 2.0.8__tar.gz

{cortex_local-2.0.7 → cortex_local-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortex-local
-Version: 2.0.7
+Version: 2.0.8
 Summary: Local semantic search MCP server — notes + code, embedded Qdrant, fastembed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0

cortex_local-2.0.8/cortex/core/cache.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Mtime-based embedding cache — skip re-embedding unchanged files on full reindex."""
+
+import json
+from pathlib import Path
+
+
+def load_cache(section: str, cache_file: Path) -> dict:
+    """Load {rel_path: mtime} for given section ('notes' or 'code')."""
+    try:
+        if cache_file.exists():
+            return json.loads(cache_file.read_text()).get(section, {})
+    except Exception:
+        pass
+    return {}
+
+
+def save_cache(section: str, data: dict, cache_file: Path) -> None:
+    """Persist updated cache section without touching other sections."""
+    try:
+        existing = json.loads(cache_file.read_text()) if cache_file.exists() else {}
+        existing[section] = data
+        cache_file.write_text(json.dumps(existing))
+    except Exception as e:
+        print(f"warn: cache save failed: {e}", flush=True)

cortex_local-2.0.8/cortex/core/chunker.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Source code chunking — tree-sitter semantic parsing with sliding-window fallback."""
+
+from pathlib import Path
+
+CODE_EXTS = {".js", ".ts", ".tsx", ".jsx", ".svelte", ".py", ".java", ".go", ".rs", ".css", ".html", ".kt", ".kts", ".gd", ".yml", ".yaml"}
+SKIP_DIRS = {"node_modules", ".git", "dist", "build", ".next", ".svelte-kit", "__pycache__", ".gradle", "target"}
+LANG_MAP = {
+    ".js": "javascript", ".ts": "typescript", ".tsx": "typescript",
+    ".jsx": "javascript", ".svelte": "svelte", ".py": "python",
+    ".java": "java", ".go": "go", ".rs": "rust", ".css": "css", ".html": "html",
+    ".kt": "kotlin", ".kts": "kotlin", ".gd": "gdscript",
+    ".yml": "yaml", ".yaml": "yaml",
+}
+
+CHUNK_LINES = 30
+OVERLAP_LINES = 5
+MAX_CHUNK_LINES = 80
+
+try:
+    from tree_sitter import Language, Parser as _TSParser
+    import tree_sitter_python as _tspy
+    import tree_sitter_javascript as _tsjs
+    import tree_sitter_typescript as _tsts
+    import tree_sitter_kotlin as _tskotlin
+
+    _TS_LANGUAGES: dict = {
+        ".py":  Language(_tspy.language()),
+        ".js":  Language(_tsjs.language()),
+        ".jsx": Language(_tsjs.language()),
+        ".ts":  Language(_tsts.language_typescript()),
+        ".tsx": Language(_tsts.language_tsx()),
+        ".kt":  Language(_tskotlin.language()),
+        ".kts": Language(_tskotlin.language()),
+    }
+    _TS_SEMANTIC: dict = {
+        ".py":  {"function_definition", "class_definition"},
+        ".js":  {"function_declaration", "class_declaration", "method_definition", "lexical_declaration"},
+        ".jsx": {"function_declaration", "class_declaration", "method_definition", "lexical_declaration"},
+        ".ts":  {"function_declaration", "class_declaration", "method_definition", "interface_declaration", "lexical_declaration"},
+        ".tsx": {"function_declaration", "class_declaration", "method_definition", "interface_declaration", "lexical_declaration"},
+        ".kt":  {"function_declaration", "class_declaration", "object_declaration"},
+        ".kts": {"function_declaration", "class_declaration", "object_declaration"},
+    }
+    _TS_AVAILABLE = True
+except Exception:
+    _TS_AVAILABLE = False
+    _TS_LANGUAGES = {}
+    _TS_SEMANTIC = {}
+
+
+def _sliding_window(lines: list, start: int, end: int, repo_name: str, rel: str, language: str, github_url_base: str = "") -> list:
+    step = CHUNK_LINES - OVERLAP_LINES
+    chunks = []
+    i = start
+    while i < end:
+        j = min(i + CHUNK_LINES, end)
+        body = "\n".join(lines[i:j]).strip()
+        if body:
+            url = f"{github_url_base}/{rel}#L{i+1}-L{j}" if github_url_base else ""
+            chunks.append({
+                "repo": repo_name, "file": rel, "language": language,
+                "start_line": i + 1, "end_line": j,
+                "text": f"# {repo_name}/{rel} (lines {i+1}-{j})\n\n{body}",
+                "github_url": url,
+            })
+        if j == end:
+            break
+        i += step
+    return chunks
+
+
+def _has_function_value(node, depth: int = 0) -> bool:
+    if node.type in ("arrow_function", "function_expression"):
+        return True
+    if depth >= 3:
+        return False
+    return any(_has_function_value(c, depth + 1) for c in node.children)
+
+
+def _collect_semantic_nodes(node, target_types: set, depth: int = 0, max_depth: int = 5) -> list:
+    if node.type in target_types:
+        return [node]
+    if depth >= max_depth:
+        return []
+    result = []
+    for child in node.children:
+        result.extend(_collect_semantic_nodes(child, target_types, depth + 1, max_depth))
+    return result
+
+
+def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_url_base: str = "") -> list:
+    """Chunk a source file into indexable segments.
+
+    base_dir: directory to compute relative paths from (defaults to path.parent).
+    github_url_base: e.g. "https://github.com/owner/repo/blob/master"
+    """
+    try:
+        source = path.read_bytes()
+        lines = source.decode("utf-8", errors="replace").splitlines()
+    except Exception:
+        return []
+    if not lines:
+        return []
+
+    ext = path.suffix
+    base = base_dir if base_dir else path.parent
+    try:
+        rel = str(path.relative_to(base))
+    except ValueError:
+        rel = path.name
+    language = LANG_MAP.get(ext, ext.lstrip("."))
+
+    if _TS_AVAILABLE and ext in _TS_LANGUAGES:
+        try:
+            parser = _TSParser(_TS_LANGUAGES[ext])
+            tree = parser.parse(source)
+            nodes = _collect_semantic_nodes(tree.root_node, _TS_SEMANTIC[ext])
+            nodes = [n for n in nodes if n.type != "lexical_declaration" or _has_function_value(n)]
+            if nodes:
+                chunks = []
+                for node in nodes:
+                    s = node.start_point[0]
+                    e = node.end_point[0] + 1
+                    if e - s > MAX_CHUNK_LINES:
+                        chunks.extend(_sliding_window(lines, s, e, repo_name, rel, language, github_url_base))
+                    else:
+                        body = "\n".join(lines[s:e]).strip()
+                        if body:
+                            url = f"{github_url_base}/{rel}#L{s+1}-L{e}" if github_url_base else ""
+                            chunks.append({
+                                "repo": repo_name, "file": rel, "language": language,
+                                "start_line": s + 1, "end_line": e,
+                                "text": f"# {repo_name}/{rel} (lines {s+1}-{e})\n\n{body}",
+                                "github_url": url,
+                            })
+                return chunks
+        except Exception:
+            pass
+
+    return _sliding_window(lines, 0, len(lines), repo_name, rel, language, github_url_base)

cortex_local-2.0.8/cortex/core/code_graph.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""Code graph extraction — import/call/inheritance edges, centrality, Louvain communities."""
+
+import json
+import re
+from pathlib import Path
+
+try:
+    import networkx as nx
+    _NX_AVAILABLE = True
+except ImportError:
+    _NX_AVAILABLE = False
+    print("Warning: networkx not installed — graph features disabled")
+
+_IMPORT_RE: dict = {
+    "py": re.compile(r'^(?:from|import)\s+([\w.]+)', re.MULTILINE),
+    "js": re.compile(r'''(?:import|from|require)\s*\(?['"](\.[^'"]+|\$lib/[^'"]+)['"]'''),
+    "ts": re.compile(r'''(?:import|from|require)\s*\(?['"](\.[^'"]+|\$lib/[^'"]+)['"]'''),
+    "kt": re.compile(r'^import\s+([\w.]+)', re.MULTILINE),
+}
+
+_NAMED_IMPORT_RE = re.compile(
+    r'''import\s*\{([^}]+)\}\s*from\s*['"](\.[^'"]+|\$lib/[^'"]+)['"]'''
+)
+_DEFAULT_IMPORT_RE = re.compile(
+    r'''import\s+(\w+)\s+from\s*['"](\.[^'"]+|\$lib/[^'"]+)['"]'''
+)
+_CALL_RE = re.compile(r'\b(\w+)\s*\(')
+
+_TOP_LEVEL_DEF_RE: dict = {
+    "py": re.compile(r'^(?:class|def)\s+(\w+)', re.MULTILINE),
+    "ts": re.compile(r'(?:export\s+)?(?:class|function|const|interface|type)\s+(\w+)'),
+    "kt": re.compile(r'(?:class|fun|object)\s+(\w+)'),
+}
+
+_INHERIT_RE: dict = {
+    "py": re.compile(r'^class\s+\w+\s*\(([^)]+)\)', re.MULTILINE),
+    "ts": re.compile(
+        r'class\s+\w+(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?'
+    ),
+    "kt": re.compile(
+        r'(?:class|interface|object)\s+\w+[^:{]*:\s*([\w,\s()]+?)(?:\{|$)',
+        re.MULTILINE,
+    ),
+}
+
+_LANG_KEY: dict = {
+    ".py": "py", ".js": "js", ".jsx": "js",
+    ".ts": "ts", ".tsx": "ts", ".svelte": "js",
+    ".kt": "kt", ".kts": "kt",
+}
+
+_EDGE_PRIORITY: dict = {"import": 0, "call": 1, "inherits": 2}
+
+_PATH_ALIASES: dict = {
+    "$lib/": "src/lib/",
+}
+
+_PY_SKIP_BASES = frozenset({
+    "object", "ABC", "ABCMeta", "BaseModel", "Exception", "BaseException",
+    "ValueError", "TypeError", "RuntimeError", "str", "int", "float",
+    "list", "dict", "set", "tuple", "Enum", "IntEnum",
+})
+_TS_SKIP_BASES = frozenset({"Error", "EventEmitter", "Component", "React"})
+
+
+def _extract_imports(path: Path, ext: str) -> list:
+    key = _LANG_KEY.get(ext)
+    if not key:
+        return []
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return []
+    return [m.group(1) for m in _IMPORT_RE[key].finditer(src)]
+
+
+def _resolve_import(source_file: str, imp: str, all_files: set, ext: str):
+    for alias, target in _PATH_ALIASES.items():
+        if imp.startswith(alias):
+            imp = target + imp[len(alias):]
+            break
+
+    if imp.startswith("."):
+        base = Path(source_file).parent
+        candidate = (base / imp).as_posix().lstrip("/")
+        for try_ext in (ext, ".ts", ".tsx", ".js", ".jsx", ".svelte"):
+            if candidate + try_ext in all_files:
+                return candidate + try_ext
+            if candidate in all_files:
+                return candidate
+        for idx in ("/index.ts", "/index.js"):
+            if candidate + idx in all_files:
+                return candidate + idx
+        return None
+    elif "/" in imp:
+        for try_ext in (ext, ".ts", ".tsx", ".js", ".jsx", ".svelte"):
+            if imp + try_ext in all_files:
+                return imp + try_ext
+            if imp in all_files:
+                return imp
+        for idx in ("/index.ts", "/index.js"):
+            if imp + idx in all_files:
+                return imp + idx
+        return None
+    else:
+        for f in all_files:
+            stem = f.replace(ext, "").replace("/", ".")
+            if stem == imp or stem.endswith("." + imp):
+                return f
+        return None
+
+
+def _build_symbol_map(repo_path: Path, all_files: set) -> dict:
+    symbol_to_file: dict = {}
+    for rel in all_files:
+        ext = Path(rel).suffix
+        key = _LANG_KEY.get(ext)
+        pat = _TOP_LEVEL_DEF_RE.get(key)
+        if not pat:
+            continue
+        try:
+            src = (repo_path / rel).read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        for m in pat.finditer(src):
+            name = m.group(1)
+            if name not in symbol_to_file:
+                symbol_to_file[name] = rel
+    return symbol_to_file
+
+
+def _extract_named_imports_map(src: str) -> dict:
+    result: dict = {}
+    for m in _NAMED_IMPORT_RE.finditer(src):
+        raw_path = m.group(2)
+        for part in m.group(1).split(","):
+            name = part.strip().split(" as ")[0].strip()
+            if name:
+                result[name] = raw_path
+    for m in _DEFAULT_IMPORT_RE.finditer(src):
+        result[m.group(1)] = m.group(2)
+    return result
+
+
+def _extract_call_targets(path: Path, ext: str, all_files: set, rel: str) -> list:
+    if ext not in (".js", ".jsx", ".ts", ".tsx", ".svelte"):
+        return []
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return []
+    named = _extract_named_imports_map(src)
+    if not named:
+        return []
+    called = {m.group(1) for m in _CALL_RE.finditer(src)}
+    targets: set = set()
+    for name, imp_path in named.items():
+        if name in called:
+            resolved = _resolve_import(rel, imp_path, all_files, ext)
+            if resolved and resolved != rel:
+                targets.add(resolved)
+    return list(targets)
+
+
+def _extract_inheritance_targets(
+    path: Path, ext: str, all_files: set, rel: str, symbol_to_file: dict
+) -> list:
+    key = _LANG_KEY.get(ext)
+    if key not in _INHERIT_RE:
+        return []
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return []
+    targets: set = set()
+    skip = _PY_SKIP_BASES if key == "py" else _TS_SKIP_BASES
+
+    if key == "py":
+        for m in _INHERIT_RE["py"].finditer(src):
+            for base in m.group(1).split(","):
+                base = base.strip().split(".")[0]
+                if base and base not in skip:
+                    t = symbol_to_file.get(base)
+                    if t and t != rel:
+                        targets.add(t)
+    elif key == "ts":
+        for m in _INHERIT_RE["ts"].finditer(src):
+            for grp in (m.group(1), m.group(2)):
+                if not grp:
+                    continue
+                for base in grp.split(","):
+                    base = base.strip().split("<")[0].strip()
+                    if base and base not in skip:
+                        t = symbol_to_file.get(base)
+                        if t and t != rel:
+                            targets.add(t)
+    elif key == "kt":
+        for m in _INHERIT_RE["kt"].finditer(src):
+            for base in m.group(1).split(","):
+                base = re.sub(r'\(.*?\)', '', base).strip()
+                if base and base not in skip:
+                    t = symbol_to_file.get(base)
+                    if t and t != rel:
+                        targets.add(t)
+
+    return list(targets)
+
+
+def _add_edge(G, src: str, dst: str, edge_type: str) -> None:
+    if G.has_edge(src, dst):
+        existing = G[src][dst].get("type", "import")
+        if _EDGE_PRIORITY.get(edge_type, 0) > _EDGE_PRIORITY.get(existing, 0):
+            G[src][dst]["type"] = edge_type
+    else:
+        G.add_edge(src, dst, type=edge_type)
+
+
+def build_code_graph(repo_path: Path, all_files: set):
+    if not _NX_AVAILABLE:
+        return None
+    G = nx.DiGraph()
+    G.add_nodes_from(all_files)
+    symbol_to_file = _build_symbol_map(repo_path, all_files)
+    for rel in all_files:
+        path = repo_path / rel
+        ext = Path(rel).suffix
+        for imp in _extract_imports(path, ext):
+            resolved = _resolve_import(rel, imp, all_files, ext)
+            if resolved and resolved != rel:
+                _add_edge(G, rel, resolved, "import")
+        for target in _extract_call_targets(path, ext, all_files, rel):
+            _add_edge(G, rel, target, "call")
+        for target in _extract_inheritance_targets(path, ext, all_files, rel, symbol_to_file):
+            _add_edge(G, rel, target, "inherits")
+    return G
+
+
+def compute_code_metadata(G) -> dict:
+    if not _NX_AVAILABLE or G is None or len(G) == 0:
+        return {}
+    in_c = nx.in_degree_centrality(G)
+    out_c = nx.out_degree_centrality(G)
+    centrality = {n: round((in_c.get(n, 0) + out_c.get(n, 0)) / 2, 4) for n in G.nodes}
+    undirected = G.to_undirected()
+    communities: dict = {}
+    try:
+        from networkx.algorithms.community import louvain_communities
+        for i, comm in enumerate(louvain_communities(undirected, seed=42)):
+            for node in comm:
+                communities[node] = i
+    except Exception:
+        for i, comp in enumerate(nx.connected_components(undirected)):
+            for node in comp:
+                communities[node] = i
+    return {
+        node: {
+            "centrality": centrality.get(node, 0.0),
+            "community_id": communities.get(node, 0),
+            "imports": [v for _, v in G.out_edges(node)],
+            "imported_by": [u for u, _ in G.in_edges(node)],
+        }
+        for node in G.nodes
+    }
+
+
+def persist_code_graph(G, metadata: dict, repo_name: str, data_dir: Path) -> None:
+    if not _NX_AVAILABLE or G is None:
+        return
+    data_dir.mkdir(parents=True, exist_ok=True)
+    edge_counts = {t: sum(1 for _, _, d in G.edges(data=True) if d.get("type") == t)
+                   for t in ("import", "call", "inherits")}
+    data = {
+        "nodes": [{"id": n, **metadata.get(n, {})} for n in G.nodes],
+        "edges": [
+            {"source": u, "target": v, "type": d.get("type", "import")}
+            for u, v, d in G.edges(data=True)
+        ],
+    }
+    out = data_dir / f"graph_{repo_name}.json"
+    out.write_text(json.dumps(data))
+    print(
+        f"  graph: {len(data['nodes'])} nodes, {len(data['edges'])} edges "
+        f"(import:{edge_counts['import']} call:{edge_counts['call']} "
+        f"inherits:{edge_counts['inherits']}) -> {out.name}"
+    )

cortex_local-2.0.8/cortex/core/global_graph.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Global cross-repo graph — scans root config files for inter-repo references."""
+
+import json
+import re
+from pathlib import Path
+
+try:
+    import networkx as nx
+    _NX_AVAILABLE = True
+except ImportError:
+    _NX_AVAILABLE = False
+
+_CROSS_REPO_CONFIG = {
+    "package.json", "requirements.txt", "go.mod", "pyproject.toml",
+    "Cargo.toml", "docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml",
+}
+_CROSS_REPO_SKIP = {
+    "node_modules", ".git", "dist", "build", ".next", ".svelte-kit",
+    "__pycache__", ".gradle", "target",
+}
+
+
+def _slug_variants(name: str) -> set:
+    return {name, name.replace("-", "_"), name.replace("_", "-")}
+
+
+def _find_cross_repo_refs(src_repo: str, repo_path: Path, other_repos: list) -> dict:
+    if not other_repos:
+        return {}
+    variant_to_repo: dict = {}
+    for r in other_repos:
+        for v in _slug_variants(r):
+            variant_to_repo[v.lower()] = r
+    refs: dict = {}
+
+    def _check(path: Path) -> None:
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace").lower()
+        except Exception:
+            return
+        rel = str(path.relative_to(repo_path))
+        for variant, dst in variant_to_repo.items():
+            if variant in text:
+                refs.setdefault(dst, [])
+                if rel not in refs[dst]:
+                    refs[dst].append(rel)
+
+    for fname in _CROSS_REPO_CONFIG:
+        p = repo_path / fname
+        if p.exists():
+            _check(p)
+    for p in repo_path.glob(".env*"):
+        if p.is_file():
+            _check(p)
+    return refs
+
+
+def build_global_graph(repo_paths: dict, data_dir: Path) -> None:
+    """Build graph_global.json with cross-repo edges. repo_paths = {repo_name: Path}"""
+    if not _NX_AVAILABLE:
+        return
+    repo_names = list(repo_paths.keys())
+    G = nx.DiGraph()
+    G.add_nodes_from(repo_names)
+    for src_repo, repo_path in repo_paths.items():
+        if not repo_path.exists():
+            continue
+        other_repos = [r for r in repo_names if r != src_repo]
+        refs = _find_cross_repo_refs(src_repo, repo_path, other_repos)
+        for dst_repo, files in refs.items():
+            if G.has_edge(src_repo, dst_repo):
+                merged = list(set(G[src_repo][dst_repo].get("files", []) + files))
+                G[src_repo][dst_repo]["files"] = merged
+            else:
+                G.add_edge(src_repo, dst_repo, type="cross-repo", files=files)
+    data_dir.mkdir(parents=True, exist_ok=True)
+    data = {
+        "nodes": [{"id": n} for n in G.nodes],
+        "edges": [
+            {"source": u, "target": v, "type": "cross-repo", "files": d.get("files", [])}
+            for u, v, d in G.edges(data=True)
+        ],
+    }
+    out = data_dir / "graph_global.json"
+    out.write_text(json.dumps(data))
+    print(f"  global graph: {len(repo_names)} repos, {len(data['edges'])} cross-repo edges -> {out.name}")

cortex_local-2.0.8/cortex/core/graph.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""Graph module facade — re-exports all graph building and PPR utilities."""
+
+from .code_graph import build_code_graph, compute_code_metadata, persist_code_graph  # noqa: F401
+from .notes_graph import build_notes_graph, persist_notes_graph, ppr_augment  # noqa: F401
+from .global_graph import build_global_graph  # noqa: F401

cortex_local-2.0.8/cortex/core/notes_graph.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Notes graph — Obsidian wikilink edges and Personalized PageRank augmentation."""
+
+import json
+import re
+from pathlib import Path
+
+try:
+    import networkx as nx
+    _NX_AVAILABLE = True
+except ImportError:
+    _NX_AVAILABLE = False
+    print("Warning: networkx not installed — graph features disabled")
+
+_WIKILINK_RE = re.compile(r'\[\[([^\[\]|#]+?)(?:\|[^\[\]]+)?\]\]')
+
+
+def build_notes_graph(notes_dir: Path):
+    if not _NX_AVAILABLE:
+        return None
+    G = nx.DiGraph()
+    md_files = [
+        p for p in notes_dir.rglob("*.md")
+        if ".obsidian" not in p.parts and ".git" not in p.parts
+    ]
+    stem_to_rel: dict = {}
+    for path in md_files:
+        rel = str(path.relative_to(notes_dir))
+        G.add_node(rel)
+        stem_to_rel[path.stem.lower()] = rel
+    for path in md_files:
+        rel = str(path.relative_to(notes_dir))
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        for m in _WIKILINK_RE.finditer(text):
+            target_stem = m.group(1).lower().split("/")[-1].split(".")[0]
+            target_rel = stem_to_rel.get(target_stem)
+            if target_rel and target_rel != rel:
+                G.add_edge(rel, target_rel, type="wikilink")
+    return G
+
+
+def persist_notes_graph(G, data_dir: Path) -> None:
+    if not _NX_AVAILABLE or G is None:
+        return
+    data_dir.mkdir(parents=True, exist_ok=True)
+    data = {
+        "nodes": [{"id": n, "centrality": 0, "community_id": 0} for n in G.nodes],
+        "edges": [{"source": u, "target": v} for u, v in G.edges],
+    }
+    out = data_dir / "graph_notes.json"
+    out.write_text(json.dumps(data))
+    print(f"  notes graph: {len(data['nodes'])} nodes, {len(data['edges'])} wikilink edges -> {out.name}")
+
+
+def ppr_augment(matched_files: list, scores: list, graph_path: Path, threshold: float = 0.03, _return_reason: bool = False):
+    """Personalized PageRank over wikilink graph seeded from vector-matched notes."""
+    def _ret(results, reason):
+        return (results, reason) if _return_reason else results
+
+    if not _NX_AVAILABLE or not graph_path.exists():
+        return _ret([], "nx_or_missing")
+    try:
+        data = json.loads(graph_path.read_text())
+        G = nx.DiGraph()
+        G.add_nodes_from(
+            n["id"] if isinstance(n, dict) else n
+            for n in data.get("nodes", [])
+        )
+        G.add_edges_from([(e["source"], e["target"]) for e in data.get("edges", [])])
+    except Exception:
+        return _ret([], "exception")
+    if len(G) < 2:
+        return _ret([], "exception")
+    total = sum(scores) or 1.0
+    personalization: dict = {n: 1e-6 for n in G.nodes}
+    for f, s in zip(matched_files, scores):
+        if f in personalization:
+            personalization[f] += s / total
+    norm = sum(personalization.values())
+    personalization = {k: v / norm for k, v in personalization.items()}
+    try:
+        ppr = nx.pagerank(G, alpha=0.85, personalization=personalization, max_iter=100)
+    except Exception:
+        return _ret([], "exception")
+    matched_set = set(matched_files)
+    results = [
+        {"file": node, "ppr_score": round(score, 4)}
+        for node, score in sorted(ppr.items(), key=lambda x: -x[1])
+        if node not in matched_set and score >= threshold
+    ][:5]
+    return _ret(results, "ok" if results else "below_threshold")

{cortex_local-2.0.7 → cortex_local-2.0.8}/cortex/indexer.py

@@ -2,7 +2,6 @@
 
 import hashlib
 import re
-import sys
 from pathlib import Path
 
 from qdrant_client import QdrantClient
@@ -13,17 +12,9 @@ from qdrant_client.models import (
 
 from .config import QDRANT_PATH, DATA_DIR, CACHE_FILE, VECTOR_SIZE
 from .embedder import embed, sparse_embed
-
-# Reuse chunking/graph logic from core
-import sys as _sys
-from pathlib import Path as _Path
-_core = _Path(__file__).parent.parent.parent / "core"
-if str(_core) not in _sys.path:
-    _sys.path.insert(0, str(_core))
-
-from chunker import chunk_file, CODE_EXTS, SKIP_DIRS  # noqa: E402
-from cache import load_cache, save_cache  # noqa: E402
-import graph as _graph  # noqa: E402
+from .core.chunker import chunk_file, CODE_EXTS, SKIP_DIRS
+from .core.cache import load_cache, save_cache
+from .core import graph as _graph
 
 
 def _qdrant() -> QdrantClient:

{cortex_local-2.0.7 → cortex_local-2.0.8}/cortex/mcp_server.py

@@ -51,17 +51,9 @@ def _run_reindex(path_str: str) -> None:
 
 def _ppr_block(matched_files: list, matched_scores: list) -> str | None:
     try:
-        from core.notes_graph import ppr_augment
-    except ImportError:
-        try:
-            import sys
-            from pathlib import Path as _P
-            _core = _P(__file__).parent.parent.parent / "core"
-            if str(_core) not in sys.path:
-                sys.path.insert(0, str(_core))
-            from notes_graph import ppr_augment
-        except Exception:
-            return None
+        from .core.notes_graph import ppr_augment
+    except Exception:
+        return None
     graph_path = DATA_DIR / "graph_notes.json"
     extras, reason = ppr_augment(matched_files, matched_scores, graph_path, _return_reason=True)
     if extras:

{cortex_local-2.0.7 → cortex_local-2.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cortex-local"
-version = "2.0.7"
+version = "2.0.8"
 description = "Local semantic search MCP server — notes + code, embedded Qdrant, fastembed"
 readme = "README.md"
 requires-python = ">=3.11"