codesearch-mcp 0.2.0-alpha → 0.2.1-alpha

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [Unreleased]
+
+## [0.2.1-alpha] - 2026-10-02
+
+### Added
+
+- **`find_symbol` indexes every member kind, not just top-level declarations** — class methods (`abstract`, `static`, `async`, generators, `#private`, computed and string-literal names), get/set accessors, constructors, class properties initialised with a function, object-literal methods, and interface/type-literal method signatures all get a `code_symbol` row now, with the dotted `container` of their enclosing scopes (`RepairsService`, `NS.Parser`, `api.handlers`) and a `static` flag. Classes are collected from the whole file — inside namespaces, as class expressions, as `export default class {}`, and inside functions or methods — not only at the top level.
+- **Qualified, quoted and computed lookup** — `find_symbol` accepts `Class.method` to disambiguate same-named members (exact container first, then a `.`-boundary suffix match), a quoted name for string-literal members (`Router.'kebab-name'`), and a computed name (`Stack.[Symbol.iterator]`), alongside the existing bare-name lookup. `find_symbol` falls back to grep whenever the index returns **no hits** (not only when it errors), and marks grep-sourced hits so the caller knows they may be stale.
+- **Qualified call graph** — `code_call.fromSymbol`/`calleeSymbol` now carry the qualified name of the enclosing/resolved declaration (`RepairsService.createRepairOrder`, including constructors and accessors, which previously had no `fromSymbol` at all). `get_callers` accepts a qualified symbol with the same suffix-matching rules as `find_symbol`.
+- **Per-project symbol-index version, enforced full re-index** — `rag-index` without `--reindex` now refuses to run on a project indexed before member indexing (mixed old/new-format rows would silently hide methods from `find_symbol`); `find_symbol`/`get_callers` show a warning when a project in scope is outdated.
+
+### Changed (breaking)
+
+- **Requires PostgreSQL 15+** — the symbol index's new unique index relies on `NULLS NOT DISTINCT`, added in PostgreSQL 15. `rag-index` checks the server version before any schema change and refuses on an older server.
+- **Every project must be re-indexed** — run `rag-index --reindex` on each project after upgrading. Old-format rows (no members, bare call-graph names) are incompatible with the new lookup and are cleared by `--reindex`.
+
 ## [0.2.0-alpha] - 2026-09-29
 
 ### Added

package/README.md

@@ -19,6 +19,8 @@ See `CHANGELOG.md` for version history.
 
 ## How it works
 
+![Architecture](docs/architecture.svg)
+
 1. `rag-index` scans your projects, chunks source files, embeds them using your configured embedding backend (default: [jina-embeddings-v2-base-code](https://huggingface.co/jinaai/jina-embeddings-v2-base-code) via a local [Infinity](https://github.com/michaelfeil/infinity) container), and stores vectors in PostgreSQL
 2. `rag-mcp` exposes an MCP server — Claude calls it automatically when you ask about code
 3. Incremental — only changed files are re-indexed on subsequent runs
@@ -29,6 +31,7 @@ See `CHANGELOG.md` for version history.
 ## Requirements
 
 - Node.js 18+
+- PostgreSQL 15+ with pgvector (the symbol index's unique index relies on `NULLS NOT DISTINCT`, added in PostgreSQL 15)
 - Docker (for local DB + Infinity) — or bring your own PostgreSQL with pgvector + an embedding backend (see [Embedding providers](#embedding-providers))
 
 ## Installation
@@ -98,13 +101,13 @@ See [docs/web-dashboard.md](docs/web-dashboard.md) for the full reference.
 |------|-------------|
 | `search_codebase` | Semantic search across all indexed projects. Accepts `include_graph_context` to append direct imports/dependents to each result, `include_neighbors` for surrounding chunks, and `threshold` to override the similarity threshold for that query |
 | `list_projects` | List projects with metadata and chunk counts |
-| `find_symbol` | Find a function, class, or type by exact name — faster than semantic search |
+| `find_symbol` | Find a declaration or member by exact name — bare, qualified (`Class.method`), quoted, or computed — faster than semantic search |
 | `list_files` | Browse the directory tree of a project |
 | `read_file` | Read a complete file by absolute path |
 | `read_file_range` | Read a specific line range from an indexed file |
 | `get_dependencies` | Show what files a given file imports (direct or transitive) |
 | `get_dependents` | Show which files import a given file (direct or transitive) |
-| `get_callers` | Find all call sites of a function or method by exact name |
+| `get_callers` | Find all call sites of a function or method by exact name (bare or qualified) |
 
 ## Project metadata
 

package/dist/app.js

@@ -42,7 +42,6 @@ const config_1 = require("./src/config");
 const config_store_1 = require("./src/config-store");
 const IndexCommand_1 = require("./src/commands/IndexCommand");
 const McpCommand_1 = require("./src/commands/McpCommand");
-const BackfillCommand_1 = require("./src/commands/BackfillCommand");
 const ConfigCommand_1 = require("./src/commands/ConfigCommand");
 const WebCommand_1 = require("./src/commands/WebCommand");
 const setup_1 = require("./src/setup");
@@ -87,9 +86,7 @@ async function main() {
     const isSetup = argv1 === 'rag-setup' || process.argv[2] === 'setup' || process.argv[2] === 'rag-setup';
     const isConfig = argv1 === 'rag-config' || process.argv[2] === 'config' || process.argv[2] === 'rag-config';
     const isWeb = argv1 === 'rag-web' || process.argv[2] === 'web' || process.argv[2] === 'rag-web';
-    const isBackfill = process.argv[2] === 'backfill' ||
-        (process.argv[2] === 'rag-index' && process.argv[3] === 'backfill');
-    const mode = isBackfill ? 'backfill' : isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : isConfig ? 'config' : isWeb ? 'web' : (process.argv[2] ?? '');
+    const mode = isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : isConfig ? 'config' : isWeb ? 'web' : (process.argv[2] ?? '');
     const isBinary = ['rag-index', 'rag-mcp', 'rag-setup', 'rag-config', 'rag-web'].includes(argv1);
     if (process.argv.includes('--help') || process.argv.includes('-h')) {
         (0, help_1.printHelp)(isBinary ? argv1 : mode);
@@ -131,17 +128,6 @@ async function main() {
             process.exit(1);
         }
     }
-    else if (mode === 'backfill') {
-        const knownBackfillFlags = new Set(['--calls']);
-        const backfillIdx = process.argv.indexOf('backfill');
-        const backfillArgs = backfillIdx >= 0 ? process.argv.slice(backfillIdx + 1) : [];
-        const unknown = backfillArgs.filter(a => !knownBackfillFlags.has(a));
-        if (unknown.length > 0) {
-            console.error(`Unexpected argument: ${unknown[0]}\n`);
-            (0, help_1.printHelp)('rag-index');
-            process.exit(1);
-        }
-    }
     if (mode === 'setup') {
         await (0, setup_1.runSetup)();
         process.exit(process.exitCode ?? 0);
@@ -151,7 +137,7 @@ async function main() {
         process.exit(0);
     }
     // All other modes require a valid config.json
-    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : mode === 'web' ? 'web' : undefined;
+    const loggerName = mode === 'index' ? 'indexer' : mode === 'mcp' ? 'mcp' : mode === 'web' ? 'web' : undefined;
     let container;
     try {
         container = (0, container_1.createContainer)(loggerName);
@@ -176,7 +162,6 @@ async function main() {
     const factories = {
         index: () => new IndexCommand_1.IndexCommand(container, argv1),
         mcp: () => new McpCommand_1.McpCommand(container),
-        backfill: () => new BackfillCommand_1.BackfillCommand(container),
         web: () => new WebCommand_1.WebCommand(container, effectiveArgs),
     };
     const factory = factories[mode];

package/dist/src/commands/IndexCommand.js

@@ -43,6 +43,33 @@ class IndexCommand {
                 return;
             }
         }
+        const discovered = discovery.discover(config.workspaceRoot);
+        const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
+        if (selected.length === 0)
+            return;
+        // Expand any selected nested-monorepo unit (e.g. an Nx repo) into its
+        // sub-projects; ordinary projects pass through unchanged.
+        const projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
+        // A project indexed before member extraction mixes old-format rows (no
+        // members, bare calleeSymbol) with new ones if left to an incremental run.
+        // Refuse before any backend readiness check, Docker command, or schema
+        // work — the same pattern as the legacy-Ollama guard above.
+        if (!force) {
+            let outdated;
+            try {
+                outdated = await db.listOutdatedProjects(projects.map(p => p.name));
+            }
+            catch (err) {
+                console.error(`\n${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (outdated.length > 0) {
+                console.error(`\nIndexed before member indexing: ${[...outdated].sort().join(', ')} — run \`rag-index --reindex\`.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
         // Ensure the local model is served (Infinity only — no-op for cloud), then
         // resolve the active embedding dimension and reconcile it with index_meta
         // (recreate code_chunk on a dimension change, clear rows on a model change)
@@ -60,13 +87,6 @@ class IndexCommand {
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            const discovered = discovery.discover(config.workspaceRoot);
-            const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
-            if (selected.length === 0)
-                return;
-            // Expand any selected nested-monorepo unit (e.g. an Nx repo) into its
-            // sub-projects; ordinary projects pass through unchanged.
-            const projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
             let pruneResult;
             try {
                 pruneResult = await indexer.pruneProjects(projects.map(p => p.name));

package/dist/src/db/index.d.ts

@@ -1,2 +1,2 @@
-export { codeChunk, codeDependency, codeSymbol, codeCall, indexMeta } from './schema';
+export { codeChunk, codeDependency, codeSymbol, codeCall, indexMeta, symbolIndexVersion } from './schema';
 export type { CodeChunkInsert } from './schema';

package/dist/src/db/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.symbolIndexVersion = exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "codeChunk", { enumerable: true, get: function () { return schema_1.codeChunk; } });
 Object.defineProperty(exports, "codeDependency", { enumerable: true, get: function () { return schema_1.codeDependency; } });
 Object.defineProperty(exports, "codeSymbol", { enumerable: true, get: function () { return schema_1.codeSymbol; } });
 Object.defineProperty(exports, "codeCall", { enumerable: true, get: function () { return schema_1.codeCall; } });
 Object.defineProperty(exports, "indexMeta", { enumerable: true, get: function () { return schema_1.indexMeta; } });
+Object.defineProperty(exports, "symbolIndexVersion", { enumerable: true, get: function () { return schema_1.symbolIndexVersion; } });

package/dist/src/db/schema.d.ts

@@ -430,6 +430,81 @@ export declare const codeSymbol: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        container: import("drizzle-orm/pg-core").PgColumn<{
+            name: "container";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isStatic: import("drizzle-orm/pg-core").PgColumn<{
+            name: "isStatic";
+            tableName: "code_symbol";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const symbolIndexVersion: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "symbol_index_version";
+    schema: undefined;
+    columns: {
+        project: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project";
+            tableName: "symbol_index_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "symbol_index_version";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

package/dist/src/db/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.indexMeta = exports.codeCall = exports.symbolIndexVersion = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 const pg_core_1 = require("drizzle-orm/pg-core");
 // NOTE: the `dimensions` literal below is nominal only. `dataType()` is invoked
 // solely by drizzle-kit DDL generation, which this project does not use — the
@@ -38,6 +38,15 @@ exports.codeSymbol = (0, pg_core_1.pgTable)('code_symbol', {
     signature: (0, pg_core_1.text)('signature'),
     line: (0, pg_core_1.integer)('line'),
     col: (0, pg_core_1.integer)('col'),
+    container: (0, pg_core_1.text)('container'),
+    isStatic: (0, pg_core_1.boolean)('isStatic').notNull().default(false),
+});
+// Per-project marker of the symbol/call-graph row format. Not one of the four
+// index tables (see the `index-consistency` pruning requirement) — a project
+// with only a marker row is not "indexed" and is never pruned for it.
+exports.symbolIndexVersion = (0, pg_core_1.pgTable)('symbol_index_version', {
+    project: (0, pg_core_1.text)('project').primaryKey(),
+    version: (0, pg_core_1.integer)('version').notNull(),
 });
 exports.codeCall = (0, pg_core_1.pgTable)('code_call', {
     id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),

package/dist/src/enriched-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { ChunkPiece } from './interfaces/IChunker';
+import type { DepEdge, SymbolEntry } from './interfaces/IAstParser';
+/**
+ * Build the embedding-input prompt for one chunk. `symbols` is the file's
+ * top-level declarations only (never members) — the prompt is unaffected by
+ * this change (see the `symbol-index-members` non-goal).
+ */
+export declare function getEnrichedPrompt(piece: ChunkPiece, relPath: string, serviceName: string, edges: DepEdge[], symbols: SymbolEntry[]): string;

package/dist/src/enriched-prompt.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnrichedPrompt = getEnrichedPrompt;
+const path = __importStar(require("path"));
+function inferRole(relPath) {
+    const p = relPath.toLowerCase();
+    if (p.includes('/services/') || p.endsWith('.service.ts'))
+        return 'Service';
+    if (p.includes('/controllers/') || p.endsWith('.controller.ts'))
+        return 'Controller';
+    if (p.includes('/entities/') || p.endsWith('.entity.ts'))
+        return 'Entity';
+    if (p.includes('/guards/') || p.endsWith('.guard.ts'))
+        return 'Guard';
+    if (p.includes('/commands/'))
+        return 'Command';
+    if (p.includes('/interfaces/'))
+        return 'Interface';
+    if (p.includes('/middleware/'))
+        return 'Middleware';
+    if (p.includes('/interceptors/'))
+        return 'Interceptor';
+    if (p.endsWith('.test.ts') || p.endsWith('.spec.ts') || p.includes('/tests/'))
+        return 'Test';
+    if (p.includes('/utils/') || p.includes('/helpers/') || p.endsWith('-utils.ts'))
+        return 'Utility';
+    return null;
+}
+/**
+ * Build the embedding-input prompt for one chunk. `symbols` is the file's
+ * top-level declarations only (never members) — the prompt is unaffected by
+ * this change (see the `symbol-index-members` non-goal).
+ */
+function getEnrichedPrompt(piece, relPath, serviceName, edges, symbols) {
+    const chunkStart = piece.startLine;
+    const chunkEnd = piece.endLine;
+    const lines = [];
+    lines.push(`Project: ${serviceName} | File: ${relPath}`);
+    const role = inferRole(relPath);
+    if (role)
+        lines.push(`Role: ${role}`);
+    const overlapping = symbols.filter(s => s.line != null &&
+        s.line <= chunkEnd &&
+        (s.endLine ?? s.line) >= chunkStart);
+    if (overlapping.length > 0) {
+        lines.push(`Symbols: ${overlapping.map(s => `${s.kind} ${s.name}`).join(', ')}`);
+    }
+    if (edges.length > 0) {
+        const depNames = [...new Set(edges.map(e => path.basename(e.toFile, path.extname(e.toFile)).split('.')[0]))];
+        lines.push(`Dependencies: ${depNames.join(', ')}`);
+    }
+    lines.push(`Code: ${piece.content}`);
+    return lines.join('\n');
+}

package/dist/src/interfaces/IAstParser.d.ts

@@ -6,15 +6,25 @@ export interface DepEdge {
     toSymbol: string | null;
     depType: string;
 }
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature';
 export interface SymbolEntry {
     project: string;
     filePath: string;
     name: string;
-    kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
+    kind: SymbolKind;
     signature: string | null;
     line: number | null;
     endLine: number | null;
     col: number | null;
+    /** Dotted path of enclosing named scopes, outermost first; null for top-level declarations. */
+    container: string | null;
+    isStatic: boolean;
+    /**
+     * Whether this declaration node has a body (vs. an overload signature).
+     * Internal — used only to pick an overload set's representative row before
+     * writing to `code_symbol`; never persisted.
+     */
+    hasBody?: boolean;
 }
 export interface CallEdge {
     project: string;
@@ -40,9 +50,15 @@ export interface OwnerRange {
 }
 export interface FileAnalysis {
     edges: DepEdge[];
+    /** Top-level declarations only — feeds the chunker and the embedding prompt. */
     symbols: SymbolEntry[];
+    /** Members, namespace-level declarations and classes collected from the whole
+     * file. Written to `code_symbol` alongside `symbols`; never fed to the
+     * chunker or the prompt (see the `symbol-index-members` retrieval-invariance
+     * requirement). */
+    members: SymbolEntry[];
     calls: CallEdge[];
-    /** Method/accessor/constructor ranges for owner-path resolution (Phase 2). */
+    /** Ownership ranges (decorator-inclusive) for every indexed declaration except `method_signature`. */
     ownerRanges?: OwnerRange[];
 }
 export interface AnalyzeProjectOpts {

package/dist/src/interfaces/IDatabase.d.ts

@@ -41,4 +41,18 @@ export interface IDatabase {
     listIndexedProjects(): Promise<string[]>;
     /** Delete all rows for `name` from the four index tables in one transaction. */
     deleteProject(name: string): Promise<void>;
+    /** Every project with at least one row in `code_chunk` or `code_symbol` — the
+     * symbol/call-graph lookup scope (distinct from `listIndexedProjects`, which
+     * also covers `code_call`/`code_dependency`). */
+    listProjectsWithIndexRows(): Promise<string[]>;
+    /**
+     * Among `projectNames` (or every project with rows when null), those that
+     * are outdated: at least one row in `code_chunk`/`code_symbol` and a
+     * `symbol_index_version` below the current format version (missing row = 1).
+     * A missing `symbol_index_version` table counts as "no marker rows" for every
+     * project. Any other database error propagates.
+     */
+    listOutdatedProjects(projectNames: string[] | null): Promise<string[]>;
+    /** Upsert a project's `symbol_index_version` marker to the current format version. */
+    upsertSymbolIndexVersion(project: string): Promise<void>;
 }

package/dist/src/interfaces/ISearcher.d.ts

@@ -27,7 +27,10 @@ export interface ISearcher {
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
+        grepFailed: boolean;
     }>;
+    /** One-line warning when a project in scope is outdated (see `SearcherService.outdatedNotice`), else null. */
+    outdatedNotice(project: string | null): Promise<string | null>;
     listFiles(relativePath: string, project: string, depth: number, pattern: string | null): {
         tree: string;
         error?: string;

package/dist/src/services/AstParserService.d.ts

@@ -8,18 +8,50 @@ export declare class AstParserService implements IAstParser {
     clearCache(projectRoot?: string): void;
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;
+    private analyzeSourceFile;
     private createMorphProject;
     private getMorphProject;
     private extractEdges;
     private resolveFromSymbol;
     private buildUsageMap;
+    private getPos;
+    /** Trimmed text of the source line containing `node`'s start — the signature
+     * rule for every kind (name node for members, the position node for
+     * constructors/anonymous default classes). */
+    private lineTextAt;
     private extractSymbols;
-    /**
-     * Method / constructor / accessor line ranges with their enclosing class, for
-     * owner-path resolution only. Deliberately NOT fed into `code_symbol` (methods
-     * stay grep-based in find_symbol), so this is separate from extractSymbols.
-     */
-    private extractOwnerRanges;
+    private extractMembers;
+    /** Chunk-ownership ranges from every indexed declaration (top-level symbols +
+     * members) except `method_signature`. Each range spans the declaration node's
+     * own first-to-last line — decorator-inclusive, comment-exclusive, and (for a
+     * variable) the declarator alone, never the whole statement. */
+    private buildOwnerRanges;
+    private static isValidSegment;
+    private static memberName;
+    private static unwrapExpr;
+    private static unwrapParent;
+    private isModuleOrNamespaceLevelVariable;
+    private classExpressionRoot;
+    private objectLiteralRootValid;
+    private isTopLevelOrNamespaceDirect;
+    /** One step of the ancestor walk used by `containerSegments`: does `node`
+     * contribute a named segment, pass through transparently, or disqualify
+     * (exclude) everything nested inside it? */
+    private walkStep;
+    /** The dotted container path of `node`'s enclosing named scopes, outermost
+     * first, or null when any contributing ancestor is invalid (a computed /
+     * string-literal segment, a string-named module, `declare global`, or an
+     * unrooted class expression / object literal). */
+    private containerSegments;
+    /** If `node` is a declaration this service indexes (top-level symbol, member,
+     * or collected class), its own name + container. Otherwise null. Shared by
+     * member extraction, ownership ranges and the call graph so all three name a
+     * declaration identically. */
+    private describeIndexedNode;
+    private qualifiedName;
+    /** The qualified name of the nearest ancestor of `node` that is itself an
+     * indexed declaration (method, accessor, constructor, function property,
+     * namespace/top-level function, or module-/namespace-level variable). */
+    private findFromSymbol;
     private extractCalls;
-    private getContainerName;
 }