codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

package/dist/src/enriched-prompt.js

@@ -0,0 +1,87 @@
+"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.getEnrichedPrompt = getEnrichedPrompt;
+const path = __importStar(require("path"));
+function inferRole(relPath) {
+    const p = relPath.toLowerCase();
+    if (p.includes('/services/') || p.endsWith('.service.ts'))
+        return 'Service';
+    if (p.includes('/controllers/') || p.endsWith('.controller.ts'))
+        return 'Controller';
+    if (p.includes('/entities/') || p.endsWith('.entity.ts'))
+        return 'Entity';
+    if (p.includes('/guards/') || p.endsWith('.guard.ts'))
+        return 'Guard';
+    if (p.includes('/commands/'))
+        return 'Command';
+    if (p.includes('/interfaces/'))
+        return 'Interface';
+    if (p.includes('/middleware/'))
+        return 'Middleware';
+    if (p.includes('/interceptors/'))
+        return 'Interceptor';
+    if (p.endsWith('.test.ts') || p.endsWith('.spec.ts') || p.includes('/tests/'))
+        return 'Test';
+    if (p.includes('/utils/') || p.includes('/helpers/') || p.endsWith('-utils.ts'))
+        return 'Utility';
+    return null;
+}
+/**
+ * Build the embedding-input prompt for one chunk. `symbols` is the file's
+ * top-level declarations only (never members) — the prompt is unaffected by
+ * this change (see the `symbol-index-members` non-goal).
+ */
+function getEnrichedPrompt(piece, relPath, serviceName, edges, symbols) {
+    const chunkStart = piece.startLine;
+    const chunkEnd = piece.endLine;
+    const lines = [];
+    lines.push(`Project: ${serviceName} | File: ${relPath}`);
+    const role = inferRole(relPath);
+    if (role)
+        lines.push(`Role: ${role}`);
+    const overlapping = symbols.filter(s => s.line != null &&
+        s.line <= chunkEnd &&
+        (s.endLine ?? s.line) >= chunkStart);
+    if (overlapping.length > 0) {
+        lines.push(`Symbols: ${overlapping.map(s => `${s.kind} ${s.name}`).join(', ')}`);
+    }
+    if (edges.length > 0) {
+        const depNames = [...new Set(edges.map(e => path.basename(e.toFile, path.extname(e.toFile)).split('.')[0]))];
+        lines.push(`Dependencies: ${depNames.join(', ')}`);
+    }
+    lines.push(`Code: ${piece.content}`);
+    return lines.join('\n');
+}

package/dist/src/help.js

@@ -29,7 +29,7 @@ function printHelp(command) {
         case 'setup':
             console.log('Usage: rag-setup');
             console.log('');
-            console.log('Interactive setup: configure DB, Ollama, and workspaceRoot.');
+            console.log('Interactive setup: configure DB, embedding backend, and workspaceRoot.');
             console.log('Run once before using rag-index or rag-mcp.');
             console.log('');
             console.log('Options:');

package/dist/src/interfaces/IAstParser.d.ts

@@ -6,15 +6,25 @@ export interface DepEdge {
     toSymbol: string | null;
     depType: string;
 }
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature';
 export interface SymbolEntry {
     project: string;
     filePath: string;
     name: string;
-    kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
+    kind: SymbolKind;
     signature: string | null;
     line: number | null;
     endLine: number | null;
     col: number | null;
+    /** Dotted path of enclosing named scopes, outermost first; null for top-level declarations. */
+    container: string | null;
+    isStatic: boolean;
+    /**
+     * Whether this declaration node has a body (vs. an overload signature).
+     * Internal — used only to pick an overload set's representative row before
+     * writing to `code_symbol`; never persisted.
+     */
+    hasBody?: boolean;
 }
 export interface CallEdge {
     project: string;
@@ -40,9 +50,15 @@ export interface OwnerRange {
 }
 export interface FileAnalysis {
     edges: DepEdge[];
+    /** Top-level declarations only — feeds the chunker and the embedding prompt. */
     symbols: SymbolEntry[];
+    /** Members, namespace-level declarations and classes collected from the whole
+     * file. Written to `code_symbol` alongside `symbols`; never fed to the
+     * chunker or the prompt (see the `symbol-index-members` retrieval-invariance
+     * requirement). */
+    members: SymbolEntry[];
     calls: CallEdge[];
-    /** Method/accessor/constructor ranges for owner-path resolution (Phase 2). */
+    /** Ownership ranges (decorator-inclusive) for every indexed declaration except `method_signature`. */
     ownerRanges?: OwnerRange[];
 }
 export interface AnalyzeProjectOpts {

package/dist/src/interfaces/IDatabase.d.ts

@@ -24,4 +24,35 @@ export interface IDatabase {
     ensureChunkTable(dimensions: number): Promise<void>;
     /** Drop and recreate `code_chunk` at `dimensions` (dimension change). */
     recreateChunkTable(dimensions: number): Promise<void>;
+    /**
+     * Return all file paths referenced in any of the four index tables for `project`.
+     * Union of code_chunk.filePath, code_symbol.filePath, code_call.fromFile,
+     * code_dependency.fromFile. calleeFile and toFile are excluded (may belong to other projects).
+     */
+    listKnownFiles(project: string): Promise<string[]>;
+    /**
+     * Delete rows for `filePaths` from all four index tables in one transaction.
+     * code_call rows where the file is either fromFile OR calleeFile are removed.
+     * code_dependency rows where the file is either fromFile OR toFile are removed.
+     * No-op when `filePaths` is empty.
+     */
+    deleteFiles(project: string, filePaths: string[]): Promise<void>;
+    /** Return all project names referenced in any of the four index tables. */
+    listIndexedProjects(): Promise<string[]>;
+    /** Delete all rows for `name` from the four index tables in one transaction. */
+    deleteProject(name: string): Promise<void>;
+    /** Every project with at least one row in `code_chunk` or `code_symbol` — the
+     * symbol/call-graph lookup scope (distinct from `listIndexedProjects`, which
+     * also covers `code_call`/`code_dependency`). */
+    listProjectsWithIndexRows(): Promise<string[]>;
+    /**
+     * Among `projectNames` (or every project with rows when null), those that
+     * are outdated: at least one row in `code_chunk`/`code_symbol` and a
+     * `symbol_index_version` below the current format version (missing row = 1).
+     * A missing `symbol_index_version` table counts as "no marker rows" for every
+     * project. Any other database error propagates.
+     */
+    listOutdatedProjects(projectNames: string[] | null): Promise<string[]>;
+    /** Upsert a project's `symbol_index_version` marker to the current format version. */
+    upsertSymbolIndexVersion(project: string): Promise<void>;
 }

package/dist/src/interfaces/ILogger.d.ts

@@ -7,4 +7,11 @@ export interface ILogger {
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
+    /**
+     * Structured telemetry emitted at `info` **independent of the configured log
+     * level** — so an operator can collect it in production without the full
+     * `debug` firehose. No-op when file logging is disabled (never writes to
+     * stdout, which the MCP transport owns).
+     */
+    metric(msg: string, data?: Record<string, unknown>): void;
 }

package/dist/src/interfaces/ISearcher.d.ts

@@ -27,7 +27,10 @@ export interface ISearcher {
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
+        grepFailed: boolean;
     }>;
+    /** One-line warning when a project in scope is outdated (see `SearcherService.outdatedNotice`), else null. */
+    outdatedNotice(project: string | null): Promise<string | null>;
     listFiles(relativePath: string, project: string, depth: number, pattern: string | null): {
         tree: string;
         error?: string;

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

@@ -13,6 +13,17 @@ export declare class AstChunker implements IChunker {
     private readonly chunkSize;
     constructor(config: Config);
     chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
+    private produce;
+    /**
+     * True iff every significant line (blank and comment lines stripped) belongs
+     * to an `import` / re-export statement and at least one is an import or
+     * re-export keyword — so the chunk carries no value/type declaration and is
+     * never a search answer. Any `export const|let|var|function|class|interface|
+     * enum|namespace|default|declare|async function|type X = …` disqualifies
+     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
+     * (re-export → drop) from `export type X = …` (declaration → keep).
+     */
+    static isImportOrReexportOnly(content: string): boolean;
     /** Character-splitter path for a whole file; line numbers from splitter metadata. */
     private splitWholeFile;
     private chunkByAst;

package/dist/src/services/AstChunker.js

@@ -27,6 +27,15 @@ class AstChunker {
         });
     }
     async chunk(code, opts) {
+        const pieces = await this.produce(code, opts);
+        // Single post-chunk pass: drop pieces whose only significant content is
+        // import / re-export statements. Both chunk sources — AST "gap" regions and
+        // the whole-file character path for barrel files — can emit these, so we
+        // filter once over the final pieces. Dependency edges are untouched (they
+        // come from analyzeProject → code_dependency, not from chunk text).
+        return pieces.filter(p => !AstChunker.isImportOrReexportOnly(p.content));
+    }
+    async produce(code, opts) {
         if (opts.isSchemaFile) {
             return this.splitWholeFile(code, this.schemaSplitter);
         }
@@ -35,6 +44,41 @@ class AstChunker {
         }
         return this.chunkByAst(code, opts.symbols);
     }
+    /**
+     * True iff every significant line (blank and comment lines stripped) belongs
+     * to an `import` / re-export statement and at least one is an import or
+     * re-export keyword — so the chunk carries no value/type declaration and is
+     * never a search answer. Any `export const|let|var|function|class|interface|
+     * enum|namespace|default|declare|async function|type X = …` disqualifies
+     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
+     * (re-export → drop) from `export type X = …` (declaration → keep).
+     */
+    static isImportOrReexportOnly(content) {
+        const lines = content
+            .replace(/\/\*[\s\S]*?\*\//g, '') // strip block comments
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l !== '' && !l.startsWith('//') && !l.startsWith('*'));
+        if (lines.length === 0)
+            return false;
+        const IMPORT = /^import\b/;
+        const REEXPORT = /^export\s+(\*|type\s+\{|\{)/; // export * | export type { | export {
+        const DISQUALIFY = /^export\s+(default|async\b|function\b|const\b|let\b|var\b|class\b|abstract\b|interface\b|enum\b|namespace\b|declare\b|type\s+[A-Za-z_$])/;
+        const CONTINUATION = /^(\}?\s*from\s+['"][^'"]+['"];?|[{}]|(type\s+)?[A-Za-z_$][\w$]*(\s+as\s+[A-Za-z_$][\w$]*)?,?|['"][^'"]*['"];?)$/;
+        let keywords = 0;
+        for (const line of lines) {
+            if (DISQUALIFY.test(line))
+                return false;
+            if (IMPORT.test(line) || REEXPORT.test(line)) {
+                keywords++;
+                continue;
+            }
+            if (CONTINUATION.test(line))
+                continue;
+            return false; // unrecognized line → real code, keep the chunk
+        }
+        return keywords >= 1;
+    }
     /** Character-splitter path for a whole file; line numbers from splitter metadata. */
     async splitWholeFile(code, splitter) {
         const docs = await splitter.createDocuments([code]);

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

@@ -8,18 +8,50 @@ export declare class AstParserService implements IAstParser {
     clearCache(projectRoot?: string): void;
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;
+    private analyzeSourceFile;
     private createMorphProject;
     private getMorphProject;
     private extractEdges;
     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;
-    /**
-     * Method / constructor / accessor line ranges with their enclosing class, for
-     * owner-path resolution only. Deliberately NOT fed into `code_symbol` (methods
-     * stay grep-based in find_symbol), so this is separate from extractSymbols.
-     */
-    private extractOwnerRanges;
+    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;
+    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 getContainerName;
 }