codesearch-mcp 0.0.17-alpha.1 → 0.0.18-alpha

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

@@ -0,0 +1,36 @@
+import type { SearchResult, NeighborResult, GraphContext, DependencyRow, ProjectRow, GrepMatch, SymbolKind, SymbolHit, CallerRow, FileRangeResult } from '../services/SearcherService';
+/**
+ * Searcher abstraction — McpServer depends on this interface
+ * rather than the concrete SearcherService.
+ */
+export interface ISearcher {
+    prepareQuery(raw: string): Promise<{
+        query: string;
+        translated: boolean;
+    }>;
+    listProjects(): Promise<ProjectRow[]>;
+    getProjectEdges(): Promise<{
+        from: string;
+        to: string;
+    }[]>;
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
+    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+    fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
+    getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
+    grepSymbol(symbol: string, project: string, excludeFile: string): Promise<{
+        matches: GrepMatch[];
+        truncated: boolean;
+    }>;
+    findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
+        hits: SymbolHit[];
+        truncated: boolean;
+    }>;
+    listFiles(relativePath: string, project: string, depth: number, pattern: string | null): {
+        tree: string;
+        error?: string;
+    };
+    readFileAbsolute(absPath: string, maxLines: number): Promise<FileRangeResult>;
+    readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
+}

package/dist/src/interfaces/ISearcher.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+export type { IEmbedder } from './IEmbedder';
+export type { IAstParser, DepEdge, SymbolEntry, CallEdge, FileAnalysis } from './IAstParser';
+export type { ILogger } from './ILogger';
+export type { IDatabase } from './IDatabase';
+export type { ISearcher } from './ISearcher';
+export type { IProjectDiscovery, DiscoveredProject } from './IProjectDiscovery';
+export type { IMcpToolHandler, ToolDefinition, ToolResponse } from './IMcpToolHandler';

package/dist/src/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/project-selector.d.ts

@@ -7,7 +7,7 @@ export declare class ProjectSelector {
     private included;
     private skipped;
     constructor(workspaceDir: string);
-    select(allProjects: Project[], forceSelect: boolean): Promise<Project[]>;
+    select<T extends Project>(allProjects: T[], forceSelect: boolean): Promise<T[]>;
     private printAlreadySelected;
     private promptForSelection;
     private promptForSkip;

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

@@ -1,12 +1,10 @@
-import type { IAstParser, DepEdge, FileAnalysis } from '../interfaces/IAstParser';
-import { LoggerService } from './LoggerService';
+import type { IAstParser, DepEdge, FileAnalysis, AnalyzeProjectOpts } from '../interfaces/IAstParser';
+import type { ILogger } from '../interfaces';
 export declare class AstParserService implements IAstParser {
     private logger;
     private morphProjects;
-    constructor(logger?: LoggerService);
-    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: {
-        skipDependencyResolution?: boolean;
-    }): Promise<Map<string, FileAnalysis>>;
+    constructor(logger?: ILogger);
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: AnalyzeProjectOpts): Promise<Map<string, FileAnalysis>>;
     clearCache(projectRoot?: string): void;
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;

package/dist/src/services/AstParserService.js

@@ -54,9 +54,10 @@ class AstParserService {
     async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
         const t0 = Date.now();
         const skipDependencyResolution = opts.skipDependencyResolution ?? false;
-        this.logger.debug('AstParser: analyzeProject start', { serviceName, projectRoot, files: filePaths.length, skipDependencyResolution });
+        const rootTsConfigPath = opts.rootTsConfigPath;
+        this.logger.debug('AstParser: analyzeProject start', { serviceName, projectRoot, files: filePaths.length, skipDependencyResolution, rootTsConfigPath });
         const analysisMap = new Map();
-        const morphProject = this.createMorphProject(projectRoot, skipDependencyResolution);
+        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: [] });
@@ -135,22 +136,37 @@ class AstParserService {
         return edges;
     }
     // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
-    createMorphProject(projectRoot, skipFileDependencyResolution = false) {
+    createMorphProject(projectRoot, skipFileDependencyResolution = false, rootTsConfigPath) {
         const t0 = Date.now();
-        const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-        const hasTsconfig = fs.existsSync(tsconfigPath);
-        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig, skipFileDependencyResolution });
+        // 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,
+            localFound: hasLocalTsconfig,
+            rootTsConfigPath: rootTsConfigPath ?? null,
+            rootFound: hasRootTsconfig,
+            effective: effectiveTsconfig,
+            skipFileDependencyResolution,
+        });
         let project;
         try {
-            const opts = hasTsconfig
-                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution }
+            const opts = effectiveTsconfig
+                ? { tsConfigFilePath: effectiveTsconfig, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution }
                 : { ...FALLBACK_OPTS, skipFileDependencyResolution };
             project = new ts_morph_1.Project(opts);
-            if (hasTsconfig) {
+            if (effectiveTsconfig) {
                 const co = project.getCompilerOptions();
                 const pathsMap = co.paths ?? {};
                 const pathCount = Object.keys(pathsMap).length;
-                this.logger.debug('AstParser: tsconfig loaded', { pathCount, ms: Date.now() - t0 });
+                this.logger.debug('AstParser: tsconfig loaded', { tsconfig: effectiveTsconfig, pathCount, ms: Date.now() - t0 });
                 if (pathCount > 0) {
                     this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
                 }
@@ -161,7 +177,7 @@ class AstParserService {
         }
         catch (err) {
             this.logger.warn('AstParser: tsconfig load failed, using fallback', {
-                tsconfigPath,
+                tsconfigPath: effectiveTsconfig ?? localTsconfigPath,
                 reason: err.message,
                 ms: Date.now() - t0,
             });
@@ -367,7 +383,7 @@ class AstParserService {
                     const sym = expr.getNameNode().getSymbol();
                     const decl = sym?.getDeclarations()?.[0];
                     const declPath = decl?.getSourceFile().getFilePath();
-                    if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                    if (declPath && !declPath.includes('/node_modules/')) {
                         calleeFile = declPath;
                         calleeSymbol = calleeName;
                     }
@@ -383,7 +399,7 @@ class AstParserService {
                             : sym;
                         const decl = resolved.getDeclarations()?.[0];
                         const declPath = decl?.getSourceFile().getFilePath();
-                        if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                        if (declPath && !declPath.includes('/node_modules/')) {
                             calleeFile = declPath;
                             calleeSymbol = calleeName;
                         }

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

@@ -1,11 +1,12 @@
 import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
 import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Config } from '../config';
+import type { IDatabase } from '../interfaces/IDatabase';
 import * as schema from '../db/schema';
 type Schema = typeof schema;
 export type DrizzleDb = NodePgDatabase<Schema>;
 export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
-export declare class DatabaseService {
+export declare class DatabaseService implements IDatabase {
     private config;
     private pool;
     private _db;

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

@@ -1,8 +1,8 @@
 import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { IAstParser } from '../interfaces/IAstParser';
-import type { DatabaseService } from './DatabaseService';
-import { LoggerService } from './LoggerService';
+import type { IDatabase } from '../interfaces/IDatabase';
+import type { ILogger } from '../interfaces/ILogger';
 export interface IndexStats {
     serviceName: string;
     indexed: number;
@@ -20,7 +20,7 @@ export declare class IndexerService {
     private logger;
     private readonly jsSplitter;
     private readonly schemaSplitter;
-    constructor(db: DatabaseService, embedder: IEmbedder, ast: IAstParser, config: Config, logger?: LoggerService);
+    constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, config: Config, logger?: ILogger);
     backfillSymbols(signal?: AbortSignal): Promise<{
         total: number;
         processed: number;
@@ -33,12 +33,10 @@ export declare class IndexerService {
         skipped: number;
         failed: number;
     }>;
-    discoverProjects(rootDir: string): {
-        name: string;
-        path: string;
-    }[];
     private writeDepEdges;
-    scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
+    scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
+        rootTsConfigPath?: string;
+    }): Promise<IndexStats>;
     private getSplitter;
     private static inferRole;
     private getEnrichedPrompt;

package/dist/src/services/IndexerService.js

@@ -159,12 +159,6 @@ class IndexerService {
         this.logger.debug('IndexerService: backfillCalls done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
         return { total: rows.length, processed, skipped, failed };
     }
-    discoverProjects(rootDir) {
-        return fs.readdirSync(rootDir, { withFileTypes: true })
-            .filter(d => d.isDirectory() && !file_utils_1.IGNORE_DIRS.has(d.name))
-            .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
-            .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
-    }
     async writeDepEdges(serviceName, relFilePath, edges, tx) {
         const run = async (t) => {
             await t.delete(db_1.codeDependency).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeDependency.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeDependency.fromFile, relFilePath)));
@@ -177,7 +171,7 @@ class IndexerService {
         else
             await this.db.transaction(run);
     }
-    async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles) {
+    async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles, opts) {
         const startTime = Date.now();
         this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
@@ -237,7 +231,10 @@ class IndexerService {
             if (signal?.aborted)
                 break;
             const batch = files.slice(batchStart, batchStart + this.config.indexer.astBatchSize);
-            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, { skipDependencyResolution: isLargeProject });
+            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, {
+                skipDependencyResolution: isLargeProject,
+                rootTsConfigPath: opts?.rootTsConfigPath,
+            });
             for (const filePath of batch) {
                 if (signal?.aborted) {
                     bar.stop();

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

@@ -1,6 +1,7 @@
 import pino from 'pino';
+import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export declare class LoggerService {
+export declare class LoggerService implements ILogger {
     private readonly logger;
     constructor(logger: pino.Logger);
     static silent(): LoggerService;

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

@@ -1,14 +1,23 @@
 import type { Config } from '../config';
-import { SearcherService } from './SearcherService';
-import { LoggerService } from './LoggerService';
+import type { ISearcher } from '../interfaces/ISearcher';
+import type { ILogger } from '../interfaces/ILogger';
+/**
+ * McpServer — thin orchestration layer that delegates tool handling
+ * to individual IMcpToolHandler implementations (Open/Closed Principle).
+ *
+ * To add a new tool: implement IMcpToolHandler and register it in createTools().
+ */
 export declare class McpServer {
     private searcher;
     private config;
     private logger;
-    constructor(searcher: SearcherService, config: Config, logger?: LoggerService);
+    private readonly version;
+    private readonly tools;
+    constructor(searcher: ISearcher, config: Config, logger: ILogger);
     start(startupError?: Error): Promise<void>;
-    private formatGraphContext;
-    private formatChunk;
-    private formatDependencies;
-    private formatDependents;
+    /**
+     * Factory method: creates and registers all tool handlers.
+     * New tools are added here without modifying the dispatch logic above.
+     */
+    private createTools;
 }