codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

package/dist/src/services/AstParserService.js

@@ -37,7 +37,15 @@ exports.AstParserService = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const ts_morph_1 = require("ts-morph");
+const DeclarationTreeBuilder_1 = require("../declarations/DeclarationTreeBuilder");
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
 const LoggerService_1 = require("./LoggerService");
+const GRAPHQL_MODULE = '@nestjs/graphql';
+const GRAPHQL_TYPE_DECORATORS = new Set(['ObjectType', 'InputType', 'InterfaceType']);
+const GRAPHQL_OPERATION_KIND = {
+    Query: 'graphql_query', Mutation: 'graphql_mutation', Subscription: 'graphql_subscription',
+};
+const GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
 const FALLBACK_OPTS = {
     skipAddingFilesFromTsConfig: true,
     skipFileDependencyResolution: false,
@@ -47,11 +55,13 @@ const MORPH_CACHE_MAX = 10;
 const VALID_SEGMENT = /^#?[\w$]+$/;
 class AstParserService {
     logger;
+    deps;
     morphProjects = new Map();
-    constructor(logger = LoggerService_1.LoggerService.silent()) {
+    declarationBuilder = new DeclarationTreeBuilder_1.DeclarationTreeBuilder();
+    constructor(logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         this.logger = logger;
+        this.deps = deps;
     }
-    // ── public interface ────────────────────────────────────────────────────────
     async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
         const t0 = Date.now();
         const skipDependencyResolution = opts.skipDependencyResolution ?? false;
@@ -61,22 +71,21 @@ 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: [], members: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] });
                 continue;
             }
             try {
                 morphProject.addSourceFileAtPath(filePath);
             }
             catch (err) {
-                this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [] });
+                this.logger.warn('AstParser: failed to add source file', { filePath, err });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] });
             }
         }
         for (const sourceFile of morphProject.getSourceFiles()) {
             const filePath = sourceFile.getFilePath();
             analysisMap.set(filePath, this.analyzeSourceFile(sourceFile, filePath, serviceName));
         }
-        // Release source file memory before returning
         for (const sourceFile of morphProject.getSourceFiles()) {
             morphProject.removeSourceFile(sourceFile);
         }
@@ -101,7 +110,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: [], members: [] };
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
         const morphProject = this.getMorphProject(projectRoot);
         const existing = morphProject.getSourceFile(filePath);
@@ -112,8 +121,8 @@ class AstParserService {
             sourceFile = morphProject.addSourceFileAtPath(filePath);
         }
         catch (err) {
-            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
-            return { edges: [], symbols: [], calls: [], members: [] };
+            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, err, ms: Date.now() - t0 });
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
         const result = this.analyzeSourceFile(sourceFile, filePath, serviceName);
         morphProject.removeSourceFile(sourceFile);
@@ -122,7 +131,6 @@ class AstParserService {
         });
         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;
@@ -132,41 +140,37 @@ class AstParserService {
             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 });
+                this.logger.warn('AstParser: member extraction failed', { filePath, err });
                 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 };
+            const declarations = this.buildDeclarations(sourceFile, filePath, symbolCandidates, memberCandidates);
+            let graphqlNames = [];
+            try {
+                graphqlNames = this.extractGraphqlNames(sourceFile, filePath, serviceName, [...symbolCandidates, ...memberCandidates]);
+            }
+            catch (err) {
+                this.logger.warn('AstParser: GraphQL extraction failed', { filePath, err });
+                graphqlNames = [];
+            }
+            return { edges, symbols, members, calls, declarations, graphqlNames };
         }
         catch (err) {
-            this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
-            return { edges: [], symbols: [], calls: [], members: [] };
+            this.logger.warn('AstParser: failed to analyze file', { filePath, err });
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
     }
-    // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
     createMorphProject(projectRoot, skipFileDependencyResolution = false, rootTsConfigPath) {
         const t0 = Date.now();
-        // Determine which tsconfig to use:
-        // 1. Project-local tsconfig.json
-        // 2. Root tsconfig (e.g. tsconfig.base.json for Nx monorepos)
-        // 3. Fallback options
         const localTsconfigPath = path.join(projectRoot, 'tsconfig.json');
         const hasLocalTsconfig = fs.existsSync(localTsconfigPath);
         const hasRootTsconfig = rootTsConfigPath ? fs.existsSync(rootTsConfigPath) : false;
-        // For monorepos: prefer the root tsconfig.base.json which contains
-        // workspace-wide path aliases (e.g. @scope/* → libs/*/src)
         const effectiveTsconfig = hasRootTsconfig ? rootTsConfigPath : (hasLocalTsconfig ? localTsconfigPath : null);
         this.logger.debug('AstParser: tsconfig lookup', {
             projectRoot,
@@ -198,7 +202,7 @@ class AstParserService {
         catch (err) {
             this.logger.warn('AstParser: tsconfig load failed, using fallback', {
                 tsconfigPath: effectiveTsconfig ?? localTsconfigPath,
-                reason: err.message,
+                err,
                 ms: Date.now() - t0,
             });
             project = new ts_morph_1.Project(FALLBACK_OPTS);
@@ -207,7 +211,6 @@ class AstParserService {
     }
     getMorphProject(projectRoot) {
         if (this.morphProjects.has(projectRoot)) {
-            // Move to end = most recently used
             const cached = this.morphProjects.get(projectRoot);
             this.morphProjects.delete(projectRoot);
             this.morphProjects.set(projectRoot, cached);
@@ -215,7 +218,6 @@ class AstParserService {
             return cached;
         }
         if (this.morphProjects.size >= MORPH_CACHE_MAX) {
-            // Evict least recently used (first entry in insertion-order Map)
             const lruKey = this.morphProjects.keys().next().value;
             this.morphProjects.delete(lruKey);
             this.logger.debug('AstParser: evicted LRU project', { lruKey });
@@ -225,13 +227,20 @@ class AstParserService {
         this.morphProjects.set(projectRoot, project);
         return project;
     }
-    // ── private: edge extraction (imports + re-exports) ────────────────────────
     extractEdges(sourceFile, filePath, serviceName) {
         const edges = [];
         const usageMap = this.buildUsageMap(sourceFile);
         for (const decl of sourceFile.getImportDeclarations()) {
+            const namedImports = decl.getNamedImports();
+            const defaultImport = decl.getDefaultImport();
+            const namespaceImport = decl.getNamespaceImport();
+            const hasClause = Boolean(defaultImport || namespaceImport || namedImports.length > 0);
             const resolved = decl.getModuleSpecifierSourceFile();
-            if (!resolved) {
+            let toFile = resolved ? resolved.getFilePath() : null;
+            if (!toFile && !hasClause) {
+                toFile = this.resolveSideEffectModuleSpecifier(decl, sourceFile, filePath);
+            }
+            if (!toFile) {
                 const specifier = decl.getModuleSpecifierValue();
                 const isCodeImport = !/\.(json|css|scss|less|svg|png|jpg|gif|ico|woff2?|ttf|eot)(\?.*)?$/.test(specifier);
                 if (specifier.startsWith('.') && isCodeImport) {
@@ -239,34 +248,37 @@ class AstParserService {
                 }
                 continue;
             }
-            const toFile = resolved.getFilePath();
             if (toFile.includes('/node_modules/'))
                 continue;
-            const namedImports = decl.getNamedImports();
-            const defaultImport = decl.getDefaultImport();
-            const namespaceImport = decl.getNamespaceImport();
-            if (namedImports.length > 0) {
-                for (const named of namedImports) {
-                    const localName = named.getAliasNode()?.getText() ?? named.getName();
-                    const fromSymbol = this.resolveFromSymbol(localName, usageMap);
-                    edges.push({
-                        project: serviceName, fromFile: filePath, fromSymbol,
-                        toFile, toSymbol: named.getName(), depType: 'import',
-                    });
-                }
-            }
-            else if (defaultImport) {
+            if (!hasClause) {
                 edges.push({
                     project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'import-side-effect',
+                });
+                continue;
+            }
+            if (defaultImport) {
+                const fromSymbol = this.resolveFromSymbol(defaultImport.getText(), usageMap);
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol,
                     toFile, toSymbol: null, depType: 'import-default',
                 });
             }
-            else if (namespaceImport) {
+            if (namespaceImport) {
+                const fromSymbol = this.resolveFromSymbol(namespaceImport.getText(), usageMap);
                 edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    project: serviceName, fromFile: filePath, fromSymbol,
                     toFile, toSymbol: null, depType: 'import-namespace',
                 });
             }
+            for (const named of namedImports) {
+                const localName = named.getAliasNode()?.getText() ?? named.getName();
+                const fromSymbol = this.resolveFromSymbol(localName, usageMap);
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol,
+                    toFile, toSymbol: named.getName(), depType: 'import',
+                });
+            }
         }
         for (const decl of sourceFile.getExportDeclarations()) {
             const resolved = decl.getModuleSpecifierSourceFile();
@@ -293,6 +305,15 @@ class AstParserService {
         }
         return edges;
     }
+    resolveSideEffectModuleSpecifier(decl, sourceFile, filePath) {
+        const specifier = decl.getModuleSpecifierValue();
+        const compilerOptions = sourceFile.getProject().getCompilerOptions();
+        const result = ts_morph_1.ts.resolveModuleName(specifier, filePath, compilerOptions, ts_morph_1.ts.sys);
+        const resolvedFileName = result.resolvedModule?.resolvedFileName;
+        if (!resolvedFileName)
+            return null;
+        return sourceFile.getProject().getSourceFile(resolvedFileName)?.getFilePath() ?? null;
+    }
     resolveFromSymbol(localName, usageMap) {
         const users = usageMap.get(localName);
         return users?.length === 1 ? users[0] : null;
@@ -302,7 +323,6 @@ class AstParserService {
         const containers = [
             ...sourceFile.getClasses().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
             ...sourceFile.getFunctions().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
-            // include top-level variable declarations so arrow function exports are tracked for fromSymbol
             ...sourceFile.getVariableStatements()
                 .flatMap(stmt => stmt.getDeclarations())
                 .flatMap(n => {
@@ -325,20 +345,15 @@ class AstParserService {
         }
         return map;
     }
-    // ── 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 candidates = [];
         const sourceLines = sourceFile.getFullText().split('\n');
@@ -406,8 +421,6 @@ class AstParserService {
                 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',
@@ -420,7 +433,6 @@ class AstParserService {
         }
         return candidates;
     }
-    // ── private: member extraction (classes anywhere, members, namespace body) ─
     extractMembers(sourceFile, filePath, serviceName) {
         const candidates = [];
         const sourceLines = sourceFile.getFullText().split('\n');
@@ -438,14 +450,10 @@ class AstParserService {
                 },
             });
         };
-        // 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 described = this.describeIndexedNode(cls);
@@ -454,7 +462,6 @@ class AstParserService {
             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)
@@ -492,7 +499,6 @@ class AstParserService {
                 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)
@@ -505,7 +511,6 @@ class AstParserService {
                 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;
@@ -545,21 +550,327 @@ class AstParserService {
         }
         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 ────────────────────────────────────
+    buildDeclarations(sourceFile, filePath, symbolCandidates, memberCandidates) {
+        try {
+            return this.declarationBuilder.build(sourceFile, [...symbolCandidates, ...memberCandidates]);
+        }
+        catch (err) {
+            this.logger.warn('AstParser: declaration tree build failed', { filePath, err });
+            try {
+                return this.declarationBuilder.flat(symbolCandidates);
+            }
+            catch {
+                return DeclarationTree_1.DeclarationTree.EMPTY;
+            }
+        }
+    }
+    buildGraphqlImportMap(sourceFile) {
+        const map = new Map();
+        for (const decl of sourceFile.getImportDeclarations()) {
+            if (decl.getModuleSpecifierValue() !== GRAPHQL_MODULE)
+                continue;
+            for (const named of decl.getNamedImports()) {
+                const exportedName = named.getName();
+                const localName = named.getAliasNode()?.getText() ?? exportedName;
+                map.set(localName, exportedName);
+            }
+        }
+        return map;
+    }
+    static decoratorIdentifier(dec) {
+        const expr = dec.getExpression();
+        if (ts_morph_1.Node.isCallExpression(expr)) {
+            const callee = expr.getExpression();
+            return ts_morph_1.Node.isIdentifier(callee) ? callee : undefined;
+        }
+        return ts_morph_1.Node.isIdentifier(expr) ? expr : undefined;
+    }
+    recognizedDecorator(dec, importMap) {
+        const idNode = AstParserService.decoratorIdentifier(dec);
+        if (!idNode)
+            return null;
+        const exported = importMap.get(idNode.getText());
+        if (!exported)
+            return null;
+        const expr = dec.getExpression();
+        const args = ts_morph_1.Node.isCallExpression(expr) ? expr.getArguments() : [];
+        return { name: exported, args };
+    }
+    static literalStringValue(node) {
+        if (ts_morph_1.Node.isStringLiteral(node) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node))
+            return node.getLiteralValue();
+        return null;
+    }
+    static checkGraphqlGrammar(name) {
+        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, reason: 'invalid-name', value: name };
+    }
+    static isAbstractGraphqlType(args) {
+        return args.some((arg) => {
+            if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
+                return false;
+            const prop = arg.getProperties().find((p) => {
+                if (!ts_morph_1.Node.isPropertyAssignment(p))
+                    return false;
+                const nameNode = p.getNameNode();
+                if (ts_morph_1.Node.isIdentifier(nameNode))
+                    return nameNode.getText() === 'isAbstract';
+                if (ts_morph_1.Node.isStringLiteral(nameNode))
+                    return nameNode.getLiteralValue() === 'isAbstract';
+                return false;
+            });
+            const init = prop?.getInitializer();
+            return init !== undefined && ts_morph_1.Node.isTrueLiteral(init);
+        });
+    }
+    static findNameProperty(obj) {
+        return obj.getProperties().find((p) => {
+            if (!ts_morph_1.Node.isPropertyAssignment(p) && !ts_morph_1.Node.isShorthandPropertyAssignment(p))
+                return false;
+            const nameNode = p.getNameNode();
+            if (ts_morph_1.Node.isIdentifier(nameNode))
+                return nameNode.getText() === 'name';
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return nameNode.getLiteralValue() === 'name';
+            return false;
+        });
+    }
+    static peekThroughWrapper(node) {
+        let current = node;
+        let wrapped = false;
+        while (true) {
+            if (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current) || ts_morph_1.Node.isNonNullExpression(current)) {
+                current = current.getExpression();
+                wrapped = true;
+                continue;
+            }
+            break;
+        }
+        return { inner: current, wrapped };
+    }
+    deriveGraphqlName(args, allowOptionsName, fallbackName) {
+        if (args.length > 0) {
+            const first = args[0];
+            const { inner, wrapped } = AstParserService.peekThroughWrapper(first);
+            const literal = AstParserService.literalStringValue(inner);
+            if (literal !== null) {
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                return AstParserService.checkGraphqlGrammar(literal);
+            }
+            const isTypeFnOrOptions = ts_morph_1.Node.isArrowFunction(inner) || ts_morph_1.Node.isFunctionExpression(inner) || ts_morph_1.Node.isObjectLiteralExpression(inner);
+            if (!isTypeFnOrOptions)
+                return { ok: false, reason: 'non-literal-name' };
+        }
+        if (allowOptionsName) {
+            for (const arg of args) {
+                const { inner, wrapped } = AstParserService.peekThroughWrapper(arg);
+                if (!ts_morph_1.Node.isObjectLiteralExpression(inner))
+                    continue;
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                const nameProp = AstParserService.findNameProperty(inner);
+                if (!nameProp)
+                    continue;
+                if (ts_morph_1.Node.isShorthandPropertyAssignment(nameProp))
+                    return { ok: false, reason: 'non-literal-name' };
+                const init = nameProp.getInitializer();
+                const value = init ? AstParserService.literalStringValue(init) : null;
+                if (value !== null)
+                    return AstParserService.checkGraphqlGrammar(value);
+                return { ok: false, reason: 'non-literal-name' };
+            }
+        }
+        return AstParserService.checkGraphqlGrammar(fallbackName);
+    }
+    logGraphqlSkip(filePath, declaration, decorator, reason, value) {
+        const fields = { filePath, declaration, decorator, reason };
+        if (value !== undefined)
+            fields.value = value;
+        this.logger.debug('AstParser: graphql row skipped', fields);
+    }
+    declarationNameFor(node, fallback) {
+        const described = this.describeIndexedNode(node);
+        return described ? this.qualifiedName(described) : fallback;
+    }
+    static extractResolverIdentifier(argNode) {
+        let target = argNode;
+        if (ts_morph_1.Node.isArrowFunction(target)) {
+            const body = target.getBody();
+            if (ts_morph_1.Node.isBlock(body))
+                return null;
+            target = body;
+        }
+        if (ts_morph_1.Node.isIdentifier(target))
+            return target;
+        if (ts_morph_1.Node.isArrayLiteralExpression(target)) {
+            const elements = target.getElements();
+            if (elements.length === 1 && ts_morph_1.Node.isIdentifier(elements[0]))
+                return elements[0];
+        }
+        return null;
+    }
+    defaultResolveDeclaration(identifier) {
+        const sym = identifier.getSymbol();
+        if (!sym)
+            return undefined;
+        const firstDecl = sym.getDeclarations()?.[0];
+        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl) ? (sym.getAliasedSymbol() ?? sym) : sym;
+        return resolved.getDeclarations()?.[0];
+    }
+    classGraphqlTypeName(declClass) {
+        const declImportMap = this.buildGraphqlImportMap(declClass.getSourceFile());
+        const decorators = declClass.getDecorators();
+        const hasAnyTypeSpelledDecorator = decorators.some((d) => {
+            const idNode = AstParserService.decoratorIdentifier(d);
+            const text = idNode?.getText();
+            return text === 'ObjectType' || text === 'InterfaceType';
+        });
+        const recognized = decorators
+            .map(d => this.recognizedDecorator(d, declImportMap))
+            .find(r => r?.name === 'ObjectType')
+            ?? decorators.map(d => this.recognizedDecorator(d, declImportMap)).find(r => r?.name === 'InterfaceType');
+        if (recognized) {
+            const fallbackName = declClass.getName() ?? (declClass.isDefaultExport() ? 'default' : '');
+            const nameResult = this.deriveGraphqlName(recognized.args, false, fallbackName);
+            return nameResult.ok ? { ok: true, name: nameResult.name } : { ok: false };
+        }
+        if (hasAnyTypeSpelledDecorator)
+            return { ok: false };
+        const name = declClass.getName();
+        if (!name)
+            return { ok: false };
+        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, value: name };
+    }
+    resolveResolverParentType(cls, importMap) {
+        const resolverDec = cls.getDecorators()
+            .map(d => this.recognizedDecorator(d, importMap))
+            .find(r => r?.name === 'Resolver');
+        if (!resolverDec || resolverDec.args.length === 0)
+            return { ok: false };
+        const argNode = resolverDec.args[0];
+        const literal = AstParserService.literalStringValue(argNode);
+        if (literal !== null) {
+            return GRAPHQL_NAME_RE.test(literal) ? { ok: true, name: literal } : { ok: false, value: literal };
+        }
+        const identifier = AstParserService.extractResolverIdentifier(argNode);
+        if (!identifier)
+            return { ok: false };
+        const resolve = this.deps.resolveDeclaration ?? this.defaultResolveDeclaration.bind(this);
+        const declaration = resolve(identifier);
+        if (!declaration || !ts_morph_1.Node.isClassDeclaration(declaration))
+            return { ok: false };
+        return this.classGraphqlTypeName(declaration);
+    }
+    extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(cls);
+        const declaration = this.declarationNameFor(cls, own?.entry.name ?? cls.getName() ?? 'default');
+        const seenNames = new Set();
+        for (const dec of cls.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec || !GRAPHQL_TYPE_DECORATORS.has(rec.name))
+                continue;
+            if (AstParserService.isAbstractGraphqlType(rec.args)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'abstract-type');
+                continue;
+            }
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, false, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            if (seenNames.has(nameResult.name)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'duplicate', own.entry.name);
+                continue;
+            }
+            seenNames.add(nameResult.name);
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind: 'graphql_type',
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: null, isStatic: false, target: declaration,
+            });
+        }
+    }
+    extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries) {
+        if (!own) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'no-symbol-row');
+            return;
+        }
+        const cls = method.getParent();
+        if (!cls || !ts_morph_1.Node.isClassDeclaration(cls)) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+            return;
+        }
+        const parent = this.resolveResolverParentType(cls, importMap);
+        if (!parent.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent', parent.value);
+            return;
+        }
+        const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+        if (!nameResult.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+            return;
+        }
+        entries.push({
+            project: serviceName, filePath, name: nameResult.name, kind: 'graphql_field',
+            signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+            container: parent.name, isStatic: own.entry.isStatic, target: declaration,
+        });
+    }
+    extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(method);
+        const declaration = this.declarationNameFor(method, own?.entry.name ?? AstParserService.memberName(method.getNameNode()) ?? '<anonymous>');
+        for (const dec of method.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec)
+                continue;
+            if (rec.name === 'ResolveField') {
+                try {
+                    this.extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries);
+                }
+                catch (err) {
+                    this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+                }
+                continue;
+            }
+            const kind = GRAPHQL_OPERATION_KIND[rec.name];
+            if (!kind)
+                continue;
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind,
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: rec.name, isStatic: own.entry.isStatic, target: declaration,
+            });
+        }
+    }
+    extractGraphqlNames(sourceFile, filePath, serviceName, ownRows) {
+        const importMap = this.buildGraphqlImportMap(sourceFile);
+        if (importMap.size === 0)
+            return [];
+        const ownByDeclNode = new Map();
+        for (const c of ownRows)
+            ownByDeclNode.set(c.declNode, c);
+        const entries = [];
+        for (const cls of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration)) {
+            this.extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        for (const method of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            this.extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        return entries;
+    }
     static isValidSegment(s) {
         return VALID_SEGMENT.test(s);
     }
@@ -593,7 +904,6 @@ class AstParserService {
         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);
@@ -626,9 +936,6 @@ class AstParserService {
     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 & ts_morph_1.NodeFlags.GlobalAugmentation)
@@ -681,10 +988,6 @@ class AstParserService {
         }
         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();
@@ -703,10 +1006,6 @@ class AstParserService {
         }
         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);
@@ -799,9 +1098,6 @@ class AstParserService {
     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) {
@@ -812,7 +1108,6 @@ class AstParserService {
         }
         return null;
     }
-    // ── private: call graph extraction ────────────────────────────────────────
     extractCalls(sourceFile, filePath, serviceName) {
         const calls = [];
         for (const callExpr of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
@@ -835,7 +1130,6 @@ class AstParserService {
                     calleeName = expr.getText();
                     const sym = expr.getSymbol();
                     if (sym) {
-                        // Imported identifiers resolve to ImportSpecifier (same file); follow the alias.
                         const firstDecl = sym.getDeclarations()?.[0];
                         const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl)
                             ? (sym.getAliasedSymbol() ?? sym)
@@ -850,7 +1144,6 @@ class AstParserService {
                 }
             }
             catch {
-                // type resolution failures are normal — skip this call
             }
             if (!calleeName || !calleeFile)
                 continue;