cortex-local 2.6.0__tar.gz → 2.7.0__tar.gz

{cortex_local-2.6.0 → cortex_local-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cortex-local
-Version: 2.6.0
+Version: 2.7.0
 Summary: Local semantic search MCP server — notes + code, embedded Qdrant, fastembed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
@@ -10,6 +10,7 @@ Requires-Dist: networkx>=3.0
 Requires-Dist: qdrant-client>=1.17.0
 Requires-Dist: tqdm>=4.0
 Requires-Dist: tree-sitter-c-sharp
+Requires-Dist: tree-sitter-gdscript
 Requires-Dist: tree-sitter-javascript
 Requires-Dist: tree-sitter-kotlin
 Requires-Dist: tree-sitter-python

{cortex_local-2.6.0 → cortex_local-2.7.0}/cortex/core/chunker.py

@@ -6,6 +6,11 @@ import os
 import re as _re
 from pathlib import Path
 
+try:
+    from . import godot as _godot
+except ImportError:  # server: core/ is on sys.path as top-level modules
+    import godot as _godot
+
 _RAZOR_BLOCK_RE = _re.compile(r'@(?:code|functions)\s*\{', _re.IGNORECASE)
 
 
@@ -32,7 +37,8 @@ def _extract_razor_cs_blocks(source: str) -> list:
 
 REPOS_DIR = Path(os.environ.get("REPOS_DIR", "/tmp/repos"))
 
-CODE_EXTS = {".js", ".ts", ".tsx", ".jsx", ".svelte", ".py", ".java", ".go", ".rs", ".css", ".html", ".kt", ".kts", ".gd", ".yml", ".yaml", ".cs", ".razor", ".cshtml"}
+CODE_EXTS = {".js", ".ts", ".tsx", ".jsx", ".svelte", ".py", ".java", ".go", ".rs", ".css", ".html", ".kt", ".kts", ".gd", ".yml", ".yaml", ".cs", ".razor", ".cshtml",
+             ".tscn", ".tres", ".godot", ".gdshader", ".dialogue"}
 SKIP_DIRS = {"node_modules", ".git", "dist", "build", ".next", ".svelte-kit", "__pycache__", ".gradle", "target", "bin", "obj", ".godot"}
 LANG_MAP = {
     ".js": "javascript", ".ts": "typescript", ".tsx": "typescript",
@@ -41,6 +47,8 @@ LANG_MAP = {
     ".kt": "kotlin", ".kts": "kotlin", ".gd": "gdscript",
     ".yml": "yaml", ".yaml": "yaml", ".cs": "csharp",
     ".razor": "razor", ".cshtml": "cshtml",
+    ".tscn": "godot-scene", ".tres": "godot-resource", ".godot": "godot-project",
+    ".gdshader": "gdshader", ".dialogue": "dialogue",
 }
 
 def _is_excluded(rel: str, patterns: list) -> bool:
@@ -297,6 +305,8 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
         rel = path.name
     language = LANG_MAP.get(ext, ext.lstrip("."))
     extra = _extra_tokens(rel, lines)
+    if ext == ".gd":
+        extra = (extra + " " + _godot.gd_context(source_text)).strip()
 
     def _header(rel: str, s: int, e: int, tokens: str) -> str:
         h = f"# {repo_name}/{rel} (lines {s}-{e})\n# {tokens}"
@@ -331,6 +341,29 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
             })
         return chunks
 
+    # Godot scenes/resources/project: index a readable summary, not the raw serialization
+    if ext in _godot.GODOT_SUMMARY_EXTS:
+        summary = _godot.summarize(path, source_text).splitlines()
+        if not summary:
+            return []
+        tokens = _path_tokens(repo_name, rel)
+        n_file = len(lines)
+        windows = [summary[i:i + MAX_CHUNK_LINES] for i in range(0, len(summary), MAX_CHUNK_LINES)]
+        k = len(windows)
+        out = []
+        for i, w in enumerate(windows):
+            # distinct pseudo line ranges per window (chunk ids are keyed on start_line)
+            s_line = 1 + (i * n_file) // k
+            e_line = max(s_line, ((i + 1) * n_file) // k)
+            url = f"{github_url_base}/{rel}#L{s_line}-L{e_line}" if github_url_base else ""
+            out.append({
+                "repo": repo_name, "file": rel, "language": language,
+                "start_line": s_line, "end_line": e_line,
+                "text": f"{_header(rel, s_line, e_line, tokens)}\n\n" + "\n".join(w),
+                "github_url": url,
+            })
+        return out
+
     # Small files: keep as single chunk to avoid diluting path/filename signal
     if len(lines) <= MAX_CHUNK_LINES:
         body = "\n".join(lines).strip()
@@ -371,6 +404,28 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
             if chunks:
                 return chunks
 
+    # GDScript: functions / inner classes / member blocks, annotations kept with their decl
+    if ext == ".gd":
+        spans = _godot.gd_spans(raw)
+        if spans:
+            chunks = []
+            tokens = _path_tokens(repo_name, rel)
+            for s0, e, _kind in spans:
+                if e - s0 > MAX_CHUNK_LINES:
+                    chunks.extend(_sliding_window(lines, s0, e, repo_name, rel, language, github_url_base, extra))
+                    continue
+                body = "\n".join(lines[s0:e]).strip()
+                if body:
+                    url = f"{github_url_base}/{rel}#L{s0+1}-L{e}" if github_url_base else ""
+                    chunks.append({
+                        "repo": repo_name, "file": rel, "language": language,
+                        "start_line": s0 + 1, "end_line": e,
+                        "text": f"{_header(rel, s0+1, e, tokens)}\n\n{body}",
+                        "github_url": url,
+                    })
+            if chunks:
+                return chunks
+
     if _TS_AVAILABLE and ext in _TS_LANGUAGES:
         try:
             parser = _TSParser(_TS_LANGUAGES[ext])

{cortex_local-2.6.0 → cortex_local-2.7.0}/cortex/core/code_graph.py

@@ -8,6 +8,13 @@ from pathlib import Path
 
 log = logging.getLogger("cortex.graph")
 
+try:
+    from . import godot as _godot
+except ImportError:  # server: core/ is on sys.path as top-level modules
+    import godot as _godot
+
+_GODOT_EXTS = (".gd", ".tscn", ".tres", ".godot")
+
 try:
     import networkx as nx
     _NX_AVAILABLE = True
@@ -336,6 +343,17 @@ def build_code_graph(repo_path: Path, all_files: set):
             _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")
+    godot_files = [f for f in all_files if f.endswith(_GODOT_EXTS)]
+    if godot_files:
+        proj = _godot.GodotProject(repo_path, all_files)
+        for rel in godot_files:
+            try:
+                text = (repo_path / rel).read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+            for target, kind in _godot.gd_edges(rel, text, proj):
+                if target in all_files:
+                    _add_edge(G, rel, target, kind)
     return G
 
 

cortex_local-2.7.0/cortex/core/godot.py

@@ -0,0 +1,296 @@
+"""Godot support: GDScript semantic chunks, scene/resource/project summaries, graph edges.
+
+Used by chunker.chunk_file (chunks) and code_graph.build_code_graph (edges). Paths handed in
+and out are repo-relative POSIX; `res://` paths are resolved against the directory that holds
+project.godot (the Godot project root, not necessarily the repo root).
+"""
+
+import re
+from pathlib import Path
+
+try:
+    from tree_sitter import Language, Parser
+    import tree_sitter_gdscript as _tsgd
+    _GD_LANG = Language(_tsgd.language())
+except Exception:  # grammar missing -> chunker falls back to the sliding window
+    _GD_LANG = None
+
+GODOT_SUMMARY_EXTS = {".tscn", ".tres", ".godot"}
+
+# ── res:// / uid:// resolution ───────────────────────────────────────────────
+
+_SECTION_RE = re.compile(r'^\[(\w+)([^\]]*)\]\s*$', re.MULTILINE)
+_ATTR_RE = re.compile(r'(\w+)=("([^"]*)"|[^\s\]]+)')
+
+
+def _attrs(s: str) -> dict:
+    return {m.group(1): (m.group(3) if m.group(3) is not None else m.group(2)) for m in _ATTR_RE.finditer(s)}
+
+
+class GodotProject:
+    """Repo-level Godot context: project roots, autoloads, uid map, class_name map."""
+
+    def __init__(self, repo_path: Path, all_files: set):
+        self.roots = sorted({str(Path(f).parent.as_posix()) for f in all_files if Path(f).name == "project.godot"},
+                            key=len, reverse=True)
+        self.autoloads: dict = {}   # Name -> repo-relative file
+        self.uids: dict = {}        # uid://x -> repo-relative file
+        self.classes: dict = {}     # class_name -> repo-relative file
+        for f in all_files:
+            p = repo_path / f
+            if Path(f).name == "project.godot":
+                for name, target in _parse_autoloads(_read(p)).items():
+                    resolved = self.res(target, f)
+                    if resolved:
+                        self.autoloads[name] = resolved
+            elif f.endswith(".gd"):
+                m = re.search(r'^class_name\s+(\w+)', _read(p), re.MULTILINE)
+                if m:
+                    self.classes.setdefault(m.group(1), f)
+            if f.endswith((".tscn", ".tres")):
+                head = _read(p, 400)
+                m = re.search(r'uid="(uid://[^"]+)"', head.split("\n", 1)[0])
+                if m:
+                    self.uids[m.group(1)] = f
+        # `.uid` twin files (Godot 4.4+): script.gd.uid contains the script's uid
+        for uidfile in repo_path.rglob("*.uid"):
+            try:
+                rel = uidfile.relative_to(repo_path).as_posix()[:-4]
+                if rel in all_files:
+                    self.uids[uidfile.read_text(errors="replace").strip()] = rel
+            except Exception:
+                continue
+
+    def project_root(self, rel: str) -> str:
+        for r in self.roots:
+            if r == "." or rel.startswith(r + "/"):
+                return r
+        return "."
+
+    def res(self, path: str, from_file: str) -> str | None:
+        """res://a/b.gd (or uid://...) -> repo-relative path, None if unknown."""
+        path = path.strip().lstrip("*")
+        if path.startswith("uid://"):
+            return self.uids.get(path)
+        if not path.startswith("res://"):
+            return None
+        root = self.project_root(from_file)
+        tail = path[len("res://"):]
+        return tail if root == "." else f"{root}/{tail}"
+
+
+def _read(p: Path, limit: int | None = None) -> str:
+    try:
+        text = p.read_text(encoding="utf-8", errors="replace")
+        return text[:limit] if limit else text
+    except Exception:
+        return ""
+
+
+def _parse_autoloads(text: str) -> dict:
+    out, in_section = {}, False
+    for line in text.splitlines():
+        s = line.strip()
+        if s.startswith("["):
+            in_section = s == "[autoload]"
+            continue
+        if in_section and "=" in s:
+            k, v = s.split("=", 1)
+            out[k.strip()] = v.strip().strip('"')
+    return out
+
+
+# ── GDScript chunking ────────────────────────────────────────────────────────
+
+_DECL_TYPES = {"signal_statement", "variable_statement", "const_statement", "enum_definition",
+               "export_variable_statement", "onready_variable_statement"}
+
+
+def gd_context(source: str) -> str:
+    """'class_name X extends Y' for embedding headers ('' when the file declares neither)."""
+    cn = re.search(r'^class_name\s+(\w+)', source, re.MULTILINE)
+    ex = re.search(r'^extends\s+(\S+)', source, re.MULTILINE)
+    parts = []
+    if cn:
+        parts.append(f"class_name {cn.group(1)}")
+    if ex:
+        parts.append(f"extends {ex.group(1)}")
+    return " ".join(parts)
+
+
+def gd_spans(raw: bytes) -> list | None:
+    """Top-level semantic spans [(start_line0, end_line_excl, kind)], or None without the grammar.
+
+    Functions and inner classes are their own spans, with preceding annotations (@rpc,
+    @warning_ignore ...) attached. Runs of signals/vars/consts/enums form one 'members' span.
+    """
+    if _GD_LANG is None:
+        return None
+    try:
+        tree = Parser(_GD_LANG).parse(raw)
+    except Exception:
+        return None
+    spans: list = []
+    pending_ann = None   # start line of annotations waiting for their declaration
+    decl = None          # [start, end] of the current members run
+    for node in tree.root_node.children:
+        t = node.type
+        s, e = node.start_point[0], node.end_point[0] + 1
+        if t == "annotation":
+            pending_ann = s if pending_ann is None else pending_ann
+            continue
+        start = pending_ann if pending_ann is not None else s
+        pending_ann = None
+        if t in ("function_definition", "class_definition", "constructor_definition"):
+            if decl:
+                spans.append((decl[0], decl[1], "members")); decl = None
+            spans.append((start, e, "class" if t == "class_definition" else "function"))
+        elif t in _DECL_TYPES:
+            decl = [decl[0], e] if decl else [start, e]
+        # class_name / extends / comments: covered by the header context
+    if decl:
+        spans.append((decl[0], decl[1], "members"))
+    return spans
+
+
+# ── Scene / resource / project summaries (indexed instead of raw text) ──────
+
+def _ext_resources(text: str) -> dict:
+    out = {}
+    for m in _SECTION_RE.finditer(text):
+        if m.group(1) == "ext_resource":
+            a = _attrs(m.group(2))
+            if "id" in a:
+                out[a["id"]] = a.get("path") or a.get("uid", "")
+    return out
+
+
+def _sections(text: str):
+    """Yield (kind, attrs, body_lines) for each [section] in a .tscn/.tres file."""
+    matches = list(_SECTION_RE.finditer(text))
+    for i, m in enumerate(matches):
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        body = text[m.end():end].strip("\n").splitlines()
+        yield m.group(1), _attrs(m.group(2)), body
+
+
+_EXTRES_REF = re.compile(r'ExtResource\(\s*"?([^")\s]+)"?\s*\)')
+_SKIP_VALUE = re.compile(r'^(Packed\w*Array|PoolByteArray|Image)\(')
+
+
+def summarize_tscn(text: str) -> str:
+    ext = _ext_resources(text)
+    lines = ["Godot scene", "Nodes:"]
+    conns = []
+    for kind, a, body in _sections(text):
+        if kind == "node":
+            name, parent = a.get("name", "?"), a.get("parent")
+            path = name if parent is None else (name if parent == "." else f"{parent}/{name}")
+            desc = f"  {path}"
+            if a.get("type"):
+                desc += f" ({a['type']})"
+            inst = _EXTRES_REF.search(a.get("instance", ""))
+            if inst:
+                desc += f" instance={ext.get(inst.group(1), inst.group(1))}"
+            for line in body:
+                if line.startswith("script ="):
+                    ref = _EXTRES_REF.search(line)
+                    if ref:
+                        desc += f" script={ext.get(ref.group(1), ref.group(1))}"
+            lines.append(desc)
+        elif kind == "connection":
+            conns.append(f"  {a.get('from', '?')}.{a.get('signal', '?')} -> {a.get('method', '?')} (on {a.get('to', '?')})")
+    if conns:
+        lines.append("Signal connections:")
+        lines += conns
+    if ext:
+        lines.append("Uses: " + ", ".join(sorted(set(v for v in ext.values() if v))))
+    return "\n".join(lines)
+
+
+def summarize_tres(text: str) -> str:
+    ext = _ext_resources(text)
+    lines = []
+    for kind, a, body in _sections(text):
+        if kind == "gd_resource":
+            head = f"Godot resource type={a.get('type', '?')}"
+            if a.get("script_class"):
+                head += f" script_class={a['script_class']}"
+            lines.append(head)
+        elif kind in ("resource", "sub_resource"):
+            if kind == "sub_resource":
+                lines.append(f"Sub-resource {a.get('type', '')} {a.get('id', '')}".rstrip())
+            for line in body:
+                if "=" not in line:
+                    continue
+                k, v = (x.strip() for x in line.split("=", 1))
+                if _SKIP_VALUE.match(v):
+                    continue
+                v = _EXTRES_REF.sub(lambda m: ext.get(m.group(1), m.group(1)), v)
+                lines.append(f"  {k} = {v[:200]}")
+    if ext:
+        lines.append("Uses: " + ", ".join(sorted(set(v for v in ext.values() if v))))
+    return "\n".join(lines)
+
+
+def summarize_project(text: str) -> str:
+    lines, section, actions = ["Godot project.godot"], "", []
+    for raw in text.splitlines():
+        s = raw.strip()
+        if s.startswith("["):
+            section = s.strip("[]")
+            continue
+        if "=" not in s or s.startswith(";"):
+            continue
+        k, v = (x.strip() for x in s.split("=", 1))
+        if section == "application" and k in ("config/name", "run/main_scene", "config/features"):
+            lines.append(f"{k} = {v}")
+        elif section == "autoload":
+            lines.append(f"autoload {k} = {v.strip(chr(34)).lstrip('*')}")
+        elif section == "input" and not k.startswith(" "):
+            actions.append(k)
+    if actions:
+        lines.append("Input actions: " + ", ".join(actions))
+    return "\n".join(lines)
+
+
+def summarize(path: Path, text: str) -> str:
+    if path.suffix == ".tscn":
+        return summarize_tscn(text)
+    if path.suffix == ".tres":
+        return summarize_tres(text)
+    return summarize_project(text)
+
+
+# ── Graph edges ──────────────────────────────────────────────────────────────
+
+_RES_STR = re.compile(r'"\*?((?:res|uid)://[^"]+)"')
+_LOAD_RE = re.compile(r'\b(?:preload|load|ResourceLoader\.load)\s*\(\s*"((?:res|uid)://[^"]+)"')
+_EXTENDS_RE = re.compile(r'^extends\s+("([^"]+)"|(\w+))', re.MULTILINE)
+_USE_RE = re.compile(r'\b([A-Z]\w*)\s*(?:\.|\(|$)|(?::|\bas|\bis|->)\s*([A-Z]\w*)', re.MULTILINE)
+
+
+def gd_edges(rel: str, text: str, proj: GodotProject) -> list:
+    """[(target, edge_type)] for a .gd / .tscn / .tres / project.godot file."""
+    edges: list = []
+    if rel.endswith(".gd"):
+        m = _EXTENDS_RE.search(text)
+        if m:
+            tgt = proj.res(m.group(2), rel) if m.group(2) else proj.classes.get(m.group(3))
+            if tgt:
+                edges.append((tgt, "inherits"))
+        for m in _LOAD_RE.finditer(text):
+            tgt = proj.res(m.group(1), rel)
+            if tgt:
+                edges.append((tgt, "import"))
+        used = {a or b for a, b in _USE_RE.findall(text)}
+        for name in used:
+            tgt = proj.classes.get(name) or proj.autoloads.get(name)
+            if tgt:
+                edges.append((tgt, "call"))
+    else:  # scenes/resources/project: every res:// reference is a dependency
+        for m in _RES_STR.finditer(text):
+            tgt = proj.res(m.group(1), rel)
+            if tgt:
+                edges.append((tgt, "import"))
+    return [(t, k) for t, k in edges if t != rel]

{cortex_local-2.6.0 → cortex_local-2.7.0}/cortex/mcp_server.py

@@ -369,9 +369,10 @@ def get_neighbors(file: str, repo: str) -> str:
     meta = get_graph_meta(repo)
     if not meta:
         return f"No graph data for '{repo}'. Run reindex() first."
+    file = file.removeprefix("res://")  # Godot paths: res:// is relative to the project root
     file_meta = meta.get(file)
     if file_meta is None:
-        matches = [f for f in meta if file in f]
+        matches = sorted((f for f in meta if f.endswith("/" + file) or file in f), key=len)
         if not matches:
             return f"File '{file}' not found in graph for '{repo}'."
         file = matches[0]

{cortex_local-2.6.0 → cortex_local-2.7.0}/pyproject.toml

@@ -22,6 +22,7 @@ dependencies = [
     "tree-sitter-typescript",
     "tree-sitter-kotlin",
     "tree-sitter-c-sharp",
+    "tree-sitter-gdscript",
 ]
 
 [project.scripts]