codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/search/symbols/SymbolIndexQuery.d.ts

@@ -0,0 +1,14 @@
+import type { IDatabase } from '../../interfaces';
+import type { SymbolHit, SymbolKind } from '../../interfaces/ISymbolLookup';
+import type { FindSymbolQuery } from '../../symbol-name';
+import type { TargetColumnGate } from './TargetColumnGate';
+export interface IndexedSymbols {
+    hits: SymbolHit[];
+    truncated: boolean;
+}
+export declare class SymbolIndexQuery {
+    private db;
+    private gate;
+    constructor(db: IDatabase, gate: TargetColumnGate);
+    query(parsed: FindSymbolQuery, project: string | null, kind: SymbolKind): Promise<IndexedSymbols>;
+}

package/dist/src/search/symbols/SymbolIndexQuery.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolIndexQuery = void 0;
+const symbol_sql_1 = require("../symbol-sql");
+const find_symbol_constants_1 = require("./find-symbol-constants");
+class SymbolIndexQuery {
+    db;
+    gate;
+    constructor(db, gate) {
+        this.db = db;
+        this.gate = gate;
+    }
+    async query(parsed, project, kind) {
+        const container = 'container' in parsed ? parsed.container : null;
+        const hasTarget = await this.gate.present();
+        const params = [];
+        const { filter: nameFilter, exactRank } = (0, symbol_sql_1.symbolMatch)(parsed.name, container, params);
+        const orderPrefix = exactRank ? `${exactRank}, ` : '';
+        let projectFilter = '';
+        if (project) {
+            params.push(project);
+            projectFilter = `AND project = $${params.length}`;
+        }
+        let kindFilter = '';
+        if (kind !== 'all') {
+            params.push(kind);
+            kindFilter = `AND kind = $${params.length}`;
+        }
+        params.push(find_symbol_constants_1.FIND_SYMBOL_LIMIT + 1);
+        const targetSelect = hasTarget ? '"target"' : 'NULL AS target';
+        const rows = await this.db.query(`SELECT "filePath", name, kind, signature, line, col, container, "isStatic", ${targetSelect}
+       FROM code_symbol
+       WHERE ${nameFilter} ${projectFilter} ${kindFilter}
+       ORDER BY ${orderPrefix}project, "filePath", line, col, kind COLLATE "C", container COLLATE "C" NULLS FIRST
+       LIMIT $${params.length}`, params);
+        return {
+            truncated: rows.length > find_symbol_constants_1.FIND_SYMBOL_LIMIT,
+            hits: rows.slice(0, find_symbol_constants_1.FIND_SYMBOL_LIMIT).map(row => ({
+                filePath: row.filePath,
+                line: row.line ?? 1,
+                column: row.col ?? 1,
+                kind: row.kind,
+                signature: row.signature ?? row.name,
+                qualified: row.container ? `${row.container}.${row.name}` : row.name,
+                isStatic: !!row.isStatic,
+                source: 'index',
+                target: row.target ?? null,
+            })),
+        };
+    }
+}
+exports.SymbolIndexQuery = SymbolIndexQuery;

package/dist/src/search/symbols/SymbolTextSearch.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../../config';
+import type { ILogger } from '../../interfaces';
+import type { GrepSymbolResult } from '../../interfaces/ISymbolLookup';
+import type { GrepRunner } from '../../workspace/GrepRunner';
+import type { ProjectRoots } from '../../workspace/ProjectRoots';
+export declare class SymbolTextSearch {
+    private grep;
+    private roots;
+    private config;
+    private logger;
+    constructor(grep: GrepRunner, roots: ProjectRoots, config: Config, logger: ILogger);
+    search(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
+}

package/dist/src/search/symbols/SymbolTextSearch.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolTextSearch = void 0;
+const path = __importStar(require("path"));
+const grep_args_1 = require("./grep-args");
+const GREP_MAX_RESULTS = 200;
+const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
+class SymbolTextSearch {
+    grep;
+    roots;
+    config;
+    logger;
+    constructor(grep, roots, config, logger) {
+        this.grep = grep;
+        this.roots = roots;
+        this.config = config;
+        this.logger = logger;
+    }
+    async search(symbol, rootDir, excludeFile) {
+        const t0 = Date.now();
+        this.logger.debug('SymbolTextSearch: grepSymbol', { symbol, rootDir, excludeFile });
+        if (symbol.includes('\n'))
+            return { ok: true, matches: [], truncated: false, partial: false };
+        const result = await this.grep.run([
+            '-rn', '-F', '-w',
+            grep_args_1.GREP_BINARY_AS_TEXT,
+            '-m', String(GREP_RAW_LIMIT),
+            ...grep_args_1.SOURCE_INCLUDES,
+            ...grep_args_1.GREP_EXCLUDE_DIRS,
+            '--',
+            symbol,
+            this.roots.toAbs(rootDir),
+        ]);
+        const excludeAbsPath = path.join(this.config.workspaceRoot, excludeFile);
+        const all = (result.output ?? '').split('\n').flatMap(line => {
+            const match = line.match(/^(.+?):(\d+):/);
+            if (!match)
+                return [];
+            const [, absFile, lineNum] = match;
+            if (absFile === excludeAbsPath)
+                return [];
+            return [{ filePath: path.relative(this.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
+        });
+        if (!result.ok && all.length === 0)
+            return { ok: false };
+        const truncated = all.length > GREP_MAX_RESULTS;
+        this.logger.debug('SymbolTextSearch: grepSymbol result', { matches: Math.min(all.length, GREP_MAX_RESULTS), truncated, partial: !result.ok, ms: Date.now() - t0 });
+        return { ok: true, matches: all.slice(0, GREP_MAX_RESULTS), truncated, partial: !result.ok };
+    }
+}
+exports.SymbolTextSearch = SymbolTextSearch;

package/dist/src/search/symbols/TargetColumnGate.d.ts

@@ -0,0 +1,7 @@
+import type { IDatabase } from '../../interfaces';
+export declare class TargetColumnGate {
+    private db;
+    private targetColumnPresent;
+    constructor(db: IDatabase);
+    present(): Promise<boolean>;
+}

package/dist/src/search/symbols/TargetColumnGate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetColumnGate = void 0;
+class TargetColumnGate {
+    db;
+    targetColumnPresent = false;
+    constructor(db) {
+        this.db = db;
+    }
+    async present() {
+        if (this.targetColumnPresent)
+            return true;
+        const rows = await this.db.query(`SELECT EXISTS (
+         SELECT 1 FROM information_schema.columns
+         WHERE table_schema = 'public' AND table_name = 'code_symbol' AND column_name = 'target'
+       ) AS present`);
+        const present = !!rows[0]?.present;
+        if (present)
+            this.targetColumnPresent = true;
+        return present;
+    }
+}
+exports.TargetColumnGate = TargetColumnGate;

package/dist/src/search/symbols/find-symbol-constants.d.ts

@@ -0,0 +1,4 @@
+import type { FindSymbolGrep, SymbolKind } from '../../interfaces/ISymbolLookup';
+export declare const GRAPHQL_KINDS: ReadonlySet<SymbolKind>;
+export declare const FIND_SYMBOL_LIMIT = 50;
+export declare const COMPLETE: FindSymbolGrep;

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,14 +1,19 @@
-import { Node } from 'ts-morph';
 import type { IAstParser, DepEdge, FileAnalysis, AnalyzeProjectOpts } from '../interfaces/IAstParser';
 import type { ILogger } from '../interfaces';
+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;
@@ -17,46 +22,5 @@ export declare class AstParserService implements IAstParser {
     private analyzeSourceFile;
     private createMorphProject;
     private getMorphProject;
-    private extractEdges;
-    private resolveSideEffectModuleSpecifier;
-    private resolveFromSymbol;
-    private buildUsageMap;
-    private getPos;
-    private lineTextAt;
-    private extractSymbols;
-    private extractMembers;
     private buildDeclarations;
-    private buildGraphqlImportMap;
-    private static decoratorIdentifier;
-    private recognizedDecorator;
-    private static literalStringValue;
-    private static checkGraphqlGrammar;
-    private static isAbstractGraphqlType;
-    private static findNameProperty;
-    private static peekThroughWrapper;
-    private deriveGraphqlName;
-    private logGraphqlSkip;
-    private declarationNameFor;
-    private static extractResolverIdentifier;
-    private defaultResolveDeclaration;
-    private classGraphqlTypeName;
-    private resolveResolverParentType;
-    private extractClassTypeRows;
-    private extractResolveFieldRow;
-    private extractMethodOperationRows;
-    private extractGraphqlNames;
-    private static isValidSegment;
-    private static memberName;
-    private static unwrapExpr;
-    private static unwrapParent;
-    private isModuleOrNamespaceLevelVariable;
-    private classExpressionRoot;
-    private objectLiteralRootValid;
-    private isTopLevelOrNamespaceDirect;
-    private walkStep;
-    private containerSegments;
-    private describeIndexedNode;
-    private qualifiedName;
-    private findFromSymbol;
-    private extractCalls;
 }