codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/indexing/analysis-rows.js

@@ -0,0 +1,65 @@
+"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.workspaceEdges = workspaceEdges;
+exports.workspaceCalls = workspaceCalls;
+exports.toPromptEdges = toPromptEdges;
+const path = __importStar(require("path"));
+function workspaceEdges(rawEdges, workspaceRoot) {
+    return rawEdges
+        .filter(e => e.toFile.startsWith(workspaceRoot))
+        .map(e => ({
+        ...e,
+        fromFile: path.relative(workspaceRoot, e.fromFile),
+        toFile: path.relative(workspaceRoot, e.toFile),
+    }));
+}
+function workspaceCalls(rawCalls, serviceName, relFilePath, workspaceRoot) {
+    return rawCalls
+        .filter(c => c.calleeFile.startsWith(workspaceRoot))
+        .map(c => ({
+        project: serviceName,
+        fromFile: relFilePath,
+        fromSymbol: c.fromSymbol,
+        calleeName: c.calleeName,
+        calleeFile: path.relative(workspaceRoot, c.calleeFile),
+        calleeSymbol: c.calleeSymbol,
+        line: c.line,
+        col: c.col,
+    }));
+}
+function toPromptEdges(edges) {
+    return edges.filter(e => e.depType !== 'import-side-effect');
+}

package/dist/src/indexing/project-notices.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectNotice } from '../interfaces';
+export declare function collectProjectNotices(dir: string, fileCount: number, batchSize: number): ProjectNotice[];

package/dist/src/indexing/project-notices.js

@@ -0,0 +1,63 @@
+"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.collectProjectNotices = collectProjectNotices;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("../file-utils");
+function collectProjectNotices(dir, fileCount, batchSize) {
+    const notices = [];
+    const meta = (0, file_utils_1.readRagMeta)(dir);
+    if (meta === 'invalid') {
+        const msg = `.ragmeta.json found but invalid JSON`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    else if (meta !== 'missing') {
+        const parts = [meta.description, meta.stack && `[${meta.stack}]`].filter(Boolean).join(' ');
+        notices.push({ mark: '✓', message: `.ragmeta.json: ${parts || '(no fields)'}`, warning: false });
+    }
+    else {
+        const msg = `No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    if (!fs.existsSync(path.join(dir, '.ragignore'))) {
+        const msg = `No .ragignore — create one to exclude generated/codegen files (e.g. src/gql/graphql.ts, **/__snapshots__/**)`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    if (fileCount > batchSize) {
+        notices.push({ mark: '⚠', message: `Large project (${fileCount} files) — AST analysis uses batches of ${batchSize}; cross-batch dependency edges may be incomplete`, warning: false });
+    }
+    return notices;
+}

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

@@ -1,3 +1,4 @@
+import type { DeclarationTree } from '../declarations/DeclarationTree';
 export interface DepEdge {
     project: string;
     fromFile: string;
@@ -6,7 +7,8 @@ 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' | 'graphql_query' | 'graphql_mutation' | 'graphql_subscription' | 'graphql_field' | 'graphql_type';
+import type { SymbolKind } from './SymbolKind';
+export type { SymbolKind };
 export interface SymbolEntry {
     project: string;
     filePath: string;
@@ -16,19 +18,9 @@ export interface SymbolEntry {
     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;
-    /**
-     * Qualified TypeScript name of the decorated declaration, set only on
-     * `graphql-symbols` rows (`graphqlNames`); null on every `symbols`/`members` entry.
-     */
     target?: string | null;
-    /**
-     * 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 {
@@ -41,47 +33,19 @@ export interface CallEdge {
     line: number | null;
     col: number | null;
 }
-/**
- * Line range of a named scope used only to compute a chunk's owning declaration
- * (`ownerPath`). Method/constructor/accessor ranges carry their enclosing class
- * as `container`; top-level declarations use `container: null`. These are NOT
- * persisted to `code_symbol` — they exist only for chunk ownership.
- */
-export interface OwnerRange {
-    name: string;
-    container: string | null;
-    line: number;
-    endLine: number;
-}
 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[];
-    /** Ownership ranges (decorator-inclusive) for every indexed declaration except `method_signature`. */
-    ownerRanges?: OwnerRange[];
-    /**
-     * GraphQL-named rows (`@Query`/`@Mutation`/`@Subscription`/`@ResolveField`/
-     * `@ObjectType`/`@InputType`/`@InterfaceType` of `@nestjs/graphql`). Written to
-     * `code_symbol` alongside `symbols`/`members`; never fed to the chunker, the
-     * prompt, `buildOwnerRanges` or `extractCalls` (see `graphql-symbols`).
-     */
+    declarations?: DeclarationTree;
     graphqlNames: SymbolEntry[];
 }
 export interface AnalyzeProjectOpts {
     skipDependencyResolution?: boolean;
-    /** Path to root tsconfig (e.g. tsconfig.base.json) for workspace-wide path aliases */
     rootTsConfigPath?: string;
 }
 export interface IAstParser {
-    /**
-     * @deprecated Use analyzeProject instead for project-wide context.
-     */
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: AnalyzeProjectOpts): Promise<Map<string, FileAnalysis>>;
     clearCache(projectRoot?: string): void;

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

@@ -0,0 +1,28 @@
+export interface CallerRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    calleeName: string;
+    calleeFile: string;
+    line: number | null;
+}
+export type NoCallersCause = {
+    kind: 'no-call-graph';
+} | {
+    kind: 'unknown-symbol';
+    suggestions: string[];
+    truncated: boolean;
+} | {
+    kind: 'no-recorded-calls';
+    definitions: {
+        qualified: string;
+        filePath: string;
+        line: number | null;
+    }[];
+    truncated: boolean;
+} | {
+    kind: 'lookup-failed';
+};
+export interface ICallGraph {
+    getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
+    explainNoCallers(symbol: string, project: string): Promise<NoCallersCause>;
+}

package/dist/src/interfaces/ICallGraph.js

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

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

@@ -0,0 +1,42 @@
+import type { ResolvedThreshold } from '../constants';
+export interface ChunkRow {
+    serviceName: string;
+    filePath: string;
+    startLine: number;
+    content: string;
+    ownerPath?: string | null;
+}
+export interface SearchResult extends ChunkRow {
+    score: number;
+}
+export interface NeighborResult {
+    result: SearchResult;
+    prevChunk: ChunkRow | null;
+    nextChunk: ChunkRow | null;
+}
+export type StageName = 'vector' | 'reranked';
+export interface StagedSearchResult {
+    pool: SearchResult[];
+    stages: {
+        vector: SearchResult[];
+        reranked?: SearchResult[];
+    };
+    rerankFailed: boolean;
+    fetchLimit: number;
+    indexParams: {
+        efSearch: number | null;
+        iterativeScan: string;
+    };
+    threshold: ResolvedThreshold;
+}
+export type NoResultsCause = 'empty-scope' | 'no-candidates' | 'lookup-failed';
+export interface IChunkSearch {
+    prepareQuery(raw: string): Promise<{
+        query: string;
+        translated: boolean;
+    }>;
+    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>;
+    explainNoResults(project: string | null): Promise<NoResultsCause>;
+    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+}

package/dist/src/interfaces/IChunkSearch.js

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

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

@@ -1,24 +1,15 @@
-import type { SymbolEntry } from './IAstParser';
-/** One embeddable unit of source with its 1-based inclusive line range. */
+import type { DeclarationTree } from '../declarations/DeclarationTree';
 export interface ChunkPiece {
     content: string;
     startLine: number;
     endLine: number;
 }
 export interface ChunkOpts {
-    /** 'ast' = symbol-aligned boundaries; 'character' = fixed-size recursive splitter. */
     strategy: 'ast' | 'character';
-    /** Schema files (.prisma/.graphql/.gql) always use the schema separator splitter. */
     isSchemaFile: boolean;
-    /** Top-level symbol ranges for the file; may be empty (no analysis available). */
-    symbols: SymbolEntry[];
+    declarations?: DeclarationTree;
+    jsx?: boolean;
 }
 export interface IChunker {
-    /**
-     * Split source into embeddable pieces. AST strategy aligns boundaries to
-     * top-level declaration ranges and never emits a piece longer than the
-     * configured chunk size; falls back to the character splitter for schema
-     * files, empty-symbol files, or when strategy is 'character'.
-     */
     chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
 }

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

@@ -0,0 +1,7 @@
+export interface ICorpusInspector {
+    headCommit(root: string): Promise<string>;
+    trackedChanges(root: string): Promise<string[]>;
+    untrackedFiles(root: string, skipDirs: readonly string[]): Promise<string[]>;
+    listFiles(dir: string): Promise<string[]>;
+    readFile(absPath: string): Promise<Buffer | null>;
+}

package/dist/src/interfaces/ICorpusInspector.js

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

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

@@ -1,44 +1,28 @@
-import type { DrizzleDb, DrizzleTx } from '../services/DatabaseService';
-/** Single-row record of which embedding model built the current index. */
+import type { DrizzleDb, DrizzleTx } from '../db';
 export interface IndexMeta {
     provider: string;
     model: string;
     dimensions: number;
 }
-/**
- * Database abstraction — services depend on this interface
- * rather than the concrete DatabaseService.
- */
+export interface InitDbOptions {
+    connectionTimeoutMs?: number;
+}
 export interface IDatabase {
     readonly orm: DrizzleDb;
     query<T = any>(sql: string, params?: any[]): Promise<T>;
+    queryWithLocalSettings<T = any>(settings: Record<string, string | number>, sql: string, params?: any[]): Promise<T>;
+    pgvectorVersion(): Promise<string | null>;
     transaction<T>(fn: (tx: DrizzleTx) => Promise<T>): Promise<T>;
-    initDb(): Promise<void>;
+    initDb(options?: InitDbOptions): Promise<void>;
+    probe(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     destroy(): Promise<void>;
-    /** Read the single `index_meta` row, or null when absent (table missing → null). */
     readIndexMeta(): Promise<IndexMeta | null>;
-    /** Upsert the single `index_meta` row. */
     writeIndexMeta(meta: IndexMeta): Promise<void>;
-    /** Create `code_chunk` (+ HNSW/service indexes) at `dimensions` if absent. */
     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>;
 }

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

@@ -0,0 +1,24 @@
+import type { SearchResult } from './IChunkSearch';
+export interface GraphContext {
+    imports: string[];
+    usedBy: string[];
+}
+export interface DependencyRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+    depth?: number;
+    via?: string;
+    id?: string;
+}
+export interface IDependencyGraph {
+    getProjectEdges(): Promise<{
+        from: string;
+        to: string;
+    }[]>;
+    fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
+    getDependencies(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getDependents(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+}

package/dist/src/interfaces/IDependencyGraph.js

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

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

@@ -1,16 +1,7 @@
 export type InputType = 'query' | 'document';
 export interface IEmbedder {
-    /**
-     * The vector width this embedder produces, when known without a probe:
-     * `embedding.dimensions` override → model registry, else `0` for models whose
-     * width is only knowable by embedding once (see `resolveDimension`). Read by
-     * `SearcherService.assertIndexMatches` to catch a dimension change on the
-     * search side (skipped when `0`). Indexing resolves the true width via
-     * `resolveDimension` (which probes when needed), not this field.
-     */
     readonly dimensions: number;
     embed(text: string, inputType?: InputType): Promise<number[]>;
-    /** One vector per input, in input order. The indexing path. */
     embedBatch(texts: string[], inputType?: InputType): Promise<number[][]>;
     rerank?(query: string, documents: string[], topN: number): Promise<number[]>;
     listModels?(): Promise<string[]>;

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

@@ -0,0 +1,3 @@
+export interface IIndexIdentityGuard {
+    assertIndexMatches(): Promise<void>;
+}

package/dist/src/interfaces/IIndexIdentityGuard.js

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

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

@@ -0,0 +1,10 @@
+import type { Node } from 'ts-morph';
+export interface IndexedNodeDescription {
+    name: string;
+    container: string[];
+}
+export interface IIndexedNodeResolver {
+    describeIndexedNode(node: Node): IndexedNodeDescription | null;
+    qualifiedName(described: IndexedNodeDescription): string;
+    findFromSymbol(node: Node): string | null;
+}

package/dist/src/interfaces/IIndexedNodeResolver.js

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

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

@@ -1,17 +1,7 @@
-/**
- * Logger abstraction — allows services to depend on a contract
- * rather than the concrete pino-based LoggerService.
- */
 export interface ILogger {
     debug(msg: string, data?: Record<string, unknown>): void;
     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;
+    withContext<T>(context: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
 }

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

@@ -0,0 +1,12 @@
+export interface ReadinessFailure {
+    ok: false;
+    err: unknown;
+}
+export type ReadinessCheck = {
+    ok: true;
+} | ReadinessFailure;
+export interface IMcpReadiness {
+    start(): Promise<ReadinessCheck>;
+    ensureReady(): Promise<ReadinessCheck>;
+    readonly ready: boolean;
+}

package/dist/src/interfaces/IMcpReadiness.js

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

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

@@ -1,8 +1,3 @@
-/**
- * MCP Tool Handler interface — each tool implements this contract.
- * Follows the Open/Closed Principle: new tools are added by implementing
- * this interface and registering them, not by modifying McpServer.
- */
 export interface ToolDefinition {
     name: string;
     description: string;

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

@@ -1,33 +1,11 @@
-/**
- * Represents a discovered project within a monorepo workspace.
- */
 export interface MonorepoProject {
-    /** Project name (e.g. "my-app", "shared-utils") */
     name: string;
-    /** Absolute path to the project root */
     path: string;
-    /** npm scope + package name (e.g. "@scope/my-app") — null if no package.json or no name */
     packageName: string | null;
-    /** "app" | "lib" — derived from project.json or directory convention */
     type: 'app' | 'lib';
 }
-/**
- * Monorepo resolver — detects and resolves workspace structure.
- * Implementations handle specific monorepo tooling (Nx, Turborepo, etc.)
- */
 export interface IMonorepoResolver {
-    /**
-     * Detect whether the given root directory is a monorepo workspace.
-     */
     isMonorepo(rootDir: string): boolean;
-    /**
-     * Discover all projects (apps + libs) in the monorepo.
-     */
     discoverProjects(rootDir: string): MonorepoProject[];
-    /**
-     * Get the root tsconfig path that contains workspace-wide path aliases.
-     * For Nx this is typically tsconfig.base.json at the workspace root.
-     * The AST parser uses this to resolve cross-project imports (@scope/*).
-     */
     getRootTsConfigPath(rootDir: string): string | null;
 }

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

@@ -0,0 +1,13 @@
+import type { ProjectMeta } from '../file-utils';
+export interface ProjectRow extends ProjectMeta {
+    serviceName: string;
+    chunks: number;
+    packageName?: string | null;
+    type?: 'app' | 'lib';
+    path?: string;
+    relPath?: string;
+    rootError?: string | null;
+}
+export interface IProjectCatalog {
+    listProjects(): Promise<ProjectRow[]>;
+}

package/dist/src/interfaces/IProjectCatalog.js

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

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

@@ -1,28 +1,11 @@
 export interface DiscoveredProject {
     name: string;
     path: string;
-    /** npm scope + package name (e.g. "@scope/my-app") — only set for monorepo projects */
     packageName?: string | null;
-    /** "app" | "lib" — only set for monorepo projects */
     type?: 'app' | 'lib';
-    /**
-     * Path to the workspace-wide tsconfig (e.g. tsconfig.base.json) that holds
-     * cross-project path aliases. Set for monorepo projects; undefined for flat
-     * workspaces (where each project uses its own local tsconfig.json).
-     */
     rootTsConfigPath?: string | null;
-    /**
-     * When a top-level directory is itself a nested monorepo (e.g. an Nx repo
-     * under a flat workspaceRoot), this holds its expanded sub-projects. The
-     * repo stays a single selectable unit; `toLeafProjects` expands `children`
-     * into the actual projects to index. Absent/undefined for ordinary projects.
-     */
     children?: DiscoveredProject[];
 }
-/**
- * Project discovery abstraction — decouples project enumeration
- * from the indexing service (Single Responsibility Principle).
- */
 export interface IProjectDiscovery {
     discover(rootDir: string): DiscoveredProject[];
 }

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

@@ -0,0 +1,3 @@
+export interface IProjectRoots {
+    fallbackRoot(relPath: string): string | null;
+}

package/dist/src/interfaces/IProjectRoots.js

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