codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

package/dist/src/services/NxMonorepoResolver.js

@@ -37,27 +37,6 @@ exports.NxMonorepoResolver = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../file-utils");
-/**
- * Nx monorepo resolver.
- *
- * Detection: presence of `nx.json` at the workspace root.
- *
- * Project discovery strategies (results deduplicated by absolute path):
- * 1. Read `workspace.json` or `angular.json` → projects map
- * 2. Scan standard Nx directories (`apps/`, `libs/`, `packages/`) for
- *    `project.json`, then `package.json` (only when strategy 1 found nothing)
- * 3. `tsconfig.base.json` `paths` — root-level libs referenced only by path
- *    alias (e.g. `contracts/`, `interfaces/`) that the directory scan misses
- * 4. Root-level fallback: treat the workspace root itself as a project
- *    (standalone Nx setup) when nothing else matched
- *
- * tsconfig resolution:
- * - Returns `tsconfig.base.json` at workspace root (Nx convention)
- * - Falls back to `tsconfig.json` at workspace root
- *
- * Cross-project import resolution is handled by the AST parser via the
- * workspace-wide tsconfig `paths` (tsconfig.base.json), so no scope map is built here.
- */
 class NxMonorepoResolver {
     logger;
     constructor(logger) {
@@ -67,15 +46,12 @@ class NxMonorepoResolver {
         return fs.existsSync(path.join(rootDir, 'nx.json'));
     }
     discoverProjects(rootDir) {
-        // Deduplicate across strategies by absolute project path.
         const byPath = new Map();
         const add = (p) => { if (p && !byPath.has(p.path))
             byPath.set(p.path, p); };
-        // Strategy 1: workspace.json / angular.json (authoritative when present)
         const workspaceProjects = this.readWorkspaceJson(rootDir);
         for (const p of workspaceProjects)
             add(p);
-        // Strategy 2 & 3: scan standard directories (only when no workspace.json map)
         if (byPath.size === 0) {
             for (const dir of ['apps', 'libs', 'packages']) {
                 const fullDir = path.join(rootDir, dir);
@@ -86,13 +62,8 @@ class NxMonorepoResolver {
                     add(p);
             }
         }
-        // Strategy 4: tsconfig.base.json `paths` — captures libs that live at the
-        // repo root (e.g. `contracts/`, `interfaces/`) referenced by path aliases,
-        // which the apps/libs/packages scan misses. Only real Nx projects (with a
-        // project.json/package.json) are added; dedup handles overlap with the scan.
         for (const p of this.discoverFromTsconfigPaths(rootDir))
             add(p);
-        // Root-level fallback (standalone Nx setup)
         if (byPath.size === 0) {
             const rootProject = this.tryReadProject(rootDir, rootDir);
             if (rootProject)
@@ -102,13 +73,6 @@ class NxMonorepoResolver {
         this.logger.debug('NxMonorepoResolver: discovered projects', { count: projects.length });
         return projects;
     }
-    /**
-     * Discover projects from `tsconfig.base.json` `compilerOptions.paths`. Each
-     * alias (e.g. `@scope/interfaces` → `interfaces/src/index.ts`) resolves to a
-     * lib root (the path before `/src/`), which for real Nx libs contains a
-     * project.json. Aliases pointing at non-projects (no project.json/package.json,
-     * e.g. `@env` → `environments/environment.ts`) are skipped.
-     */
     discoverFromTsconfigPaths(rootDir) {
         const tsconfigPath = this.getRootTsConfigPath(rootDir);
         if (!tsconfigPath)
@@ -118,7 +82,7 @@ class NxMonorepoResolver {
             json = this.parseJsonc(fs.readFileSync(tsconfigPath, 'utf-8'));
         }
         catch (err) {
-            this.logger.warn('NxMonorepoResolver: failed to parse tsconfig paths', { file: tsconfigPath, reason: err.message });
+            this.logger.warn('NxMonorepoResolver: failed to parse tsconfig paths', { file: tsconfigPath, err });
             return [];
         }
         const co = json?.compilerOptions ?? {};
@@ -134,13 +98,12 @@ class NxMonorepoResolver {
             const srcIdx = target.indexOf('/src/');
             const relRoot = srcIdx >= 0 ? target.slice(0, srcIdx) : path.dirname(target);
             const libRoot = path.resolve(rootDir, baseUrl, relRoot);
-            const project = this.tryReadProject(libRoot, rootDir); // null unless a real project marker exists
+            const project = this.tryReadProject(libRoot, rootDir);
             if (project)
                 projects.push(project);
         }
         return projects;
     }
-    /** Parse JSON that may contain comments / trailing commas (tsconfig style). */
     parseJsonc(text) {
         try {
             return JSON.parse(text);
@@ -154,17 +117,14 @@ class NxMonorepoResolver {
         }
     }
     getRootTsConfigPath(rootDir) {
-        // Nx convention: tsconfig.base.json at workspace root
         const basePath = path.join(rootDir, 'tsconfig.base.json');
         if (fs.existsSync(basePath))
             return basePath;
-        // Fallback: tsconfig.json at workspace root
         const rootPath = path.join(rootDir, 'tsconfig.json');
         if (fs.existsSync(rootPath))
             return rootPath;
         return null;
     }
-    // ── Private helpers ─────────────────────────────────────────────────────────
     readWorkspaceJson(rootDir) {
         const projects = [];
         for (const filename of ['workspace.json', 'angular.json']) {
@@ -175,9 +135,6 @@ class NxMonorepoResolver {
                 const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
                 const projectsMap = content.projects ?? {};
                 for (const [name, value] of Object.entries(projectsMap)) {
-                    // value can be a string (path) or an object with a `root` property.
-                    // Guard per-entry: a malformed entry (object without `root`) must not
-                    // abort discovery of the remaining projects in this file.
                     const rawRoot = typeof value === 'string'
                         ? value
                         : value?.root;
@@ -196,7 +153,7 @@ class NxMonorepoResolver {
             catch (err) {
                 this.logger.warn('NxMonorepoResolver: failed to parse workspace file', {
                     file: filePath,
-                    reason: err.message,
+                    err,
                 });
             }
         }
@@ -222,14 +179,12 @@ class NxMonorepoResolver {
                 projects.push(project);
                 continue;
             }
-            // Check for nested grouping directories (e.g. libs/shared/utils)
             const nested = this.scanDirectory(projectPath, defaultType, rootDir);
             projects.push(...nested);
         }
         return projects;
     }
     tryReadProject(projectPath, rootDir, defaultType = 'lib') {
-        // Check for project.json (Nx project marker)
         const projectJsonPath = path.join(projectPath, 'project.json');
         const packageJsonPath = path.join(projectPath, 'package.json');
         const hasProjectJson = fs.existsSync(projectJsonPath);
@@ -239,7 +194,6 @@ class NxMonorepoResolver {
         let name = path.relative(rootDir, projectPath).replace(/\\/g, '/');
         let type = defaultType;
         let packageName = null;
-        // Read project.json for name and type
         if (hasProjectJson) {
             try {
                 const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
@@ -253,14 +207,12 @@ class NxMonorepoResolver {
             catch (err) {
                 this.logger.warn('NxMonorepoResolver: failed to parse project.json', {
                     file: projectJsonPath,
-                    reason: err.message,
+                    err,
                 });
             }
         }
-        // Read package.json for npm scope
         if (hasPackageJson) {
             packageName = this.readPackageName(projectPath);
-            // If no project.json name, use package name without scope
             if (!hasProjectJson && packageName) {
                 const shortName = packageName.replace(/^@[^/]+\//, '');
                 name = shortName;
@@ -281,7 +233,6 @@ class NxMonorepoResolver {
         }
     }
     inferProjectType(projectPath, name) {
-        // Check project.json
         const projectJsonPath = path.join(projectPath, 'project.json');
         if (fs.existsSync(projectJsonPath)) {
             try {
@@ -291,15 +242,13 @@ class NxMonorepoResolver {
                 if (projectJson.projectType === 'library')
                     return 'lib';
             }
-            catch { /* fall through */ }
+            catch { }
         }
-        // Infer from path
         const rel = projectPath.replace(/\\/g, '/');
         if (rel.includes('/apps/') || rel.includes('/app/'))
             return 'app';
         if (rel.includes('/libs/') || rel.includes('/lib/') || rel.includes('/packages/'))
             return 'lib';
-        // Infer from name
         if (name.includes('lib') || name.includes('shared') || name.includes('util'))
             return 'lib';
         return 'app';

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

@@ -5,12 +5,6 @@ export interface EmbedderDeps {
     fetchImpl?: typeof fetch;
     baseDelayMs?: number;
 }
-/**
- * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
- * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
- * inputs (`{ input: string[], model, dimensions? }`) and returns
- * `{ data: [{ embedding, index }] }`, re-ordered to input order.
- */
 export declare class OpenAICompatibleEmbedder implements IEmbedder {
     protected config: Config;
     private logger;

package/dist/src/services/OpenAICompatibleEmbedder.js

@@ -6,12 +6,6 @@ const config_1 = require("../config");
 const reranker_1 = require("./reranker");
 const http_retry_1 = require("./http-retry");
 const constants_1 = require("../constants");
-/**
- * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
- * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
- * inputs (`{ input: string[], model, dimensions? }`) and returns
- * `{ data: [{ embedding, index }] }`, re-ordered to input order.
- */
 class OpenAICompatibleEmbedder {
     config;
     logger;
@@ -24,7 +18,6 @@ class OpenAICompatibleEmbedder {
         this.config = config;
         this.logger = logger;
         const base = config.embedding.baseURL.replace(/\/+$/, '');
-        // Allow a baseURL that already includes the path (…/v1) or not.
         this.url = /\/embeddings$/.test(base) ? base : `${base}/embeddings`;
         this.doFetch = deps.fetchImpl ?? fetch;
         this.baseDelayMs = deps.baseDelayMs;
@@ -40,8 +33,6 @@ class OpenAICompatibleEmbedder {
             return [];
         return (0, http_retry_1.withRetry)(async () => {
             const headers = { 'Content-Type': 'application/json' };
-            // Resolve the key lazily — an unset `env:` ref throws here (request time),
-            // not at construction, so `rag-web`/`rag-mcp` still start.
             const apiKey = (0, config_1.resolveEnvRef)(this.config.embedding.apiKey);
             if (apiKey)
                 headers['Authorization'] = `Bearer ${apiKey}`;
@@ -51,7 +42,7 @@ class OpenAICompatibleEmbedder {
             const res = await this.doFetch(this.url, {
                 method: 'POST',
                 headers,
-                signal: AbortSignal.timeout(120_000),
+                signal: AbortSignal.timeout(240_000),
                 body: JSON.stringify(body),
             });
             if (!res.ok) {
@@ -59,13 +50,9 @@ class OpenAICompatibleEmbedder {
                 throw new http_retry_1.HttpError(res.status, `embeddings request failed: ${res.status} ${errBody}`);
             }
             const data = await res.json();
-            // Guard against a partial/mismatched response — a missing vector would
-            // otherwise be inserted as "[undefined]" and fail the whole file, or (with
-            // reordering + no index) silently misalign vectors to the wrong chunks.
             if (!Array.isArray(data.data) || data.data.length !== texts.length) {
                 throw new Error(`embeddings response returned ${data.data?.length ?? 0} vectors for ${texts.length} inputs`);
             }
-            // Sort by `index` so vectors line up with input order regardless of server ordering.
             return [...data.data]
                 .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
                 .map(d => d.embedding);

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

@@ -1,8 +1,4 @@
 import type { IProjectDiscovery, DiscoveredProject } from '../interfaces/IProjectDiscovery';
-/**
- * Default project discovery: finds immediate subdirectories
- * of the workspace root that contain a package.json.
- */
 export declare class ProjectDiscoveryService implements IProjectDiscovery {
     discover(rootDir: string): DiscoveredProject[];
 }

package/dist/src/services/ProjectDiscoveryService.js

@@ -37,10 +37,6 @@ exports.ProjectDiscoveryService = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../file-utils");
-/**
- * Default project discovery: finds immediate subdirectories
- * of the workspace root that contain a package.json.
- */
 class ProjectDiscoveryService {
     discover(rootDir) {
         return fs.readdirSync(rootDir, { withFileTypes: true })

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

@@ -1,9 +1,11 @@
+import * as fs from 'fs';
 import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces';
 import type { IDatabase } from '../interfaces';
-import { type ProjectMeta } from '../file-utils';
+import { type IndexingExclusion, type ProjectMeta } from '../file-utils';
 import type { ILogger } from '../interfaces';
 import type { IProjectDiscovery } from '../interfaces';
+import type { StagedSearchResult } from '../interfaces/ISearcher';
 export interface ChunkRow {
     serviceName: string;
     filePath: string;
@@ -23,6 +25,56 @@ export interface GraphContext {
     imports: string[];
     usedBy: string[];
 }
+export type PathRefusal = {
+    ok: false;
+    reason: 'invalid';
+    missing: boolean;
+} | {
+    ok: false;
+    reason: 'absolute';
+    relative: string;
+} | {
+    ok: false;
+    reason: 'outside_workspace';
+};
+export type ResolvedToolPath = {
+    ok: true;
+    relPath: string;
+    absPath: string;
+} | PathRefusal;
+export type NotIndexedExplanation = IndexingExclusion | {
+    kind: 'no_project';
+} | {
+    kind: 'project_not_indexed';
+    project: string;
+} | {
+    kind: 'unknown';
+};
+export type PathFailure = {
+    ok: false;
+    reason: 'outside_workspace';
+} | {
+    ok: false;
+    reason: 'unreadable';
+    code: string;
+} | {
+    ok: false;
+    reason: 'not_found';
+    candidates: string[];
+} | {
+    ok: false;
+    reason: 'deleted';
+} | {
+    ok: false;
+    reason: 'not_indexed';
+    explanation: NotIndexedExplanation;
+} | {
+    ok: false;
+    reason: 'not_a_file';
+} | {
+    ok: false;
+    reason: 'not_a_directory';
+};
 export type FileRangeResult = {
     ok: true;
     filePath: string;
@@ -30,10 +82,35 @@ export type FileRangeResult = {
     endLine: number;
     lines: string[];
     hasMore: boolean;
+} | PathFailure | {
+    ok: false;
+    reason: 'past_end';
+    lineCount: number;
+    startLine: number;
+} | {
+    ok: false;
+    reason: 'bad_range';
+    startLine: number;
+    endLine: number;
+};
+export type ListFilesResult = {
+    ok: true;
+    tree: string;
+} | PathFailure;
+export type GrepSymbolResult = {
+    ok: true;
+    matches: GrepMatch[];
+    truncated: boolean;
+    partial: boolean;
 } | {
     ok: false;
-    reason: 'not_indexed' | 'not_on_disk' | 'invalid_path';
 };
+export interface SearcherFs {
+    realpath(p: string): Promise<string>;
+    stat(p: string): Promise<fs.Stats>;
+    readdir(p: string): Promise<fs.Dirent[]>;
+    createReadStream(p: string): NodeJS.ReadableStream;
+}
 export interface DependencyRow {
     fromFile: string;
     fromSymbol: string | null;
@@ -42,20 +119,22 @@ export interface DependencyRow {
     depType: string;
     depth?: number;
     via?: string;
+    id?: string;
 }
 export interface ProjectRow extends ProjectMeta {
     serviceName: string;
     chunks: number;
     packageName?: string | null;
     type?: 'app' | 'lib';
-    /** Real filesystem root of the project (resolved via discovery). */
     path?: string;
+    relPath?: string;
+    rootError?: string | null;
 }
 export interface GrepMatch {
     filePath: string;
     line: number;
 }
-export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature' | 'all';
+export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature' | 'graphql_query' | 'graphql_mutation' | 'graphql_subscription' | 'graphql_field' | 'graphql_type' | 'all';
 export interface CallerRow {
     fromFile: string;
     fromSymbol: string | null;
@@ -69,36 +148,52 @@ export interface SymbolHit {
     column: number;
     kind: Exclude<SymbolKind, 'all'>;
     signature: string;
-    /** `container.name`, or `name` when the container is null. */
     qualified: string;
     isStatic: boolean;
     source: 'index' | 'grep';
+    target: string | null;
 }
+export declare function rerankDocument(row: ChunkRow): string;
 export declare class SearcherService {
     private db;
     private embedder;
     private discovery;
     private config;
     private logger;
-    constructor(db: IDatabase, embedder: IEmbedder, discovery: IProjectDiscovery, config: Config, logger?: ILogger);
-    /** Lazily-built, cached map of project name → real filesystem root. */
+    private readonly fs;
+    constructor(db: IDatabase, embedder: IEmbedder, discovery: IProjectDiscovery, config: Config, logger?: ILogger, fsDeps?: Partial<SearcherFs>);
+    private targetColumnPresent;
+    private realRootCache?;
     private rootMap?;
-    /** Cached, lazily-built map of leaf project name → real filesystem root (via discovery). */
+    private pgvectorVersionRead?;
+    private degradedScanWarned;
+    private iterativeScanEnabled;
+    private warnDegradedScan;
     private projectRootMap;
-    /**
-     * Resolve a project name to its real filesystem root. Uses discovery (leaf
-     * projects) so nested-monorepo names like `repo/app` map to their true path;
-     * falls back to `join(workspaceRoot, name)` when the name is unknown (e.g. a
-     * project since removed from disk, or a flat project not surfaced by discovery).
-     */
     private resolveProjectRoot;
-    /**
-     * Project-level dependency edges aggregated from `code_dependency`: an edge
-     * `A → B` means some file in project A imports a file owned by project B.
-     * Used by the graph to draw links between a monorepo's sub-projects. Only
-     * edges whose target file belongs to an indexed project are returned (targets
-     * outside any indexed project — e.g. unindexed libs — are skipped).
-     */
+    private toRel;
+    private toAbs;
+    private workspaceRoot;
+    private realWorkspaceRoot;
+    resolveToolPath(input: string | null | undefined): Promise<ResolvedToolPath>;
+    private realLocation;
+    checkRealLocation(relPath: string, absPath: string, kind: 'file' | 'dir'): Promise<{
+        ok: true;
+    } | Extract<PathFailure, {
+        reason: 'outside_workspace' | 'unreadable';
+    }>>;
+    private pathExists;
+    isIndexedPath(relPath: string): Promise<boolean>;
+    isContentPath(relPath: string): Promise<boolean>;
+    private hasContentUnder;
+    findPathCandidates(relPath: string, kind: 'file' | 'dir'): Promise<string[]>;
+    private candidatesOrNone;
+    private substituteProjectName;
+    private findProjectRootByName;
+    private findProjectRoot;
+    fallbackRoot(relPath: string): string | null;
+    checkGraphPath(relPath: string): Promise<PathFailure | null>;
+    private explainNotIndexed;
     getProjectEdges(): Promise<{
         from: string;
         to: string;
@@ -107,72 +202,34 @@ export declare class SearcherService {
         query: string;
         translated: boolean;
     }>;
-    /**
-     * Refuse when the configured embedding model disagrees with the one that built
-     * the index — embedding a query into a foreign vector space returns noise. A
-     * missing `index_meta` row with an empty (or altogether absent) `code_chunk`
-     * does not block — but a *populated* `code_chunk` with no `index_meta` row is a
-     * pre-`index_meta` install, treated as the legacy `ollama`/`bge-m3` index (same
-     * interpretation as the `rag-index` legacy-Ollama guard), read-only — this check
-     * never writes `index_meta`.
-     */
     assertIndexMatches(): Promise<void>;
     private compareIndexed;
     listProjects(): Promise<ProjectRow[]>;
-    searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
-    /**
-     * Emit one structured search-tuning line (via `logger.metric`, at `info`
-     * regardless of `logging.level`). `candidates` are in cosine order, so a
-     * candidate's array index is its cosine rank — `maxCosineRankSurvived` is the
-     * deepest cosine position that survived reranking into the returned set. Read
-     * it alongside `poolSaturated` to tune `candidateFloor`/`overfetch`/threshold
-     * per hardware. Never logs chunk content, embeddings, or credentials.
-     */
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<SearchResult[]>;
+    searchChunksWithStages(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<StagedSearchResult>;
     private emitSearchMetrics;
     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[]>;
+    getDependencies(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getDependents(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
-    /**
-     * One-line warning when any project in `scope` (the given `project`, or
-     * every project with `code_chunk`/`code_symbol` rows) is outdated — shown
-     * first in `find_symbol`/`get_callers` output. Any failure to determine the
-     * scope or read markers only drops the notice (warn logged); the lookup
-     * itself is unaffected.
-     */
-    outdatedNotice(project: string | null): Promise<string | null>;
-    grepSymbol(symbol: string, project: string, excludeFile: string): Promise<{
-        matches: GrepMatch[];
-        truncated: boolean;
-    }>;
+    grepSymbol(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
         grepFailed: boolean;
     }>;
+    private hasTargetColumn;
     private findSymbolFromIndex;
     private grepFindSymbol;
-    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>;
+    listFiles(relPath: string, depth: number, pattern: string | null): Promise<ListFilesResult>;
+    private openableFile;
+    private readLines;
+    readFile(relPath: string, maxLines: number): Promise<FileRangeResult>;
+    readFileRange(relPath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
     private walkDir;
-    /**
-     * ERE pattern for a grep-fallback kind, or null when that kind is never
-     * grepped (`function_property`/`method_signature` are index-only; a bare
-     * `constructor` search only makes sense when the name itself is `constructor`).
-     */
     private buildFindSymbolPattern;
-    /** 1-based index of the first whole-word occurrence of `name` in `line`, or -1. */
     private static wholeWordIndex;
     private inferKind;
-    /**
-     * Async wrapper around grep to avoid blocking the event loop. `ok: false`
-     * means grep could not be spawned or exited with status ≥ 2 (distinguishable
-     * from a clean "no matches", which is `ok: true, output: null`).
-     */
     private spawnGrep;
 }