codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/ast/ImportEdgeExtractor.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEdgeExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+class ImportEdgeExtractor {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    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();
+            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) {
+                    this.logger.debug('AstParser: unresolved import', { specifier, file: filePath });
+                }
+                continue;
+            }
+            if (toFile.includes('/node_modules/'))
+                continue;
+            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',
+                });
+            }
+            if (namespaceImport) {
+                const fromSymbol = this.resolveFromSymbol(namespaceImport.getText(), usageMap);
+                edges.push({
+                    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();
+            if (!resolved)
+                continue;
+            const toFile = resolved.getFilePath();
+            if (toFile.includes('/node_modules/'))
+                continue;
+            const namedExports = decl.getNamedExports();
+            if (namedExports.length > 0) {
+                for (const named of namedExports) {
+                    edges.push({
+                        project: serviceName, fromFile: filePath, fromSymbol: null,
+                        toFile, toSymbol: named.getName(), depType: 'reexport',
+                    });
+                }
+            }
+            else {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'reexport-namespace',
+                });
+            }
+        }
+        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;
+    }
+    buildUsageMap(sourceFile) {
+        const map = new Map();
+        const containers = [
+            ...sourceFile.getClasses().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            ...sourceFile.getFunctions().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            ...sourceFile.getVariableStatements()
+                .flatMap(stmt => stmt.getDeclarations())
+                .flatMap(n => {
+                const name = n.getName();
+                return name ? [{ name, node: n }] : [];
+            }),
+        ];
+        for (const { name, node } of containers) {
+            for (const id of node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)) {
+                const text = id.getText();
+                const existing = map.get(text);
+                if (existing) {
+                    if (!existing.includes(name))
+                        existing.push(name);
+                }
+                else {
+                    map.set(text, [name]);
+                }
+            }
+        }
+        return map;
+    }
+}
+exports.ImportEdgeExtractor = ImportEdgeExtractor;

package/dist/src/ast/IndexedNodeResolver.d.ts

@@ -0,0 +1,14 @@
+import { Node } from 'ts-morph';
+import type { IIndexedNodeResolver, IndexedNodeDescription } from '../interfaces/IIndexedNodeResolver';
+export declare class IndexedNodeResolver implements IIndexedNodeResolver {
+    private static isValidSegment;
+    private isModuleOrNamespaceLevelVariable;
+    private classExpressionRoot;
+    private objectLiteralRootValid;
+    private isTopLevelOrNamespaceDirect;
+    private walkStep;
+    private containerSegments;
+    describeIndexedNode(node: Node): IndexedNodeDescription | null;
+    qualifiedName(described: IndexedNodeDescription): string;
+    findFromSymbol(node: Node): string | null;
+}

package/dist/src/ast/IndexedNodeResolver.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedNodeResolver = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+const VALID_SEGMENT = /^#?[\w$]+$/;
+class IndexedNodeResolver {
+    static isValidSegment(s) {
+        return VALID_SEGMENT.test(s);
+    }
+    isModuleOrNamespaceLevelVariable(varDecl) {
+        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 = (0, node_helpers_1.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 = (0, node_helpers_1.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);
+    }
+    walkStep(node) {
+        if (ts_morph_1.Node.isModuleDeclaration(node)) {
+            if (node.compilerNode.flags & ts_morph_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 = (0, node_helpers_1.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 = (0, node_helpers_1.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' };
+    }
+    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 (!IndexedNodeResolver.isValidSegment(step.text))
+                    return null;
+                segments.unshift(step.text);
+                current = step.skipTo ? step.skipTo.getParent() : current.getParent();
+                continue;
+            }
+            current = current.getParent();
+        }
+        return segments;
+    }
+    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 = (0, node_helpers_1.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 = (0, node_helpers_1.unwrapExpr)(init);
+            if (!(ts_morph_1.Node.isArrowFunction(unwrapped) || ts_morph_1.Node.isFunctionExpression(unwrapped)))
+                return null;
+            const name = (0, node_helpers_1.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 = (0, node_helpers_1.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;
+    }
+    findFromSymbol(node) {
+        let current = node.getParent();
+        while (current) {
+            const described = this.describeIndexedNode(current);
+            if (described)
+                return this.qualifiedName(described);
+            current = current.getParent();
+        }
+        return null;
+    }
+}
+exports.IndexedNodeResolver = IndexedNodeResolver;

package/dist/src/ast/MemberExtractor.d.ts

@@ -0,0 +1,8 @@
+import { type SourceFile } from 'ts-morph';
+import type { IIndexedNodeResolver } from '../interfaces';
+import type { DeclarationCandidate } from '../declarations/DeclarationTreeBuilder';
+export declare class MemberExtractor {
+    private readonly resolver;
+    constructor(resolver: IIndexedNodeResolver);
+    extractMembers(sourceFile: SourceFile, filePath: string, serviceName: string): DeclarationCandidate[];
+}

package/dist/src/ast/MemberExtractor.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+class MemberExtractor {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    extractMembers(sourceFile, filePath, serviceName) {
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => (0, node_helpers_1.lineTextAt)(sourceLines, sourceFile, node);
+        const push = (declNode, posNode, name, kind, container, isStatic, hasBody) => {
+            const { line, col } = (0, node_helpers_1.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,
+                },
+            });
+        };
+        for (const cls of [
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration),
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassExpression),
+        ]) {
+            if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName() && ts_morph_1.Node.isSourceFile(cls.getParent()))
+                continue;
+            const described = this.resolver.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);
+        }
+        for (const m of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            const described = this.resolver.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.resolver.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.resolver.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.resolver.describeIndexedNode(c);
+            if (!described)
+                continue;
+            const kw = c.getFirstChildByKind(ts_morph_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.resolver.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.resolver.describeIndexedNode(p);
+            if (!described)
+                continue;
+            push(p, p.getNameNode(), described.name, 'function_property', described.container, false, true);
+        }
+        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodSignature)) {
+            const described = this.resolver.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.resolver.describeIndexedNode(s);
+            if (!described)
+                continue;
+            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
+        }
+        for (const fn of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(fn.getParent()))
+                continue;
+            const described = this.resolver.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.resolver.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.resolver.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.resolver.describeIndexedNode(decl);
+                if (!described)
+                    continue;
+                push(decl, decl.getNameNode(), described.name, 'variable', described.container, false, true);
+            }
+        }
+        return candidates;
+    }
+}
+exports.MemberExtractor = MemberExtractor;

package/dist/src/ast/TopLevelSymbolExtractor.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from 'ts-morph';
+import type { DeclarationCandidate } from '../declarations/DeclarationTreeBuilder';
+export declare class TopLevelSymbolExtractor {
+    extractSymbols(sourceFile: SourceFile, filePath: string, serviceName: string): DeclarationCandidate[];
+}

package/dist/src/ast/TopLevelSymbolExtractor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopLevelSymbolExtractor = void 0;
+const node_helpers_1 = require("./node-helpers");
+class TopLevelSymbolExtractor {
+    extractSymbols(sourceFile, filePath, serviceName) {
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => (0, node_helpers_1.lineTextAt)(sourceLines, sourceFile, node);
+        for (const cls of sourceFile.getClasses()) {
+            const name = cls.getName();
+            if (!name)
+                continue;
+            const nameNode = cls.getNameNode() ?? cls;
+            const { line, col } = (0, node_helpers_1.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() ?? fn;
+            const { line, col } = (0, node_helpers_1.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 nameNode = iface.getNameNode();
+            const { line, col } = (0, node_helpers_1.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 nameNode = ta.getNameNode();
+            const { line, col } = (0, node_helpers_1.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 nameNode = decl.getNameNode();
+                const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+                candidates.push({
+                    declNode: decl,
+                    entry: {
+                        project: serviceName, filePath, name: decl.getName(), kind: 'variable',
+                        signature: lineAt(nameNode),
+                        line, endLine: stmt.getEndLineNumber(), col,
+                        container: null, isStatic: false,
+                    },
+                });
+            }
+        }
+        return candidates;
+    }
+}
+exports.TopLevelSymbolExtractor = TopLevelSymbolExtractor;

package/dist/src/ast/graphql-grammar.d.ts

@@ -0,0 +1,24 @@
+import { Node, type Decorator, type ObjectLiteralExpression, type PropertyAssignment, type ShorthandPropertyAssignment } from 'ts-morph';
+import type { SymbolKind } from '../interfaces/IAstParser';
+export declare const GRAPHQL_MODULE = "@nestjs/graphql";
+export declare const GRAPHQL_TYPE_DECORATORS: Set<string>;
+export declare const GRAPHQL_OPERATION_KIND: Record<string, SymbolKind>;
+export declare const GRAPHQL_NAME_RE: RegExp;
+export type GraphqlNameResult = {
+    ok: true;
+    name: string;
+} | {
+    ok: false;
+    reason: 'non-literal-name' | 'invalid-name';
+    value?: string;
+};
+export declare function decoratorIdentifier(dec: Decorator): Node | undefined;
+export declare function literalStringValue(node: Node): string | null;
+export declare function checkGraphqlGrammar(name: string): GraphqlNameResult;
+export declare function isAbstractGraphqlType(args: Node[]): boolean;
+export declare function findNameProperty(obj: ObjectLiteralExpression): PropertyAssignment | ShorthandPropertyAssignment | undefined;
+export declare function peekThroughWrapper(node: Node): {
+    inner: Node;
+    wrapped: boolean;
+};
+export declare function extractResolverIdentifier(argNode: Node): Node | null;