codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/search/symbols/find-symbol-constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPLETE = exports.FIND_SYMBOL_LIMIT = exports.GRAPHQL_KINDS = void 0;
+exports.GRAPHQL_KINDS = new Set([
+    'graphql_query', 'graphql_mutation', 'graphql_subscription', 'graphql_field', 'graphql_type',
+]);
+exports.FIND_SYMBOL_LIMIT = 50;
+exports.COMPLETE = { outcome: 'complete' };

package/dist/src/search/symbols/grep-args.d.ts

@@ -0,0 +1,3 @@
+export declare const SOURCE_INCLUDES: readonly ["--include=*.ts", "--include=*.tsx", "--include=*.js", "--include=*.jsx"];
+export declare const GREP_EXCLUDE_DIRS: string[];
+export declare const GREP_BINARY_AS_TEXT = "--binary-files=text";

package/dist/src/search/symbols/grep-args.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GREP_BINARY_AS_TEXT = exports.GREP_EXCLUDE_DIRS = exports.SOURCE_INCLUDES = void 0;
+const file_utils_1 = require("../../file-utils");
+exports.SOURCE_INCLUDES = ['--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx'];
+exports.GREP_EXCLUDE_DIRS = [...file_utils_1.IGNORE_DIRS].map(d => `--exclude-dir=${d}`);
+exports.GREP_BINARY_AS_TEXT = '--binary-files=text';

package/dist/src/search/symbols/grep-patterns.d.ts

@@ -0,0 +1,4 @@
+import type { SymbolKind } from '../../interfaces/ISymbolLookup';
+export declare function buildFindSymbolPattern(name: string, kind: SymbolKind): string | null;
+export declare function wholeWordIndex(line: string, name: string): number;
+export declare function inferKind(line: string, name: string): Exclude<SymbolKind, 'all'>;

package/dist/src/search/symbols/grep-patterns.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFindSymbolPattern = buildFindSymbolPattern;
+exports.wholeWordIndex = wholeWordIndex;
+exports.inferKind = inferKind;
+const find_symbol_constants_1 = require("./find-symbol-constants");
+const MODIFIERS = ['public', 'private', 'protected', 'static', 'abstract', 'async', 'override'];
+function buildFindSymbolPattern(name, kind) {
+    if (kind === 'function_property' || kind === 'method_signature')
+        return null;
+    if (find_symbol_constants_1.GRAPHQL_KINDS.has(kind))
+        return null;
+    if (kind === 'constructor')
+        return name === 'constructor' ? `(^|[[:space:]])constructor[[:space:]]*\\(` : null;
+    const esc = name.replace(/\$/g, '\\$');
+    const MODIFIER = `(${MODIFIERS.join('|')})`;
+    const BOUNDARY = '(^|[^[:alnum:]_$])';
+    const patterns = {
+        function: `(export[[:space:]]+)?(async[[:space:]]+)?function[[:space:]]+${esc}[[:space:](<]`,
+        class: `(export[[:space:]]+)?(abstract[[:space:]]+)?class[[:space:]]+${esc}[[:space:]{<]`,
+        type: `(export[[:space:]]+)?type[[:space:]]+${esc}[[:space:]=<]`,
+        interface: `(export[[:space:]]+)?interface[[:space:]]+${esc}[[:space:]{<]`,
+        variable: `(export[[:space:]]+)?(const|let|var)[[:space:]]+${esc}[[:space:]=:]`,
+        method: `${BOUNDARY}(${MODIFIER}[[:space:]]+)+\\*?[[:space:]]*${esc}[[:space:]]*[(<]`,
+        get_accessor: `(^|[[:space:]])get[[:space:]]+${esc}[[:space:]]*\\(`,
+        set_accessor: `(^|[[:space:]])set[[:space:]]+${esc}[[:space:]]*\\(`,
+    };
+    if (kind === 'all')
+        return Object.values(patterns).join('|');
+    return patterns[kind];
+}
+function wholeWordIndex(line, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`(?<![\\w$#])${escaped}(?![\\w$#])`);
+    const m = re.exec(line);
+    return m ? m.index : -1;
+}
+function inferKind(line, name) {
+    if (name === 'constructor')
+        return 'constructor';
+    const idx = wholeWordIndex(line, name);
+    const before = idx === -1 ? line : line.slice(0, idx);
+    const tokens = before.trim().split(/\s+/).filter(Boolean);
+    const last = (tokens[tokens.length - 1] ?? '').replace(/\*$/, '');
+    if (last === 'get')
+        return 'get_accessor';
+    if (last === 'set')
+        return 'set_accessor';
+    if (last === 'function')
+        return 'function';
+    if (last === 'class')
+        return 'class';
+    if (last === 'interface')
+        return 'interface';
+    if (last === 'type')
+        return 'type';
+    if (MODIFIERS.includes(last))
+        return 'method';
+    return 'variable';
+}

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

@@ -1,15 +1,19 @@
-import { Node } from 'ts-morph';
 import type { IAstParser, DepEdge, FileAnalysis, AnalyzeProjectOpts } from '../interfaces/IAstParser';
 import type { ILogger } from '../interfaces';
-/** Test seam for `graphql-symbols`' resolve-field parent-type resolution —
- * defaults to the alias-following type-checker lookup `extractCalls` already uses. */
+import type { ResolveDeclaration } from '../ast/node-helpers';
 export interface AstParserDeps {
-    resolveDeclaration?(identifier: Node): Node | undefined;
+    resolveDeclaration?: ResolveDeclaration;
 }
 export declare class AstParserService implements IAstParser {
     private logger;
-    private deps;
     private morphProjects;
+    private readonly declarationBuilder;
+    private readonly resolver;
+    private readonly edges;
+    private readonly topLevel;
+    private readonly members;
+    private readonly calls;
+    private readonly graphql;
     constructor(logger?: ILogger, deps?: AstParserDeps);
     analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: AnalyzeProjectOpts): Promise<Map<string, FileAnalysis>>;
     clearCache(projectRoot?: string): void;
@@ -18,105 +22,5 @@ export declare class AstParserService implements IAstParser {
     private analyzeSourceFile;
     private createMorphProject;
     private getMorphProject;
-    private extractEdges;
-    /** Manual fallback for a bindingless import specifier (design.md decision 2) —
-     * ts-morph's `getModuleSpecifierSourceFile()` is `null` for these even when
-     * the target is a real project file, since nothing is bound to resolve through. */
-    private resolveSideEffectModuleSpecifier;
-    private resolveFromSymbol;
-    private buildUsageMap;
-    private getPos;
-    /** Trimmed text of the source line containing `node`'s start — the signature
-     * rule for every kind (name node for members, the position node for
-     * constructors/anonymous default classes). */
-    private lineTextAt;
-    private extractSymbols;
-    private extractMembers;
-    /** Chunk-ownership ranges from every indexed declaration (top-level symbols +
-     * members) except `method_signature`. Each range spans the declaration node's
-     * own first-to-last line — decorator-inclusive, comment-exclusive, and (for a
-     * variable) the declarator alone, never the whole statement. */
-    private buildOwnerRanges;
-    /** Local name → the name exported by `@nestjs/graphql`, for every named import
-     * of that module specifier (aliases followed). Recognition is import-based,
-     * not type-checker-based, so `skipFileDependencyResolution` batches agree. */
-    private buildGraphqlImportMap;
-    /** The identifier naming a decorator's expression (`@Foo` or the callee of `@Foo(...)`). */
-    private static decoratorIdentifier;
-    /** `dec` recognised against `importMap` — its exported `@nestjs/graphql` name and its call arguments (`[]` for a bare `@Foo`). */
-    private recognizedDecorator;
-    private static literalStringValue;
-    private static checkGraphqlGrammar;
-    /** `true` when any decorator argument is an (unwrapped) options object
-     * literal with `isAbstract: true` — an abstract base type (`PaginatedType`
-     * pattern) that NestJS never registers in the actual GraphQL schema. */
-    private static isAbstractGraphqlType;
-    /** `obj`'s own `name` property (`PropertyAssignment` or `ShorthandPropertyAssignment`), if any. */
-    private static findNameProperty;
-    /** Strips parens/`as`/`satisfies`/non-null wrappers (any nesting) to find the
-     * underlying node — used only to classify an argument's *shape* (type
-     * function vs. options object vs. literal vs. other), never to read a name
-     * value through the wrapper (decision 4 of `graphql-symbols` forbids that). */
-    private static peekThroughWrapper;
-    /**
-     * GraphQL name from a decorator's arguments (design decision 4 of
-     * `graphql-symbols`) — syntactic, no wrapper looked through at any step.
-     * `allowOptionsName` gates step 2 (the `name` option — `Query`/`Mutation`/
-     * `Subscription`/`ResolveField` only); `fallbackName` is the TS name used at
-     * step 3.
-     */
-    private deriveGraphqlName;
-    private logGraphqlSkip;
-    /** `declNode`'s qualified TypeScript name for diagnostics, independent of
-     * whether its own `code_symbol` row was actually written. */
-    private declarationNameFor;
-    /** The identifier named by a `@Resolver` argument: directly, or as an arrow
-     * function's expression body; or the sole identifier of a single-element
-     * array literal in either position (list-returning resolver). */
-    private static extractResolverIdentifier;
-    private defaultResolveDeclaration;
-    /** The GraphQL type name of a `@ResolveField`'s resolved parent class
-     * (design decision 5, second half): its recognised `@ObjectType` (else
-     * `@InterfaceType`) decorator, or its class name when it carries no
-     * decorator spelled `ObjectType`/`InterfaceType` at all, recognised or not. */
-    private classGraphqlTypeName;
-    /** The parent type of a `@ResolveField` — the enclosing class's recognised
-     * `@Resolver` argument (design decision 5, first half). */
-    private resolveResolverParentType;
-    private extractClassTypeRows;
-    private extractResolveFieldRow;
-    private extractMethodOperationRows;
-    /** GraphQL-named rows for every recognised `@nestjs/graphql` decorator in
-     * the file (`graphql-symbols`). `ownRows` is `symbols ∪ members` — the
-     * declarations' own `code_symbol` candidates, checked so a GraphQL row is
-     * never written without its decorated declaration's own row. */
-    private extractGraphqlNames;
-    private static isValidSegment;
-    private static memberName;
-    private static unwrapExpr;
-    private static unwrapParent;
-    private isModuleOrNamespaceLevelVariable;
-    private classExpressionRoot;
-    private objectLiteralRootValid;
-    private isTopLevelOrNamespaceDirect;
-    /** One step of the ancestor walk used by `containerSegments`: does `node`
-     * contribute a named segment, pass through transparently, or disqualify
-     * (exclude) everything nested inside it? */
-    private walkStep;
-    /** The dotted container path of `node`'s enclosing named scopes, outermost
-     * first, or null when any contributing ancestor is invalid (a computed /
-     * string-literal segment, a string-named module, `declare global`, or an
-     * unrooted class expression / object literal). */
-    private containerSegments;
-    /** If `node` is a declaration this service indexes (top-level symbol, member,
-     * or collected class), its own name + container. Otherwise null. Shared by
-     * member extraction, ownership ranges and the call graph so all three name a
-     * declaration identically. */
-    private describeIndexedNode;
-    private qualifiedName;
-    /** The qualified name of the nearest ancestor of `node` that is itself an
-     * indexed declaration (method, accessor, constructor, function property,
-     * namespace/top-level function, or module-/namespace-level variable). */
-    private findFromSymbol;
-    private extractCalls;
+    private buildDeclarations;
 }