codecortex 0.17.0__tar.gz → 0.18.0__tar.gz

{codecortex-0.17.0/src/codecortex.egg-info → codecortex-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.17.0
+Version: 0.18.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -279,7 +279,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.16.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.18.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
@@ -396,7 +396,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel prompt [project_root] [--agent auto\|claude\|codex\|gemini\|zed] [--fresh] [--deep]` | Print a paste-to-your-agent setup prompt; probes health and emits only the outstanding steps (or "just restart me" when already healthy). `--fresh` = the full sequence from `pip install`, to send a friend |
-| `codeintel index [project_root]` | Index a project for semantic search |
+| `codeintel index [project_root] [--quiet]` | Index a repo (semantic embeddings + best-effort graph & map refresh), with a live progress display; `--quiet` prints only the result line |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
 | `codeintel query --op OP --target TARGET [--engine auto] [--project-root DIR] [--json]` | Run a single query and print the result |
@@ -404,7 +404,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
 | `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
-| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
+| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear this repo's index — **both** semantic and graph — so it's as if never indexed; `--all` wipes every repo. Recovers from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
 Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
@@ -444,7 +444,7 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
-| `CODEINTEL_HOME` | Where the index cache lives (default `~/.codeintel`). Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
+| `CODEINTEL_HOME` | Where per-machine state lives (default `~/.codeintel`) — the index cache, the global `config.toml`, and `auth.toml`. Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
 
 ## Privacy & dependencies
 

{codecortex-0.17.0 → codecortex-0.18.0}/README.md

@@ -242,7 +242,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.16.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.18.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
@@ -359,7 +359,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel prompt [project_root] [--agent auto\|claude\|codex\|gemini\|zed] [--fresh] [--deep]` | Print a paste-to-your-agent setup prompt; probes health and emits only the outstanding steps (or "just restart me" when already healthy). `--fresh` = the full sequence from `pip install`, to send a friend |
-| `codeintel index [project_root]` | Index a project for semantic search |
+| `codeintel index [project_root] [--quiet]` | Index a repo (semantic embeddings + best-effort graph & map refresh), with a live progress display; `--quiet` prints only the result line |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
 | `codeintel query --op OP --target TARGET [--engine auto] [--project-root DIR] [--json]` | Run a single query and print the result |
@@ -367,7 +367,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
 | `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
-| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
+| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear this repo's index — **both** semantic and graph — so it's as if never indexed; `--all` wipes every repo. Recovers from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
 Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
@@ -407,7 +407,7 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
-| `CODEINTEL_HOME` | Where the index cache lives (default `~/.codeintel`). Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
+| `CODEINTEL_HOME` | Where per-machine state lives (default `~/.codeintel`) — the index cache, the global `config.toml`, and `auth.toml`. Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
 
 ## Privacy & dependencies
 

{codecortex-0.17.0 → codecortex-0.18.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.17.0
+Version: 0.18.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -279,7 +279,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.16.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.18.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
@@ -396,7 +396,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel prompt [project_root] [--agent auto\|claude\|codex\|gemini\|zed] [--fresh] [--deep]` | Print a paste-to-your-agent setup prompt; probes health and emits only the outstanding steps (or "just restart me" when already healthy). `--fresh` = the full sequence from `pip install`, to send a friend |
-| `codeintel index [project_root]` | Index a project for semantic search |
+| `codeintel index [project_root] [--quiet]` | Index a repo (semantic embeddings + best-effort graph & map refresh), with a live progress display; `--quiet` prints only the result line |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
 | `codeintel query --op OP --target TARGET [--engine auto] [--project-root DIR] [--json]` | Run a single query and print the result |
@@ -404,7 +404,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
 | `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
-| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
+| `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear this repo's index — **both** semantic and graph — so it's as if never indexed; `--all` wipes every repo. Recovers from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
 Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
@@ -444,7 +444,7 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
-| `CODEINTEL_HOME` | Where the index cache lives (default `~/.codeintel`). Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
+| `CODEINTEL_HOME` | Where per-machine state lives (default `~/.codeintel`) — the index cache, the global `config.toml`, and `auth.toml`. Set this when the process has **no resolvable home directory** — a container running as a UID with no passwd entry and no `$HOME`, which is common when an agent runs in one. Without it, `Path.home()` raises and every command fails somewhere far from the cause. |
 
 ## Privacy & dependencies
 

{codecortex-0.17.0 → codecortex-0.18.0}/src/codecortex.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ src/codeintel/mapper.py
 src/codeintel/metrics.py
 src/codeintel/onboarding.py
 src/codeintel/outcome.py
+src/codeintel/paths.py
 src/codeintel/policy.py
 src/codeintel/progress.py
 src/codeintel/provider.py
@@ -104,11 +105,14 @@ tests/test_model_dimension.py
 tests/test_never_raise.py
 tests/test_onboarding.py
 tests/test_rbac.py
+tests/test_redaction_boundary.py
 tests/test_reindexer.py
 tests/test_rerank.py
 tests/test_reset.py
 tests/test_semantic_provider.py
 tests/test_source_kind.py
+tests/test_staleness.py
+tests/test_symbol_context.py
 tests/test_term.py
 tests/test_treesitter.py
 tests/test_verify.py

codecortex-0.18.0/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0"

{codecortex-0.17.0 → codecortex-0.18.0}/src/codeintel/auth.py

@@ -26,6 +26,7 @@ import os
 import pathlib
 import tomllib  # stdlib on Python 3.11+ (the project's minimum)
 
+from codeintel.paths import codeintel_home
 from codeintel.policy import TieringPolicy
 
 logger = logging.getLogger("codeintel")
@@ -78,7 +79,13 @@ def _auth_config_path() -> pathlib.Path | None:
     if env:
         p = pathlib.Path(env)
         return p if p.is_file() else None
-    default = pathlib.Path.home() / ".codeintel" / "auth.toml"
+    try:
+        default = codeintel_home() / "auth.toml"
+    except Exception:
+        # No CODEINTEL_HOME and no resolvable home. `load_auth` promises never to raise, and its
+        # whole contract is "absent config → auth disabled"; a host with nowhere to look is the
+        # absent case, not a crash. (Previously this read `Path.home()` inline and raised.)
+        return None
     return default if default.is_file() else None
 
 

{codecortex-0.17.0 → codecortex-0.18.0}/src/codeintel/config.py

@@ -4,6 +4,8 @@ import logging
 import pathlib
 import tomllib  # stdlib since 3.11, which is this package's floor
 
+from codeintel.paths import codeintel_home
+
 logger = logging.getLogger("codeintel")
 
 _DEFAULTS: dict = {
@@ -18,7 +20,12 @@ _DEFAULTS: dict = {
     "model": "BAAI/bge-small-en-v1.5",
     "chunk_strategy": "syntax",  # syntax-aware (def/class boundaries) vs fixed line windows
     "rerank": "on",              # hybrid lexical+semantic rerank of search results
-    "rerank_candidates": 30,     # cosine candidates fused/re-ranked before returning top-k
+    # Cosine candidates retrieved, fused and re-ranked before the top-k is returned. Was 30, but
+    # the semantic provider hardcoded its own `_display_k * 6` widening that overrode it, so the
+    # effective breadth has always been 60; 30 only ever described behaviour the code didn't have.
+    # The provider now honours this key, so the default is set to the value that was really in use
+    # — otherwise "fixing" the wiring would have silently narrowed everyone's retrieval by half.
+    "rerank_candidates": 60,
 }
 
 # Values restricted to a fixed set — anything else falls back to the default.
@@ -80,12 +87,27 @@ def _coerce(cfg: dict) -> dict:
     return out
 
 
+def _global_config() -> dict:
+    """The machine-wide ``config.toml``, or ``{}`` when there isn't one.
+
+    Resolving the directory can RAISE (no ``CODEINTEL_HOME`` and no resolvable home — a container
+    UID with no passwd entry). That used to propagate straight out of ``load_config``: the call
+    read ``pathlib.Path.home()`` inline, so it blew up before ``_read_toml``'s handler could see
+    it, and every query on such a host died as an opaque ``provider-error``. "There is nowhere to
+    look for a global config" is not an error — it means there is no global config."""
+    try:
+        return _read_toml(codeintel_home() / "config.toml")
+    except Exception as exc:
+        logger.debug("no resolvable config directory (%s) — using defaults + project config", exc)
+        return {}
+
+
 def load_config(project_root: str | None = None) -> dict:
     """Return the merged, validated config: defaults < global < project. Values that fail
     validation fall back to their default (logged), so a bad config file never breaks a query."""
     root = pathlib.Path(project_root) if project_root is not None else pathlib.Path.cwd()
 
-    global_cfg = _read_toml(pathlib.Path.home() / ".codeintel" / "config.toml")
+    global_cfg = _global_config()
     project_cfg = _read_toml(root / ".codeintel.toml")
 
     merged = {**_DEFAULTS, **global_cfg, **project_cfg}

{codecortex-0.17.0 → codecortex-0.18.0}/src/codeintel/containment.py

@@ -69,9 +69,24 @@ def open_contained(root_real: str, candidate: str | Path, **kwargs):
     Raises ``ContainmentError`` rather than returning a sentinel, so a caller that wraps reads in a
     broad ``except Exception`` cannot quietly downgrade an escape to "file not found" — the escape
     is logged at WARNING here regardless of what the caller does with the exception.
+
+    A path that simply DOES NOT EXIST is reported as ``FileNotFoundError``, not as an escape.
+    ``contained_path`` answers the single question "may this be read", and a deleted file is a
+    legitimate no — but it is also the most ordinary thing that can happen to an indexed file, and
+    reporting it as a refusal meant every deletion between indexing and a query logged a WARNING
+    asking whether a symlink had been "planted after indexing" and rendered the hit as
+    ``[refused: resolves outside the indexed root]``. That is a false security alarm on a routine
+    event, and it drowns the real ones. The distinction is made HERE rather than by relaxing
+    ``contained_path``, whose ``None`` also drives ``_cleanup_deleted``'s reconciliation of deleted
+    files — loosening it there would leave their rows in the index forever.
     """
     safe = contained_path(root_real, candidate)
     if safe is None:
+        # lexists(), not exists(): a dangling symlink still EXISTS as a link, and a link whose
+        # target vanished is a construct worth refusing loudly rather than calling "not found".
+        if not os.path.lexists(candidate):
+            logger.debug("indexed file no longer exists: %s", candidate)
+            raise FileNotFoundError(str(candidate))
         logger.warning(
             "refusing to read %s — it does not resolve to a file inside %s (symlink or hard link "
             "planted after indexing?)", candidate, root_real,

{codecortex-0.17.0 → codecortex-0.18.0}/src/codeintel/indexer.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING
 
 from codeintel.containment import contained_path, real_root
 from codeintel.progress import ProgressSink, _Guard
+from codeintel.semantic_db import MAX_CHUNK_CHARS, chunk_content_hash
 from codeintel.source_kind import (
     CODE_EXTS,
     load_gitattributes_globs,
@@ -26,8 +27,10 @@ logger = logging.getLogger(__name__)
 
 # Hard ceiling on the characters embedded for ONE chunk. Line-based splitting cannot bound a
 # minified or generated single-line file, and the embedder's memory use scales with input size.
-# Generous enough that no hand-written function is affected.
-_MAX_CHUNK_CHARS = 200_000
+# Generous enough that no hand-written function is affected. Defined beside the schema so the
+# searcher hashes an oversized chunk exactly the way the indexer stored it; re-exported here
+# because this module is where the truncation is actually performed (and warned about).
+_MAX_CHUNK_CHARS = MAX_CHUNK_CHARS
 
 # Bytes examined when deciding whether a file is binary. A NUL in the first block is the classic
 # signal and is what `git` itself uses.
@@ -228,6 +231,9 @@ class Indexer:
         self._ts_parsers: dict = {}  # per-instance tree-sitter parser cache (lang -> parser|None)
         # Why the last index() failed, for callers that must SHOW a reason rather than log one.
         self.last_error: str | None = None
+        # Rows whose content was unchanged but whose `chunk_end` this pass patched in place
+        # (pre-migration NULLs). Counted so the commit can be skipped when there were none.
+        self._backfilled = 0
 
     def _get_embedder(self):
         if self._embedder is None:
@@ -457,6 +463,77 @@ class Indexer:
                 spans.extend(members)
         return spans
 
+    def _symbol_index_py(self, tree: ast.Module, n: int) -> list[tuple[int, int, str]]:
+        """``(start, end, name)`` for EVERY def/class in the file, nested ones included.
+
+        Deliberately a full ``ast.walk`` rather than reusing ``_primary_spans``: that one emits
+        only the spans worth embedding (top-level defs, class members) and skips nested inner
+        functions, but a chunk can land inside one — and "which symbol am I looking at" should
+        answer with the innermost enclosing def, not the outermost. Separate from the span
+        pipeline on purpose, so chunk boundaries and symbol attribution stay independent."""
+        out: list[tuple[int, int, str]] = []
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                lo, hi = self._node_span(node, n)
+                out.append((lo, hi, node.name))
+        return out
+
+    @staticmethod
+    def _ts_node_name(node) -> str | None:
+        """The declared name of a tree-sitter def node, or None when it has no usable one.
+
+        Most def types carry a ``name`` field. Function-bound `const`/`let` (React components and
+        hooks — how most modern TS is written) instead nest the identifier one level down in a
+        ``variable_declarator``, so an anonymous default export or an IIFE simply yields None and
+        the chunk is attributed to whatever encloses it."""
+        try:
+            named = node.child_by_field_name("name")
+            if named is not None and named.text:
+                return named.text.decode("utf-8", "replace")
+            if node.type in _TS_DECL_TYPES:
+                for child in node.children:
+                    if child.type == "variable_declarator":
+                        ident = child.child_by_field_name("name")
+                        if ident is not None and ident.text:
+                            return ident.text.decode("utf-8", "replace")
+        except Exception as exc:
+            logger.debug("tree-sitter node name extraction failed: %s", exc)
+        return None
+
+    def _symbol_index_ts(self, root, lang: str, n: int) -> list[tuple[int, int, str]]:
+        """``_symbol_index_py`` for tree-sitter languages: every def node anywhere in the tree.
+        Iterative, so deep nesting cannot blow the stack (same reason ``nearest_defs`` is)."""
+        all_types = _TS_FUNC_TYPES.get(lang, set()) | _TS_CONTAINER_TYPES.get(lang, set())
+        if not all_types:
+            return []
+        arrow_ok = lang in _TS_ARROW_LANGS
+        out: list[tuple[int, int, str]] = []
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            is_def = node.type in all_types or (
+                arrow_ok and node.type in _TS_DECL_TYPES and _ts_decl_is_function(node)
+            )
+            if is_def:
+                name = self._ts_node_name(node)
+                if name:
+                    out.append((node.start_point[0], self._ts_end_line(node, n), name))
+            stack.extend(c for c in node.children if c.is_named)
+        return out
+
+    @staticmethod
+    def _enclosing_symbol(index: list[tuple[int, int, str]], start: int) -> str | None:
+        """The INNERMOST definition containing line ``start``, or None at module level.
+
+        Innermost = the latest-starting span that still contains the line, so a method inside a
+        class reports the method (the useful answer) rather than the class."""
+        best_lo = -1
+        best_name = None
+        for lo, hi, name in index:
+            if lo <= start < hi and lo > best_lo:
+                best_lo, best_name = lo, name
+        return best_name
+
     def _cover(self, primary: list[tuple[int, int]], n: int) -> list[tuple[int, int]]:
         """Gapless cover of ``[0, n)`` in file order: window-fill every gap between primary spans
         and window-split any oversized def. The def-aligned *primary* spans are whole and mutually
@@ -479,13 +556,20 @@ class Indexer:
             result.extend(self._window_spans(cursor, n))
         return result
 
+    def _chunk_python_ast_full(
+        self, lines: list[str], source: str
+    ) -> tuple[list[tuple[int, int]], list[tuple[int, int, str]]]:
+        """Spans AND the symbol index from ONE parse. Both derive from the same tree, so they can
+        never describe different versions of the file."""
+        tree = ast.parse(source)
+        n = len(lines)
+        return self._cover(self._primary_spans(tree, n), n), self._symbol_index_py(tree, n)
+
     def _chunk_python_ast(self, lines: list[str], source: str) -> list[tuple[int, int]]:
         """Parse ``source`` → a complete, non-overlapping, def-aligned cover of the file as
         0-based half-open ``(start, end)`` spans. Raises on parse failure (``SyntaxError`` /
         ``ValueError`` on NUL bytes / ``RecursionError`` / …) so the caller falls back to windows."""
-        tree = ast.parse(source)
-        n = len(lines)
-        return self._cover(self._primary_spans(tree, n), n)
+        return self._chunk_python_ast_full(lines, source)[0]
 
     def _get_ts_parser(self, lang: str):
         """Lazily load + cache (per instance) the tree-sitter parser for a language. Returns None
@@ -563,52 +647,67 @@ class Indexer:
             emit(node)
         return spans
 
-    def _chunk_treesitter(self, lines: list[str], source: str, lang: str):
-        """Parse ``source`` with tree-sitter → a complete, def-aligned cover, or ``None`` when the
-        parser is unavailable (caller windows). tree-sitter is error-tolerant, so a syntactically
-        broken file still yields a partial tree (and thus useful spans) rather than raising."""
+    def _chunk_treesitter_full(self, lines: list[str], source: str, lang: str):
+        """Spans AND the symbol index from ONE tree-sitter parse, or ``None`` when the parser is
+        unavailable (caller windows)."""
         parser = self._get_ts_parser(lang)
         if parser is None:
             return None
         tree = parser.parse(source.encode("utf-8", errors="replace"))
         n = len(lines)
-        return self._cover(self._primary_spans_ts(tree.root_node, lang, n), n)
+        root = tree.root_node
+        return (
+            self._cover(self._primary_spans_ts(root, lang, n), n),
+            self._symbol_index_ts(root, lang, n),
+        )
+
+    def _chunk_treesitter(self, lines: list[str], source: str, lang: str):
+        """Parse ``source`` with tree-sitter → a complete, def-aligned cover, or ``None`` when the
+        parser is unavailable (caller windows). tree-sitter is error-tolerant, so a syntactically
+        broken file still yields a partial tree (and thus useful spans) rather than raising."""
+        got = self._chunk_treesitter_full(lines, source, lang)
+        return None if got is None else got[0]
 
     def _spans_for_file(
         self, filepath: Path, lines: list[str], rel_path: str
-    ) -> list[tuple[int, int]]:
+    ) -> tuple[list[tuple[int, int]], list[tuple[int, int, str]]]:
         """Choose spans for one file under the syntax strategy: ``ast`` for ``.py``, tree-sitter for
         the mapped languages (TS/JS/Go/Rust/Java/C/C++), fixed windows for everything else and on
-        any parse/grammar failure or when tree-sitter isn't installed."""
+        any parse/grammar failure or when tree-sitter isn't installed.
+
+        Returns ``(spans, symbol_index)``. The index is empty for the windowed fallbacks — a file
+        we could not parse is a file whose symbols we do not know, and guessing them with a regex
+        is how a preview ends up confidently naming the wrong function."""
         if self.chunk_strategy == "syntax":
             suffix = filepath.suffix.lower()
             if suffix == ".py":
                 try:
-                    return self._chunk_python_ast(lines, "".join(lines))
+                    return self._chunk_python_ast_full(lines, "".join(lines))
                 except Exception as exc:
                     logger.debug("syntax chunking failed for %s (%s) — windowing", rel_path, exc)
             else:
                 lang = _TS_LANG_BY_EXT.get(suffix)
                 if lang is not None:
                     try:
-                        spans = self._chunk_treesitter(lines, "".join(lines), lang)
-                        if spans is not None:
-                            return spans
+                        got = self._chunk_treesitter_full(lines, "".join(lines), lang)
+                        if got is not None:
+                            return got
                     except Exception as exc:
                         logger.debug("tree-sitter chunking failed for %s (%s) — windowing",
                                      rel_path, exc)
-        return self._window_spans(0, len(lines))
+        return self._window_spans(0, len(lines)), []
 
     # ---- materialisation -------------------------------------------------------------------
 
     def _emit_spans(
         self,
         spans: list[tuple[int, int]],
+        symbols: list[tuple[int, int, str]],
         lines: list[str],
         rel_path: str,
         project_key: str,
         conn,
-        new_chunks: list[tuple[str, str, str, int, str]],
+        new_chunks: list[tuple[str, str, str, int, int, str, str | None]],
     ) -> tuple[set[str], bool]:
         """Materialise spans into new/changed chunk records — shared by both strategies, so the
         whitespace-skip, hash-dedup, and per-file cap behave identically. Returns
@@ -651,29 +750,45 @@ class Indexer:
                 chunk_count += 1
                 continue
             chunk_id = f"{project_key}:{rel_path}:{start}"
-            content_hash = hashlib.sha256(chunk_text.encode()).hexdigest()[:16]
+            content_hash = chunk_content_hash(chunk_text)
+            symbol = self._enclosing_symbol(symbols, start)
             keep_ids.add(chunk_id)  # produced this pass — keep even when dedup skips re-embed
             try:
                 row = conn.execute(
-                    "SELECT content_hash FROM chunk_hashes WHERE chunk_id = ?",
+                    "SELECT content_hash, chunk_end, chunk_symbol FROM chunk_hashes"
+                    " WHERE chunk_id = ?",
                     (chunk_id,),
                 ).fetchone()
                 if row and row[0] == content_hash:
+                    # Unchanged content: the stored embedding is still correct and must NOT be
+                    # recomputed. But a row written before `chunk_end` existed carries NULL, and
+                    # the searcher cannot verify staleness without it — so patch the span in
+                    # place. This is what lets an existing 85k-chunk cache gain verification from
+                    # one ordinary index pass instead of a full re-embed.
+                    if row[1] != end or row[2] != symbol:
+                        conn.execute(
+                            "UPDATE chunk_hashes SET chunk_end = ?, chunk_symbol = ?"
+                            " WHERE chunk_id = ?",
+                            (end, symbol, chunk_id),
+                        )
+                        self._backfilled += 1
                     chunk_count += 1
                     continue
             except Exception as exc:
                 logger.debug("hash check failed for %s: %s", chunk_id, exc)
-            new_chunks.append((chunk_id, chunk_text, rel_path, start, content_hash))
+            new_chunks.append(
+                (chunk_id, chunk_text, rel_path, start, end, content_hash, symbol)
+            )
             chunk_count += 1
         return keep_ids, True
 
     def _collect_new_chunks(
         self, root: Path, project_key: str, project_root_real: str
-    ) -> list[tuple[str, str, str, int, str]]:
-        """Walk files; return (chunk_id, text, rel_path, start, hash) for new/changed chunks, and
+    ) -> list[tuple[str, str, str, int, int, str, str | None]]:
+        """Walk files; return (chunk_id, text, rel_path, start, end, hash, symbol) for new/changed chunks, and
         reconcile each fully-processed file (dropping rows for chunks it no longer produces)."""
         conn = self.db.conn()
-        new_chunks: list[tuple[str, str, str, int, str]] = []
+        new_chunks: list[tuple[str, str, str, int, int, str, str | None]] = []
         files_seen = 0
 
         for filepath in self._walk_files(root):
@@ -699,9 +814,9 @@ class Indexer:
                 continue
 
             rel_path = str(filepath.relative_to(root))
-            spans = self._spans_for_file(filepath, lines, rel_path)
+            spans, symbols = self._spans_for_file(filepath, lines, rel_path)
             keep_ids, complete = self._emit_spans(
-                spans, lines, rel_path, project_key, conn, new_chunks
+                spans, symbols, lines, rel_path, project_key, conn, new_chunks
             )
             if complete:
                 # Reconcile only a fully-processed file: drop rows for defs/windows it no longer
@@ -716,13 +831,24 @@ class Indexer:
                 # out of scope for the indexer.
                 self.db.delete_file_orphans(project_root_real, rel_path, keep_ids)
 
+        # Commit any in-place `chunk_end` backfills. These ride outside `_embed_and_write`'s
+        # per-batch commits, and a pass that finds nothing new to embed returns before reaching
+        # them — so without this the backfill is computed and then dropped on every up-to-date
+        # repo, which is precisely the case it exists to serve.
+        if self._backfilled:
+            try:
+                conn.commit()
+                logger.debug("backfilled chunk_end for %d existing chunks", self._backfilled)
+            except Exception as exc:
+                logger.warning("committing chunk_end backfill failed: %s", exc)
+
         # One final tick with the true totals so the committed scan line is accurate (the per-file
         # ticks lag by the current file's chunks). The renderer records this even when throttled.
         self._progress.scan(files_seen, len(new_chunks))
         return new_chunks
 
     def _embed_and_write(
-        self, new_chunks: list[tuple[str, str, str, int, str]], project_root_real: str
+        self, new_chunks: list[tuple[str, str, str, int, int, str, str | None]], project_root_real: str
     ) -> int:
         total = len(new_chunks)
         # Signal the model-load BEFORE materialising the embedder: on a cold cache _get_embedder()
@@ -744,7 +870,8 @@ class Indexer:
                 logger.warning("embedding batch %d failed: %s", i // batch_size, exc)
                 continue
 
-            for j, (chunk_id, _, rel_path, chunk_start, content_hash) in enumerate(batch):
+            for j, (chunk_id, _, rel_path, chunk_start, chunk_end, content_hash,
+                    chunk_symbol) in enumerate(batch):
                 if j >= len(embeddings):
                     break
                 try:
@@ -770,9 +897,10 @@ class Indexer:
                     )
                     conn.execute(
                         "INSERT OR REPLACE INTO chunk_hashes"
-                        "(chunk_id, project_root, file_path, chunk_start, content_hash)"
-                        " VALUES (?, ?, ?, ?, ?)",
-                        (chunk_id, project_root_real, rel_path, chunk_start, content_hash),
+                        "(chunk_id, project_root, file_path, chunk_start, chunk_end,"
+                        " content_hash, chunk_symbol) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                        (chunk_id, project_root_real, rel_path, chunk_start, chunk_end,
+                         content_hash, chunk_symbol),
                     )
                     embedded_count += 1
                 except Exception as exc:
@@ -808,6 +936,7 @@ class Indexer:
             return 0
 
         project_key = _project_key(project_root_real)
+        self._backfilled = 0  # per-pass, so a reused Indexer can't carry a stale count forward
 
         self._cleanup_deleted(root, project_root_real)
 

codecortex-0.18.0/src/codeintel/paths.py

@@ -0,0 +1,31 @@
+"""Where codeintel keeps its per-machine state — one definition, used by every consumer.
+
+``CODEINTEL_HOME`` exists because ``Path.home()`` raises when a process has no resolvable home
+directory: a UID with no passwd entry and no ``$HOME``. That is not exotic for this tool. It is an
+MCP server whose whole purpose is to be launched by coding agents, which are routinely run in
+containers shaped exactly that way.
+
+The override used to be honoured by the semantic cache alone. ``config.py`` and ``auth.py`` each
+called ``Path.home()`` directly, so on such a host ``load_config()`` raised ``RuntimeError`` — and
+kept raising with ``CODEINTEL_HOME`` set, because the override never reached them. The escape hatch
+did not work in the one environment it was written for, and the failure surfaced several layers
+away as a generic ``provider-error``. Anything resolving this directory now asks here.
+"""
+from __future__ import annotations
+
+import os
+import pathlib
+
+
+def codeintel_home() -> pathlib.Path:
+    """The per-machine state directory (cache, global config, auth).
+
+    Raises ``RuntimeError`` (from ``Path.home()``) when there is no override and no resolvable home
+    — deliberately, so a caller that must NAME the problem can. ``SemanticProvider.probe`` reports
+    it with the remediation that actually fixes it; callers for whom a missing file is merely
+    "no config" should catch it instead (see ``config.global_config_path``).
+    """
+    override = os.environ.get("CODEINTEL_HOME", "").strip()
+    if override:
+        return pathlib.Path(override).expanduser()
+    return pathlib.Path.home() / ".codeintel"