contextual-engine 0.9.2__tar.gz → 0.9.4__tar.gz

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextual-engine
-Version: 0.9.2
+Version: 0.9.4
 Summary: Temporal-first local code memory for AI tools via MCP
 Project-URL: Homepage, https://contextuallabs.dev
 Project-URL: Documentation, https://contextuallabs.dev/docs

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/cli/commands/mcp.py

@@ -144,7 +144,7 @@ def mcp_logs(
                 console.print(line, highlight=False, end="")
     except Exception as e:
         print_error(f"Failed to read logs: {e}")
-        return
+        raise typer.Exit(1)
 
     if follow:
         try:

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/cli/commands/stats.py

@@ -22,7 +22,6 @@ from contextual.security.sanitize import sql_str_literal
 @require_config
 @require_index
 async def stats(
-    path: str = typer.Option(".", "--path", "-p", help="Repository path"),
     temporal: bool = typer.Option(False, "--temporal", "-t", help="Show temporal stats"),
     graph: bool = typer.Option(False, "--graph", "-g", help="Show graph stats"),
     show_all: bool = typer.Option(False, "--all", "-a", help="Show all stats"),

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/config/global_/mcp_config.py

@@ -50,6 +50,15 @@ class DaemonConfig(BaseModel):
     compaction_interval_hours: float = 6.0   # How often the background loop runs (0 disables)
     compaction_retention_hours: float = 1.0  # Prune versions older than this; never 0 (breaks concurrent writes)
 
+    # Heap / memory trimmer
+    # When the daemon's physical footprint exceeds heap_trim_threshold_mb a
+    # hard trim fires (GC + malloc page return). If the footprint is still over
+    # the threshold on the next tick and no sessions are active, models are
+    # offloaded to CPU to recover MPS/GPU pages. Set to 0 to disable.
+    heap_monitor_enabled: bool = True
+    heap_monitor_interval_seconds: int = 30
+    heap_trim_threshold_mb: int = 2500
+
     # Logging
     log_level: str = "INFO"
 

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/core/models.py

@@ -98,7 +98,14 @@ class FactSource(StrEnum):
 class Language(StrEnum):
     """Supported programming languages for indexing.
 
-    Week 1 MVP: Python, TypeScript, JavaScript, Go, Java, Rust, C#
+    Each value MUST equal the tree-sitter language name used by
+    ``contextual.indexing.chunker.LANGUAGE_MAP`` (the string handed to
+    ``tree_sitter_language_pack.get_parser``). The chunker maps a file
+    extension to that name; ``_build_chunk`` then does ``Language(name)``.
+    Any name present in ``LANGUAGE_MAP`` but absent here silently casts to
+    ``Language.PYTHON`` — mislabelling the chunk and breaking language
+    filtering. Keep the two in lockstep. ``c_sharp`` is the sole divergence
+    (enum value ``csharp``) and is bridged by ``chunker._TS_TO_LANG``.
     """
 
     PYTHON = "python"
@@ -109,12 +116,53 @@ class Language(StrEnum):
     JAVA = "java"
     RUST = "rust"
     CSHARP = "csharp"
+    # C family
+    C = "c"
+    CPP = "cpp"
+    # JVM / mobile
+    KOTLIN = "kotlin"
+    SWIFT = "swift"
+    SCALA = "scala"
+    DART = "dart"
+    # Scripting
+    RUBY = "ruby"
+    PHP = "php"
+    LUA = "lua"
+    PERL = "perl"
+    R = "r"
+    BASH = "bash"
+    # Functional / emerging
+    HASKELL = "haskell"
+    ELIXIR = "elixir"
     # Config formats (free wins)
     JSON = "json"
     YAML = "yaml"
     TOML = "toml"
     MARKDOWN = "markdown"
     DOCKERFILE = "dockerfile"
+    # Data / schema / infra
+    SQL = "sql"
+    HCL = "hcl"
+    PROTO = "proto"
+    # Web frontend
+    HTML = "html"
+    CSS = "css"
+    SCSS = "scss"
+    # JVM / enterprise
+    GROOVY = "groovy"
+    # Systems / emerging
+    NIM = "nim"
+    ZIG = "zig"
+    V = "v"
+    # Functional
+    ELM = "elm"
+    OCAML = "ocaml"
+    ERLANG = "erlang"
+    # Scientific
+    JULIA = "julia"
+    # Platform / Web3
+    OBJC = "objc"
+    SOLIDITY = "solidity"
 
 
 class ModelType(StrEnum):

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/graph/extractor.py

@@ -152,6 +152,103 @@ AST_ENTITY_NODES: dict[str, dict[str, set[str]]] = {
         "enum": {"enum_declaration"},
         "import": {"using_directive"},
     },
+    "c": {
+        "function": {"function_definition"},
+        "class": {"struct_specifier"},  # C structs model as class-like
+        "enum": {"enum_specifier"},
+        "type": {"type_definition"},
+        "import": {"preproc_include"},
+    },
+    "cpp": {
+        "function": {"function_definition"},
+        "class": {"class_specifier", "struct_specifier"},
+        "enum": {"enum_specifier"},
+        "import": {"preproc_include"},
+    },
+    "swift": {
+        "class": {"class_declaration"},  # covers class/struct/enum/extension
+        "function": {"function_declaration"},  # -> method when nested
+        "interface": {"protocol_declaration"},
+    },
+    "kotlin": {
+        "class": {"class_declaration", "object_declaration"},
+        "function": {"function_declaration"},  # -> method when nested
+    },
+    "ruby": {
+        "class": {"class", "module"},
+        "method": {"method", "singleton_method"},
+    },
+    "php": {
+        "class": {"class_declaration"},
+        "function": {"function_definition"},
+        "method": {"method_declaration"},
+        "interface": {"interface_declaration"},
+        "import": {"namespace_use_declaration"},
+    },
+    "bash": {
+        "function": {"function_definition"},
+    },
+    # ── Data / schema / infra ─────────────────────────────────────────────
+    "proto": {
+        "class": {"message_declaration"},
+        "interface": {"service_declaration"},
+        "enum": {"enum_declaration"},
+    },
+    "hcl": {
+        "class": {"block"},  # resource/module/data blocks modelled as class-like
+    },
+    # ── JVM / enterprise ──────────────────────────────────────────────────
+    "groovy": {
+        "class": {"class_declaration"},
+        "method": {"method_declaration"},
+    },
+    # ── Systems / emerging ────────────────────────────────────────────────
+    "nim": {
+        "function": {"proc_declaration", "func_declaration"},
+        "type": {"type_declaration"},
+    },
+    "zig": {
+        "function": {"function_declaration"},
+        "class": {"container_declaration"},
+    },
+    "v": {
+        "function": {"fn_declaration"},
+        "class": {"struct_declaration"},
+        "interface": {"interface_declaration"},
+    },
+    # ── Functional ────────────────────────────────────────────────────────
+    "elm": {
+        "function": {"value_declaration"},
+        "type": {"type_alias_declaration", "type_declaration"},
+    },
+    "ocaml": {
+        "function": {"let_binding"},
+        "type": {"type_definition"},
+        "module": {"module_definition"},
+    },
+    "erlang": {
+        "function": {"function_clause"},
+        "type": {"type_declaration"},
+    },
+    # ── Scientific ────────────────────────────────────────────────────────
+    "julia": {
+        "function": {"function_definition"},
+        "class": {"struct_definition", "abstract_definition"},
+    },
+    # ── Platform / Web3 ──────────────────────────────────────────────────
+    "objc": {
+        "function": {"function_definition"},
+        "method": {"method_declaration"},
+        "interface": {"objc_interface_declaration"},
+        "class": {"objc_implementation_declaration"},
+        "import": {"preproc_include"},
+    },
+    "solidity": {
+        "class": {"contract_declaration"},
+        "function": {"function_definition"},
+        "interface": {"interface_declaration"},
+        "enum": {"enum_declaration"},
+    },
 }
 
 # Scope boundary node kinds per language — push/pop the FQN scope stack on these.
@@ -164,6 +261,31 @@ SCOPE_BOUNDARY_NODES: dict[str, set[str]] = {
     "java": {"class_declaration", "interface_declaration", "enum_declaration"},
     "rust": {"struct_item", "impl_item", "trait_item", "enum_item"},
     "c_sharp": {"class_declaration", "interface_declaration", "namespace_declaration"},
+    "c": {"struct_specifier"},
+    "cpp": {"class_specifier", "struct_specifier", "namespace_definition"},
+    "swift": {"class_declaration", "protocol_declaration"},
+    "kotlin": {"class_declaration", "object_declaration"},
+    "ruby": {"class", "module"},
+    "php": {"class_declaration", "interface_declaration", "trait_declaration"},
+    "bash": set(),
+    # ── Data / schema / infra ─────────────────────────────────────────────
+    "proto": {"message_declaration", "service_declaration"},
+    "hcl": {"block"},
+    # ── JVM / enterprise ──────────────────────────────────────────────────
+    "groovy": {"class_declaration"},
+    # ── Systems / emerging ────────────────────────────────────────────────
+    "nim": {"type_declaration"},
+    "zig": {"container_declaration"},
+    "v": {"struct_declaration", "interface_declaration"},
+    # ── Functional ────────────────────────────────────────────────────────
+    "elm": set(),
+    "ocaml": {"module_definition"},
+    "erlang": set(),
+    # ── Scientific ────────────────────────────────────────────────────────
+    "julia": {"struct_definition", "abstract_definition"},
+    # ── Platform / Web3 ──────────────────────────────────────────────────
+    "objc": {"objc_interface_declaration", "objc_implementation_declaration"},
+    "solidity": {"contract_declaration"},
 }
 
 # Call-expression node kinds per language.
@@ -176,10 +298,32 @@ CALL_NODES: dict[str, set[str]] = {
     "java": {"method_invocation"},
     "rust": {"call_expression"},
     "c_sharp": {"invocation_expression"},
+    "c": {"call_expression"},
+    "cpp": {"call_expression"},
+    "swift": {"call_expression"},
+    "kotlin": {"call_expression"},
+    "ruby": {"call", "method_call"},
+    "php": {"function_call_expression", "member_call_expression", "scoped_call_expression"},
+    "bash": {"command"},
+    # ── JVM / enterprise ──────────────────────────────────────────────────
+    "groovy": {"method_call", "call_expression"},
+    # ── Systems / emerging ────────────────────────────────────────────────
+    "nim": {"call"},
+    "zig": {"call_expression"},
+    "v": {"call_expression"},
+    # ── Functional ────────────────────────────────────────────────────────
+    "elm": {"function_call_expr"},
+    "ocaml": {"application_expression"},
+    "erlang": {"call"},
+    # ── Scientific ────────────────────────────────────────────────────────
+    "julia": {"call_expression"},
+    # ── Platform / Web3 ──────────────────────────────────────────────────
+    "objc": {"call_expression"},
+    "solidity": {"call_expression"},
 }
 
 # Languages where a top-level "function" node nested inside a scope is a method.
-_METHOD_WHEN_NESTED = {"python", "rust"}
+_METHOD_WHEN_NESTED = {"python", "rust", "swift", "kotlin", "cpp", "groovy", "julia", "solidity"}
 
 
 def init_worker() -> None:
@@ -347,6 +491,26 @@ def _node_name(node: Any, source_bytes: bytes) -> str | None:
             ):
                 ident = child
                 break
+    # C / C++ functions carry the name under a `declarator` field rather than a
+    # `name` field: function_definition → function_declarator → identifier. Walk
+    # down the declarator chain (handles pointer/reference wrappers too) to find
+    # the leaf identifier. Bounded depth to stay safe on pathological trees.
+    if ident is None:
+        cursor = node.child_by_field_name("declarator")
+        for _ in range(6):
+            if cursor is None:
+                break
+            if cursor.kind() in ("identifier", "field_identifier"):
+                ident = cursor
+                break
+            inner = cursor.child_by_field_name("declarator")
+            if inner is None:
+                for child in _children(cursor):
+                    if child.kind() in ("identifier", "field_identifier"):
+                        ident = child
+                        break
+                break
+            cursor = inner
     if ident is None:
         return None
     name = _text(ident, source_bytes).lstrip("*")  # Go pointer receivers

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/graph/integrator.py

@@ -32,6 +32,24 @@ GRAPH_CONTEXT_RATIO = 0.15  # 15% graph context, 85% chunk results
 _MAX_SEED_ENTITIES = 5  # cap seed entities per query for latency
 _MAX_LABEL_LOOKUP = 200
 
+# Structural edges followed by default during search-time nexus expansion.
+# co_changes_with is deliberately excluded: it is ~85% of all edges (historical
+# correlation, not a hard dependency) and traversing it explodes the BFS frontier
+# — inflating latency AND diluting the structural context an AI actually needs
+# (callers/callees/imports/inheritance). The dedicated co_change_analysis tool
+# surfaces coupling when it's genuinely wanted. authored_by/supersedes are
+# provenance/version edges, not structure. Mirrors the filter already applied in
+# contextual.mcp.tools.graph.
+STRUCTURAL_PREDICATES: list[str] = [
+    "calls",
+    "imports",
+    "defines",
+    "references",
+    "inherits_from",
+    "implements",
+    "uses",
+]
+
 
 @dataclass
 class NexusNode:
@@ -360,6 +378,13 @@ class GraphIntegrator:
         if not seed_entity_ids:
             return []
 
+        # Default to structural traversal only. Without this, predicates=None
+        # follows every edge type — including co_changes_with (~85% of the graph)
+        # — which both slows the BFS and buries real structural context. Callers
+        # that genuinely want correlation edges pass an explicit predicate list.
+        if predicates is None:
+            predicates = STRUCTURAL_PREDICATES
+
         depth = max(1, min(depth, 5))  # clamp to valid range
         node_budget = _DEPTH_BUDGETS.get(depth, 100)
 

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/graph/resolver.py

@@ -284,11 +284,21 @@ def _resolve_inheritance(
     else as ``inherits_from``.
     """
     simple = base.split(".")[-1]
+    head = base.split(".")[0]
     target = local_by_name.get(simple)
     confidence = 0.90
     if not target and registry.is_unique(simple):
         target = registry.lookup_name(simple)[0]
         confidence = 0.85 if simple in imported_names or base in imported_names else 0.75
+    # Ambiguous global fallback (0.55) — only when import-attested, mirroring
+    # _resolve_call. Cross-file inheritance from a base whose simple name is not
+    # unique (e.g. several `Base`/`Config` classes) was previously dropped
+    # entirely; recover it deterministically when the import vouches for it.
+    if not target and (head in imported_names or simple in imported_names):
+        candidates = [c for c in registry.lookup_name(simple) if c != subject_id]
+        if candidates:
+            target = candidates[0]
+            confidence = CONFIDENCE_FLOOR
     if not target or target == subject_id:
         return None
     predicate = "implements" if entity_type == "interface" else "inherits_from"

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/incremental/file_watcher.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import asyncio
+import ctypes
+import gc
 import time
 from pathlib import Path
 from threading import Lock
@@ -26,6 +28,31 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+def _post_index_trim() -> None:
+    """Reclaim transient allocations after a single-file index job.
+
+    Each embedding run leaves ~200-600 MB of freed PyArrow/LanceDB pages that
+    macOS will not return to the OS without an explicit hint. Calling this after
+    every file keeps the footprint flat across a multi-file push event instead
+    of letting allocations stack into a multi-GB spike.
+    """
+    gc.collect()
+    try:
+        import pyarrow as pa
+        pa.default_memory_pool().release_unused()
+    except Exception:
+        pass
+    try:
+        ctypes.CDLL("libSystem.B.dylib").malloc_zone_pressure_relief(
+            None, ctypes.c_size_t(0)
+        )
+    except Exception:
+        try:
+            ctypes.CDLL(None).malloc_trim(0)
+        except Exception:
+            pass
+
+
 class _DocsPipelineProtocol(Protocol):
     def index_file(self, path: Path) -> None: ...
 
@@ -152,6 +179,10 @@ class DebouncedFileWatcher(FileSystemEventHandler):
                     duration_ms=duration_ms,
                 )
 
+                # Reclaim transient PyArrow/LanceDB buffers immediately after each
+                # file so they don't accumulate across a multi-file push event.
+                await asyncio.to_thread(_post_index_trim)
+
                 changed = any(abs(v) > 0 for v in stats.values())
                 if changed and self._on_indexed is not None:
                     try:

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/incremental/incremental_indexer.py

@@ -191,6 +191,14 @@ class IncrementalIndexer:
         logger.info("File changed, re-indexing", path=str(file_path))
         result = await self.pipeline.index_single_file(file_path)
 
+        # Expire the per-workspace FunctionRegistry cache so the next graph
+        # resolution pass sees freshly-indexed entities rather than stale ones.
+        try:
+            from contextual.graph.resolver import invalidate_registry_cache
+            invalidate_registry_cache(self.pipeline.workspace_id)
+        except Exception:
+            pass
+
         if hash_bytes:
             await self.provider.upsert_file_state(
                 self.pipeline.workspace_id,

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/indexing/chunker.py

@@ -33,6 +33,11 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
+# tree-sitter language names that don't match Language enum values
+_TS_TO_LANG: dict[str, Language] = {
+    "c_sharp": Language.CSHARP,
+}
+
 # Chunking parameters from TECHNICAL_SPEC §6
 TARGET_CHUNK_BYTES = 1500
 MAX_CHUNK_BYTES = 2000
@@ -91,6 +96,34 @@ LANGUAGE_MAP = {
     "Dockerfile": "dockerfile",
     # ── Documentation ─────────────────────────────────────────────────────
     ".md": "markdown",
+    # ── Data / schema / infra ─────────────────────────────────────────────
+    ".sql": "sql",
+    ".tf": "hcl",
+    ".hcl": "hcl",
+    ".tfvars": "hcl",
+    ".proto": "proto",
+    # ── Web frontend ──────────────────────────────────────────────────────
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    # ── JVM / enterprise ──────────────────────────────────────────────────
+    ".groovy": "groovy",
+    # ── Systems / emerging ────────────────────────────────────────────────
+    ".nim": "nim",
+    ".zig": "zig",
+    ".v": "v",
+    # ── Functional ────────────────────────────────────────────────────────
+    ".elm": "elm",
+    ".ml": "ocaml",
+    ".mli": "ocaml",
+    ".erl": "erlang",
+    ".hrl": "erlang",
+    # ── Scientific ────────────────────────────────────────────────────────
+    ".jl": "julia",
+    # ── Platform / Web3 ──────────────────────────────────────────────────
+    ".m": "objc",
+    ".sol": "solidity",
 }
 
 # Top-level node types per language (from TECHNICAL_SPEC §6.1)
@@ -126,6 +159,52 @@ TOP_LEVEL_NODES = {
         "trait_item",
     },
     "c_sharp": {"class_declaration", "method_declaration", "interface_declaration"},
+    # ── C family ──────────────────────────────────────────────────────────
+    "c": {"function_definition", "struct_specifier", "enum_specifier", "type_definition"},
+    "cpp": {
+        "function_definition",
+        "class_specifier",
+        "struct_specifier",
+        "namespace_definition",
+        "enum_specifier",
+        "template_declaration",
+    },
+    # ── JVM / mobile ──────────────────────────────────────────────────────
+    "kotlin": {"function_declaration", "class_declaration", "object_declaration"},
+    "swift": {"function_declaration", "class_declaration", "protocol_declaration"},
+    # ── Scripting ─────────────────────────────────────────────────────────
+    "ruby": {"method", "class", "module", "singleton_method"},
+    "php": {
+        "function_definition",
+        "method_declaration",
+        "class_declaration",
+        "interface_declaration",
+        "trait_declaration",
+    },
+    "bash": {"function_definition"},
+    # ── Data / schema / infra ─────────────────────────────────────────────
+    "sql": {"statement"},
+    "hcl": {"block", "attribute"},
+    "proto": {"message_declaration", "enum_declaration", "service_declaration"},
+    # ── Web frontend (no fine-grained AST boundaries needed) ──────────────
+    "css": {"rule_set", "keyframes_statement", "at_rule"},
+    "scss": {"rule_set", "function_statement", "mixin_statement", "include_statement"},
+    # html falls back to line-based splitting — no structural boundary needed
+    # ── JVM / enterprise ──────────────────────────────────────────────────
+    "groovy": {"method_declaration", "class_declaration"},
+    # ── Systems / emerging ────────────────────────────────────────────────
+    "nim": {"proc_declaration", "func_declaration", "type_declaration"},
+    "zig": {"function_declaration"},
+    "v": {"fn_declaration", "struct_declaration"},
+    # ── Functional ────────────────────────────────────────────────────────
+    "elm": {"value_declaration", "type_alias_declaration", "type_declaration"},
+    "ocaml": {"let_binding", "type_definition", "module_definition"},
+    "erlang": {"function_clause"},
+    # ── Scientific ────────────────────────────────────────────────────────
+    "julia": {"function_definition", "struct_definition", "abstract_definition"},
+    # ── Platform / Web3 ──────────────────────────────────────────────────
+    "objc": {"function_definition", "method_declaration"},
+    "solidity": {"contract_declaration", "function_definition", "struct_declaration"},
 }
 
 
@@ -563,6 +642,23 @@ class ASTChunker:
                 )
         return None
 
+    def _get_decorators(self, node: "Node") -> list[str]:
+        """Extract decorator text for a function/class node (Python only)."""
+        if self.language != "python":
+            return []
+        parent = node.parent()
+        if parent is None or parent.kind() != "decorated_definition":
+            return []
+        decorators = []
+        for i in range(parent.child_count()):
+            child = parent.child(i)
+            if child.kind() == "decorator":
+                text = self.content[child.start_byte() : child.end_byte()].decode(
+                    "utf-8", errors="replace"
+                ).strip()
+                decorators.append(text)
+        return decorators
+
     def _build_header(self, header_lines: list[str]) -> str:
         header = "\n".join(header_lines)
         if len(header) <= MAX_HEADER_BYTES:
@@ -612,8 +708,11 @@ class ASTChunker:
             header_lines.append("none")
 
         header_lines.append("DECORATORS:")
-        # TODO: Extract decorators per node
-        header_lines.append("none")
+        decorators = self._get_decorators(parsed_node.node)
+        if decorators:
+            header_lines.extend(decorators)
+        else:
+            header_lines.append("none")
         header_lines.append("-----")
 
         header = self._build_header(header_lines)
@@ -630,9 +729,9 @@ class ASTChunker:
         # Extract symbol name from node
         symbol_name = self._extract_symbol_name(parsed_node.node)
 
-        # Map language to enum
+        # Map language to enum (tree-sitter names like "c_sharp" diverge from enum values)
         try:
-            language_enum = Language(self.language)
+            language_enum = _TS_TO_LANG.get(self.language) or Language(self.language)
         except ValueError:
             language_enum = Language.PYTHON  # Fallback
 
@@ -685,9 +784,9 @@ class ASTChunker:
         full_text = f"{header}\n{body}"
         content_hash = blake3.blake3(full_text.encode("utf-8")).hexdigest()
 
-        # Map language to enum
+        # Map language to enum (tree-sitter names like "c_sharp" diverge from enum values)
         try:
-            language_enum = Language(self.language)
+            language_enum = _TS_TO_LANG.get(self.language) or Language(self.language)
         except ValueError:
             language_enum = Language.PYTHON  # Fallback
 

{contextual_engine-0.9.2 → contextual_engine-0.9.4}/contextual/indexing/symbol_extractor.py

@@ -20,7 +20,11 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
-# Language to Tree-sitter language name mapping
+# Language to Tree-sitter language name mapping.
+# Languages without a dedicated visitor below route to _extract_generic_symbols
+# (returns []) — they still get full chunking + graph entities, just no entries
+# in the symbols table. Keep the tree-sitter names in sync with
+# chunker.LANGUAGE_MAP so a shared parse can be reused.
 LANGUAGE_MAPPING = {
     Language.PYTHON: "python",
     Language.TYPESCRIPT: "typescript",
@@ -30,6 +34,43 @@ LANGUAGE_MAPPING = {
     Language.GO: "go",
     Language.JAVA: "java",
     Language.CSHARP: "c_sharp",
+    Language.C: "c",
+    Language.CPP: "cpp",
+    Language.KOTLIN: "kotlin",
+    Language.SWIFT: "swift",
+    Language.SCALA: "scala",
+    Language.DART: "dart",
+    Language.RUBY: "ruby",
+    Language.PHP: "php",
+    Language.LUA: "lua",
+    Language.PERL: "perl",
+    Language.R: "r",
+    Language.BASH: "bash",
+    Language.HASKELL: "haskell",
+    Language.ELIXIR: "elixir",
+    # Data / schema / infra
+    Language.SQL: "sql",
+    Language.HCL: "hcl",
+    Language.PROTO: "proto",
+    # Web frontend
+    Language.HTML: "html",
+    Language.CSS: "css",
+    Language.SCSS: "scss",
+    # JVM / enterprise
+    Language.GROOVY: "groovy",
+    # Systems / emerging
+    Language.NIM: "nim",
+    Language.ZIG: "zig",
+    Language.V: "v",
+    # Functional
+    Language.ELM: "elm",
+    Language.OCAML: "ocaml",
+    Language.ERLANG: "erlang",
+    # Scientific
+    Language.JULIA: "julia",
+    # Platform / Web3
+    Language.OBJC: "objc",
+    Language.SOLIDITY: "solidity",
 }