codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

package/dist/src/services/AstParserService.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstParserService = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const typescript_1 = require("typescript");
 const ts_morph_1 = require("ts-morph");
 const LoggerService_1 = require("./LoggerService");
 const FALLBACK_OPTS = {
@@ -44,6 +45,7 @@ const FALLBACK_OPTS = {
     compilerOptions: { allowJs: true, noEmit: true },
 };
 const MORPH_CACHE_MAX = 10;
+const VALID_SEGMENT = /^#?[\w$]+$/;
 class AstParserService {
     logger;
     morphProjects = new Map();
@@ -60,7 +62,7 @@ class AstParserService {
         const morphProject = this.createMorphProject(projectRoot, skipDependencyResolution, rootTsConfigPath);
         for (const filePath of filePaths) {
             if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [] });
                 continue;
             }
             try {
@@ -68,22 +70,12 @@ class AstParserService {
             }
             catch (err) {
                 this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [] });
             }
         }
         for (const sourceFile of morphProject.getSourceFiles()) {
             const filePath = sourceFile.getFilePath();
-            try {
-                const edges = this.extractEdges(sourceFile, filePath, serviceName);
-                const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
-                const calls = this.extractCalls(sourceFile, filePath, serviceName);
-                const ownerRanges = this.extractOwnerRanges(sourceFile);
-                analysisMap.set(filePath, { edges, symbols, calls, ownerRanges });
-            }
-            catch (err) {
-                this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
-            }
+            analysisMap.set(filePath, this.analyzeSourceFile(sourceFile, filePath, serviceName));
         }
         // Release source file memory before returning
         for (const sourceFile of morphProject.getSourceFiles()) {
@@ -110,7 +102,7 @@ class AstParserService {
         this.logger.debug('AstParser: analyzeFile start', { filePath, serviceName, projectRoot });
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
             this.logger.debug('AstParser: analyzeFile skip (non-TS)', { filePath, ms: Date.now() - t0 });
-            return { edges: [], symbols: [], calls: [] };
+            return { edges: [], symbols: [], calls: [], members: [] };
         }
         const morphProject = this.getMorphProject(projectRoot);
         const existing = morphProject.getSourceFile(filePath);
@@ -122,21 +114,48 @@ class AstParserService {
         }
         catch (err) {
             this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
-            return { edges: [], symbols: [], calls: [] };
+            return { edges: [], symbols: [], calls: [], members: [] };
         }
-        const edges = this.extractEdges(sourceFile, filePath, serviceName);
-        const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
-        const calls = this.extractCalls(sourceFile, filePath, serviceName);
-        const ownerRanges = this.extractOwnerRanges(sourceFile);
+        const result = this.analyzeSourceFile(sourceFile, filePath, serviceName);
         morphProject.removeSourceFile(sourceFile);
-        this.logger.debug('AstParser: analyzeFile done', { filePath, edges: edges.length, symbols: symbols.length, calls: calls.length, ms: Date.now() - t0 });
-        return { edges, symbols, calls, ownerRanges };
+        this.logger.debug('AstParser: analyzeFile done', {
+            filePath, edges: result.edges.length, symbols: result.symbols.length, members: result.members.length, calls: result.calls.length, ms: Date.now() - t0,
+        });
+        return result;
     }
     // Kept for test compatibility (extract-import-edges.test.ts).
     async extractImportEdges(filePath, serviceName, projectRoot) {
         const { edges } = await this.analyzeFile(filePath, serviceName, projectRoot);
         return edges;
     }
+    analyzeSourceFile(sourceFile, filePath, serviceName) {
+        try {
+            const edges = this.extractEdges(sourceFile, filePath, serviceName);
+            const symbolCandidates = this.extractSymbols(sourceFile, filePath, serviceName);
+            const symbols = symbolCandidates.map(c => c.entry);
+            // Member extraction (classes anywhere, class/interface/object-literal
+            // members, namespace-level declarations) is isolated in its own try: a
+            // bug there must never change a file's top-level symbols, chunks or
+            // embedding prompt (see the `symbol-index-members` retrieval-invariance
+            // requirement).
+            let memberCandidates = [];
+            try {
+                memberCandidates = this.extractMembers(sourceFile, filePath, serviceName);
+            }
+            catch (err) {
+                this.logger.warn('AstParser: member extraction failed', { filePath, reason: err.message });
+                memberCandidates = [];
+            }
+            const members = memberCandidates.map(c => c.entry);
+            const calls = this.extractCalls(sourceFile, filePath, serviceName);
+            const ownerRanges = this.buildOwnerRanges([...symbolCandidates, ...memberCandidates]);
+            return { edges, symbols, members, calls, ownerRanges };
+        }
+        catch (err) {
+            this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
+            return { edges: [], symbols: [], calls: [], members: [] };
+        }
+    }
     // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
     createMorphProject(projectRoot, skipFileDependencyResolution = false, rootTsConfigPath) {
         const t0 = Date.now();
@@ -307,96 +326,492 @@ class AstParserService {
         }
         return map;
     }
-    // ── private: symbol extraction ─────────────────────────────────────────────
+    // ── private: position / signature helpers ───────────────────────────────────
+    getPos(sourceFile, node) {
+        const { line, character } = sourceFile.compilerNode
+            .getLineAndCharacterOfPosition(node.getStart());
+        return { line: line + 1, col: character + 1 };
+    }
+    /** 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). */
+    lineTextAt(sourceLines, sourceFile, node) {
+        const { line } = this.getPos(sourceFile, node);
+        return (sourceLines[line - 1] ?? node.getText().split('\n')[0]).trim();
+    }
+    // ── private: top-level symbol extraction (feeds the chunker + prompt) ──────
     extractSymbols(sourceFile, filePath, serviceName) {
-        const symbols = [];
-        const sig = (text, keyword) => {
-            const found = text.split('\n').find(l => keyword.test(l));
-            return found?.trim() ?? text.split('\n')[0].trim();
-        };
-        const getPos = (node) => {
-            const { line, character } = sourceFile.compilerNode
-                .getLineAndCharacterOfPosition(node.getStart());
-            return { line: line + 1, col: character + 1 };
-        };
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => this.lineTextAt(sourceLines, sourceFile, node);
         for (const cls of sourceFile.getClasses()) {
             const name = cls.getName();
             if (!name)
                 continue;
-            const nameNode = cls.getNameNode();
-            const { line, col } = nameNode ? getPos(nameNode) : { line: cls.getStartLineNumber(), col: 1 };
-            symbols.push({
-                project: serviceName, filePath, name, kind: 'class',
-                signature: sig(cls.getText(), /\bclass\s/),
-                line, endLine: cls.getEndLineNumber(), col,
+            const nameNode = cls.getNameNode() ?? cls;
+            const { line, col } = this.getPos(sourceFile, nameNode);
+            candidates.push({
+                declNode: cls,
+                entry: {
+                    project: serviceName, filePath, name, kind: 'class',
+                    signature: lineAt(nameNode),
+                    line, endLine: cls.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
             });
         }
         for (const fn of sourceFile.getFunctions()) {
             const name = fn.getName();
             if (!name)
                 continue;
-            const nameNode = fn.getNameNode();
-            const { line, col } = nameNode ? getPos(nameNode) : { line: fn.getStartLineNumber(), col: 1 };
-            symbols.push({
-                project: serviceName, filePath, name, kind: 'function',
-                signature: sig(fn.getText(), /\bfunction\s/),
-                line, endLine: fn.getEndLineNumber(), col,
+            const nameNode = fn.getNameNode() ?? fn;
+            const { line, col } = this.getPos(sourceFile, nameNode);
+            candidates.push({
+                declNode: fn,
+                entry: {
+                    project: serviceName, filePath, name, kind: 'function',
+                    signature: lineAt(nameNode),
+                    line, endLine: fn.getEndLineNumber(), col,
+                    container: null, isStatic: false, hasBody: fn.getBody() !== undefined,
+                },
             });
         }
         for (const iface of sourceFile.getInterfaces()) {
-            const { line, col } = getPos(iface.getNameNode());
-            symbols.push({
-                project: serviceName, filePath, name: iface.getName(), kind: 'interface',
-                signature: sig(iface.getText(), /\binterface\s/),
-                line, endLine: iface.getEndLineNumber(), col,
+            const nameNode = iface.getNameNode();
+            const { line, col } = this.getPos(sourceFile, nameNode);
+            candidates.push({
+                declNode: iface,
+                entry: {
+                    project: serviceName, filePath, name: iface.getName(), kind: 'interface',
+                    signature: lineAt(nameNode),
+                    line, endLine: iface.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
             });
         }
         for (const ta of sourceFile.getTypeAliases()) {
-            const { line, col } = getPos(ta.getNameNode());
-            symbols.push({
-                project: serviceName, filePath, name: ta.getName(), kind: 'type',
-                signature: sig(ta.getText(), /\btype\s/),
-                line, endLine: ta.getEndLineNumber(), col,
+            const nameNode = ta.getNameNode();
+            const { line, col } = this.getPos(sourceFile, nameNode);
+            candidates.push({
+                declNode: ta,
+                entry: {
+                    project: serviceName, filePath, name: ta.getName(), kind: 'type',
+                    signature: lineAt(nameNode),
+                    line, endLine: ta.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
             });
         }
         for (const stmt of sourceFile.getVariableStatements()) {
             for (const decl of stmt.getDeclarations()) {
-                const { line, col } = getPos(decl.getNameNode());
-                symbols.push({
-                    project: serviceName, filePath, name: decl.getName(), kind: 'variable',
-                    signature: sig(stmt.getText(), /\b(const|let|var)\s/),
-                    line, endLine: stmt.getEndLineNumber(), col,
+                const nameNode = decl.getNameNode();
+                const { line, col } = this.getPos(sourceFile, nameNode);
+                candidates.push({
+                    // Owner ranges use the declarator's own span, not the statement's —
+                    // each declarator of `const a = 1, b = () => {…}` owns only its lines.
+                    declNode: decl,
+                    entry: {
+                        project: serviceName, filePath, name: decl.getName(), kind: 'variable',
+                        signature: lineAt(nameNode),
+                        line, endLine: stmt.getEndLineNumber(), col,
+                        container: null, isStatic: false,
+                    },
                 });
             }
         }
-        return symbols;
+        return candidates;
     }
-    /**
-     * 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.
-     */
-    extractOwnerRanges(sourceFile) {
-        const ranges = [];
-        for (const cls of sourceFile.getClasses()) {
-            const container = cls.getName();
-            if (!container)
+    // ── private: member extraction (classes anywhere, members, namespace body) ─
+    extractMembers(sourceFile, filePath, serviceName) {
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => this.lineTextAt(sourceLines, sourceFile, node);
+        const push = (declNode, posNode, name, kind, container, isStatic, hasBody) => {
+            const { line, col } = this.getPos(sourceFile, posNode);
+            candidates.push({
+                declNode,
+                entry: {
+                    project: serviceName, filePath, name, kind,
+                    signature: lineAt(posNode),
+                    line, endLine: declNode.getEndLineNumber(), col,
+                    container: container.length ? container.join('.') : null,
+                    isStatic, hasBody,
+                },
+            });
+        };
+        // Classes anywhere in the file — nested, expression, anonymous default.
+        for (const cls of [
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration),
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassExpression),
+        ]) {
+            // Named top-level classes are already handled by extractSymbols; an
+            // anonymous top-level class (`export default class {}`) is not — it
+            // must still be collected here.
+            if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName() && ts_morph_1.Node.isSourceFile(cls.getParent()))
                 continue;
-            const members = [
-                ...cls.getMethods().map(n => ({ name: n.getName(), node: n })),
-                ...cls.getGetAccessors().map(n => ({ name: n.getName(), node: n })),
-                ...cls.getSetAccessors().map(n => ({ name: n.getName(), node: n })),
-                ...cls.getConstructors().map(n => ({ name: 'constructor', node: n })),
-            ];
-            for (const { name, node } of members) {
-                ranges.push({
-                    name, container,
-                    line: node.getStartLineNumber(),
-                    endLine: node.getEndLineNumber(),
-                });
+            const described = this.describeIndexedNode(cls);
+            if (!described)
+                continue;
+            const posNode = (ts_morph_1.Node.isClassDeclaration(cls) ? cls.getNameNode() : undefined) ?? cls;
+            push(cls, posNode, described.name, 'class', described.container, false, true);
+        }
+        // Class / object-literal methods, accessors, constructors, function properties.
+        for (const m of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            const described = this.describeIndexedNode(m);
+            if (!described)
+                continue;
+            push(m, m.getNameNode(), described.name, 'method', described.container, m.isStatic(), m.getBody() !== undefined);
+        }
+        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.GetAccessor)) {
+            const described = this.describeIndexedNode(a);
+            if (!described)
+                continue;
+            push(a, a.getNameNode(), described.name, 'get_accessor', described.container, a.isStatic(), true);
+        }
+        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SetAccessor)) {
+            const described = this.describeIndexedNode(a);
+            if (!described)
+                continue;
+            push(a, a.getNameNode(), described.name, 'set_accessor', described.container, a.isStatic(), true);
+        }
+        for (const c of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.Constructor)) {
+            const described = this.describeIndexedNode(c);
+            if (!described)
+                continue;
+            const kw = c.getFirstChildByKind(typescript_1.SyntaxKind.ConstructorKeyword) ?? c;
+            push(c, kw, described.name, 'constructor', described.container, false, c.getBody() !== undefined);
+        }
+        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyDeclaration)) {
+            const described = this.describeIndexedNode(p);
+            if (!described)
+                continue;
+            push(p, p.getNameNode(), described.name, 'function_property', described.container, p.isStatic(), true);
+        }
+        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+            const described = this.describeIndexedNode(p);
+            if (!described)
+                continue;
+            push(p, p.getNameNode(), described.name, 'function_property', described.container, false, true);
+        }
+        // Interface / type-literal method and function-typed property signatures.
+        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodSignature)) {
+            const described = this.describeIndexedNode(s);
+            if (!described)
+                continue;
+            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
+        }
+        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertySignature)) {
+            const described = this.describeIndexedNode(s);
+            if (!described)
+                continue;
+            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
+        }
+        // Declarations directly in a namespace body.
+        for (const fn of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(fn.getParent()))
+                continue;
+            const described = this.describeIndexedNode(fn);
+            if (!described)
+                continue;
+            const nameNode = fn.getNameNode();
+            if (!nameNode)
+                continue;
+            push(fn, nameNode, described.name, 'function', described.container, false, fn.getBody() !== undefined);
+        }
+        for (const iface of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.InterfaceDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(iface.getParent()))
+                continue;
+            const described = this.describeIndexedNode(iface);
+            if (!described)
+                continue;
+            push(iface, iface.getNameNode(), described.name, 'interface', described.container, false, true);
+        }
+        for (const ta of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.TypeAliasDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(ta.getParent()))
+                continue;
+            const described = this.describeIndexedNode(ta);
+            if (!described)
+                continue;
+            push(ta, ta.getNameNode(), described.name, 'type', described.container, false, true);
+        }
+        for (const stmt of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableStatement)) {
+            if (!ts_morph_1.Node.isModuleBlock(stmt.getParent()))
+                continue;
+            for (const decl of stmt.getDeclarations()) {
+                const described = this.describeIndexedNode(decl);
+                if (!described)
+                    continue;
+                push(decl, decl.getNameNode(), described.name, 'variable', described.container, false, true);
             }
         }
-        return ranges;
+        return candidates;
+    }
+    /** 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. */
+    buildOwnerRanges(candidates) {
+        return candidates
+            .filter(c => c.entry.kind !== 'method_signature')
+            .map(c => ({
+            name: c.entry.name,
+            container: c.entry.container,
+            line: c.declNode.getStartLineNumber(),
+            endLine: c.declNode.getEndLineNumber(),
+        }));
+    }
+    // ── private: shared container resolution ────────────────────────────────────
+    static isValidSegment(s) {
+        return VALID_SEGMENT.test(s);
+    }
+    static memberName(nameNode) {
+        if (!nameNode)
+            return null;
+        if (ts_morph_1.Node.isPrivateIdentifier(nameNode))
+            return nameNode.getText();
+        if (ts_morph_1.Node.isIdentifier(nameNode))
+            return nameNode.getText();
+        if (ts_morph_1.Node.isStringLiteral(nameNode))
+            return nameNode.getLiteralValue();
+        if (ts_morph_1.Node.isNumericLiteral(nameNode))
+            return nameNode.getText();
+        if (ts_morph_1.Node.isComputedPropertyName(nameNode))
+            return nameNode.getText().replace(/\s+/g, '');
+        return null;
+    }
+    static unwrapExpr(node) {
+        let current = node;
+        while (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current)) {
+            current = current.getExpression();
+        }
+        return current;
+    }
+    static unwrapParent(node) {
+        let current = node.getParent();
+        while (current && (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current))) {
+            current = current.getParent();
+        }
+        return current;
+    }
+    isModuleOrNamespaceLevelVariable(varDecl) {
+        // VariableDeclaration -> VariableDeclarationList -> VariableStatement -> (SourceFile | ModuleBlock)
+        const stmt = varDecl.getParent()?.getParent();
+        const stmtParent = stmt?.getParent();
+        return ts_morph_1.Node.isSourceFile(stmtParent) || ts_morph_1.Node.isModuleBlock(stmtParent);
+    }
+    classExpressionRoot(classExpr) {
+        const parent = AstParserService.unwrapParent(classExpr);
+        if (!parent)
+            return null;
+        if (ts_morph_1.Node.isVariableDeclaration(parent)) {
+            const name = parent.getName();
+            return name ? { name, namingParent: parent } : null;
+        }
+        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals()) {
+            return { name: 'default', namingParent: parent };
+        }
+        return null;
+    }
+    objectLiteralRootValid(obj) {
+        const parent = AstParserService.unwrapParent(obj);
+        if (!parent)
+            return false;
+        if (ts_morph_1.Node.isPropertyAssignment(parent))
+            return true;
+        if (ts_morph_1.Node.isVariableDeclaration(parent))
+            return this.isModuleOrNamespaceLevelVariable(parent);
+        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals())
+            return true;
+        return false;
+    }
+    isTopLevelOrNamespaceDirect(node) {
+        return ts_morph_1.Node.isSourceFile(node) || ts_morph_1.Node.isModuleBlock(node);
+    }
+    /** 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? */
+    walkStep(node) {
+        if (ts_morph_1.Node.isModuleDeclaration(node)) {
+            if (node.compilerNode.flags & typescript_1.NodeFlags.GlobalAugmentation)
+                return { kind: 'exclude' };
+            const nameNode = node.getNameNode();
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return { kind: 'exclude' };
+            return { kind: 'segment', text: nameNode.getText() };
+        }
+        if (ts_morph_1.Node.isClassDeclaration(node)) {
+            const name = node.getName();
+            if (name)
+                return { kind: 'segment', text: name };
+            if (node.isDefaultExport())
+                return { kind: 'segment', text: 'default' };
+            return { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isClassExpression(node)) {
+            const root = this.classExpressionRoot(node);
+            if (!root)
+                return { kind: 'exclude' };
+            return { kind: 'segment', text: root.name, skipTo: root.namingParent };
+        }
+        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+            const name = node.getName();
+            return name ? { kind: 'segment', text: name } : { kind: 'transparent' };
+        }
+        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
+            const name = AstParserService.memberName(node.getNameNode());
+            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
+            return { kind: 'segment', text: 'constructor' };
+        }
+        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
+            const name = AstParserService.memberName(node.getNameNode());
+            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isVariableDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+            return this.objectLiteralRootValid(node) ? { kind: 'transparent' } : { kind: 'exclude' };
+        }
+        return { kind: 'transparent' };
+    }
+    /** 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). */
+    containerSegments(node) {
+        const segments = [];
+        let current = node.getParent();
+        while (current) {
+            const step = this.walkStep(current);
+            if (step.kind === 'exclude')
+                return null;
+            if (step.kind === 'segment') {
+                if (!AstParserService.isValidSegment(step.text))
+                    return null;
+                segments.unshift(step.text);
+                current = step.skipTo ? step.skipTo.getParent() : current.getParent();
+                continue;
+            }
+            current = current.getParent();
+        }
+        return segments;
+    }
+    /** 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. */
+    describeIndexedNode(node) {
+        if (ts_morph_1.Node.isClassDeclaration(node)) {
+            const name = node.getName() ?? (node.isDefaultExport() ? 'default' : null);
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isClassExpression(node)) {
+            const root = this.classExpressionRoot(node);
+            if (!root)
+                return null;
+            const container = this.containerSegments(root.namingParent);
+            return container === null ? null : { name: root.name, container };
+        }
+        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+            const name = node.getName();
+            if (!name || !this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
+            const name = AstParserService.memberName(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: 'constructor', container };
+        }
+        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
+            const init = node.getInitializer();
+            if (!init)
+                return null;
+            const unwrapped = AstParserService.unwrapExpr(init);
+            if (!(ts_morph_1.Node.isArrowFunction(unwrapped) || ts_morph_1.Node.isFunctionExpression(unwrapped)))
+                return null;
+            const name = AstParserService.memberName(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
+            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
+            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isVariableDeclaration(node)) {
+            if (!this.isModuleOrNamespaceLevelVariable(node))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isMethodSignature(node) || ts_morph_1.Node.isPropertySignature(node)) {
+            if (ts_morph_1.Node.isPropertySignature(node)) {
+                const typeNode = node.getTypeNode();
+                if (!typeNode || !ts_morph_1.Node.isFunctionTypeNode(typeNode))
+                    return null;
+            }
+            const parent = node.getParent();
+            let validParent = false;
+            if (ts_morph_1.Node.isInterfaceDeclaration(parent)) {
+                validParent = true;
+            }
+            else if (ts_morph_1.Node.isTypeLiteral(parent)) {
+                const aliasParent = parent.getParent();
+                validParent = ts_morph_1.Node.isTypeAliasDeclaration(aliasParent) && aliasParent.getTypeNode() === parent;
+            }
+            if (!validParent)
+                return null;
+            const name = AstParserService.memberName(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        return null;
+    }
+    qualifiedName(described) {
+        return described.container.length ? `${described.container.join('.')}.${described.name}` : described.name;
+    }
+    /** 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). */
+    findFromSymbol(node) {
+        let current = node.getParent();
+        while (current) {
+            const described = this.describeIndexedNode(current);
+            if (described)
+                return this.qualifiedName(described);
+            current = current.getParent();
+        }
+        return null;
     }
     // ── private: call graph extraction ────────────────────────────────────────
     extractCalls(sourceFile, filePath, serviceName) {
@@ -405,7 +820,7 @@ class AstParserService {
             const expr = callExpr.getExpression();
             let calleeName = null;
             let calleeFile = null;
-            let calleeSymbol = null;
+            let calleeDecl;
             try {
                 if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
                     calleeName = expr.getName();
@@ -414,7 +829,7 @@ class AstParserService {
                     const declPath = decl?.getSourceFile().getFilePath();
                     if (declPath && !declPath.includes('/node_modules/')) {
                         calleeFile = declPath;
-                        calleeSymbol = calleeName;
+                        calleeDecl = decl;
                     }
                 }
                 else if (ts_morph_1.Node.isIdentifier(expr)) {
@@ -430,7 +845,7 @@ class AstParserService {
                         const declPath = decl?.getSourceFile().getFilePath();
                         if (declPath && !declPath.includes('/node_modules/')) {
                             calleeFile = declPath;
-                            calleeSymbol = calleeName;
+                            calleeDecl = decl;
                         }
                     }
                 }
@@ -440,7 +855,9 @@ class AstParserService {
             }
             if (!calleeName || !calleeFile)
                 continue;
-            const fromSymbol = this.getContainerName(callExpr);
+            const described = calleeDecl ? this.describeIndexedNode(calleeDecl) : null;
+            const calleeSymbol = described ? this.qualifiedName(described) : null;
+            const fromSymbol = this.findFromSymbol(callExpr);
             const pos = sourceFile.compilerNode
                 .getLineAndCharacterOfPosition(callExpr.getStart());
             calls.push({
@@ -456,22 +873,5 @@ class AstParserService {
         }
         return calls;
     }
-    getContainerName(node) {
-        let current = node.getParent();
-        while (current) {
-            if (ts_morph_1.Node.isMethodDeclaration(current) || ts_morph_1.Node.isFunctionDeclaration(current)) {
-                return current.getName() ?? null;
-            }
-            if (ts_morph_1.Node.isArrowFunction(current) || ts_morph_1.Node.isFunctionExpression(current)) {
-                const parent = current.getParent();
-                if (ts_morph_1.Node.isVariableDeclaration(parent))
-                    return parent.getName();
-                if (ts_morph_1.Node.isPropertyDeclaration(parent))
-                    return parent.getName();
-            }
-            current = current.getParent();
-        }
-        return null;
-    }
 }
 exports.AstParserService = AstParserService;