codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

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

@@ -1,19 +1,30 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { Config } from '../config';
 import type { ISearcher } from '../interfaces/ISearcher';
 import type { ILogger } from '../interfaces/ILogger';
 import type { IMcpToolHandler, ToolResponse } from '../interfaces/IMcpToolHandler';
-/**
- * The dispatch logic behind `CallToolRequestSchema` — pulled out so it is testable
- * without a live stdio transport. A rejecting handler becomes `Tool error: <message>`.
- */
 export declare function dispatchTool(tools: Map<string, IMcpToolHandler>, name: string, args: Record<string, unknown>, logger: ILogger): Promise<ToolResponse>;
+export interface ToolCallRequest {
+    name: string;
+    arguments?: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
+}
+export interface ToolCaller {
+    callId: number;
+    session: string | null;
+    client: {
+        name: string;
+        version: string;
+    } | null;
+    startupError?: Error;
+}
+export declare function handleToolCall(tools: Map<string, IMcpToolHandler>, req: ToolCallRequest, signal: AbortSignal, caller: ToolCaller, logger: ILogger): Promise<ToolResponse>;
+export declare function createToolCallHandler(tools: Map<string, IMcpToolHandler>, server: Pick<Server, 'getClientVersion'>, identity: Pick<ToolCaller, 'session' | 'startupError'>, logger: ILogger): (req: {
+    params: ToolCallRequest;
+}, extra: {
+    signal: AbortSignal;
+}) => Promise<ToolResponse>;
 export declare function buildInstructions(t: number): string;
-/**
- * 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;
@@ -22,9 +33,6 @@ export declare class McpServer {
     private readonly tools;
     constructor(searcher: ISearcher, config: Config, logger: ILogger);
     start(startupError?: Error): Promise<void>;
-    /**
-     * Factory method: creates and registers all tool handlers.
-     * New tools are added here without modifying the dispatch logic above.
-     */
+    createServer(startupError?: Error): Server;
     private createTools;
 }

package/dist/src/services/McpServer.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpServer = void 0;
 exports.dispatchTool = dispatchTool;
+exports.handleToolCall = handleToolCall;
+exports.createToolCallHandler = createToolCallHandler;
 exports.buildInstructions = buildInstructions;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -42,6 +44,8 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const tools_1 = require("../tools");
+const tool_call_log_1 = require("../tool-call-log");
+const error_record_1 = require("../error-record");
 function readPackageVersion() {
     try {
         return JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8')).version ?? '0.0.0';
@@ -50,10 +54,6 @@ function readPackageVersion() {
         return '0.0.0';
     }
 }
-/**
- * The dispatch logic behind `CallToolRequestSchema` — pulled out so it is testable
- * without a live stdio transport. A rejecting handler becomes `Tool error: <message>`.
- */
 async function dispatchTool(tools, name, args, logger) {
     const handler = tools.get(name);
     if (!handler) {
@@ -63,11 +63,63 @@ async function dispatchTool(tools, name, args, logger) {
         return await handler.handle(args);
     }
     catch (err) {
+        logger.error('McpServer: tool handler error', { tool: name, err });
         const reason = err instanceof Error ? err.message : String(err);
-        logger.error('McpServer: tool handler error', { tool: name, reason });
         return { isError: true, content: [{ type: 'text', text: `Tool error: ${reason}` }] };
     }
 }
+function unavailableResponse(startupError) {
+    return {
+        isError: true,
+        content: [{
+                type: 'text',
+                text: `MCP server is unavailable: ${(0, error_record_1.errorMessage)(startupError)}\n\nCheck the log file and fix the issue, then restart the MCP server.`,
+            }],
+    };
+}
+function metaForLog(meta) {
+    if (!meta)
+        return null;
+    const { progressToken: _, ...rest } = meta;
+    return Object.keys(rest).length ? (0, tool_call_log_1.truncateForLog)(rest) : null;
+}
+async function handleToolCall(tools, req, signal, caller, logger) {
+    const t0 = Date.now();
+    const toolUseId = req._meta?.['claudecode/toolUseId'];
+    const context = typeof toolUseId === 'string' ? { callId: caller.callId, toolUseId } : { callId: caller.callId };
+    return logger.withContext(context, async () => {
+        const args = req.arguments ?? {};
+        const response = caller.startupError
+            ? unavailableResponse(caller.startupError)
+            : await dispatchTool(tools, req.name, args, logger);
+        const ms = Date.now() - t0;
+        if (!response.isError)
+            logger.debug('McpServer: tool handled', { tool: req.name, ms });
+        logger.info('tool call', {
+            tool: req.name,
+            args: (0, tool_call_log_1.truncateForLog)(args),
+            isError: response.isError ?? false,
+            responseChars: response.content.reduce((n, c) => n + (typeof c.text === 'string' ? c.text.length : 0), 0),
+            ms,
+            client: caller.client,
+            session: caller.session,
+            meta: metaForLog(req._meta),
+            ...(signal.aborted ? { cancelled: true } : {}),
+        });
+        return response;
+    });
+}
+function createToolCallHandler(tools, server, identity, logger) {
+    let nextCallId = 1;
+    return (req, extra) => {
+        const client = server.getClientVersion();
+        return handleToolCall(tools, req.params, extra.signal, {
+            ...identity,
+            callId: nextCallId++,
+            client: client ? { name: client.name, version: client.version } : null,
+        }, logger);
+    };
+}
 function buildInstructions(t) {
     return `
 You have access to a local code intelligence server. Use these tools to search codebases by meaning, navigate import graphs, look up symbol definitions, and read source files.
@@ -91,7 +143,7 @@ Pick one workflow based on what you need:
 Every file or directory argument (\`file_path\`, \`callee_file\`, \`path\`) is workspace-relative, exactly as printed by search_codebase (e.g. \`my-app/src/index.ts\`; \`.\` is the workspace root) — copy paths between tools unchanged.
 
 - **list_projects** — call this first to see what projects are indexed, their exact names and their directories (\`path:\`).
-- **search_codebase** — semantic search across indexed source files. Returns file path, line number, and a code chunk. **Pass \`project\` whenever the target project is known or guessable from the question** — this workspace indexes many projects at once, and an unscoped query competes against all of them, which \`rerank\` cannot fix (reranking only reorders whatever the vector search already retrieved). Pass \`rerank: false\` for "what does X do" / "where is X" lookups described without an exact name — measurement shows reranking hurts these (-0.23 to -0.31 MRR@10). If you already know the exact symbol name, use \`find_symbol\` instead, not \`search_codebase\` — it is faster and exact, and the rerank setting does not matter there. Leave reranking at its default (omit \`rerank\`, or pass \`true\`) for conceptual/architectural queries, where it helps (+0.08 MRR@10).
+- **search_codebase** — semantic search across indexed source files. Returns file path, line number, and a code chunk. **Pass \`project\` whenever the target project is known or guessable from the question** — this workspace indexes many projects at once, and an unscoped query competes against all of them, which \`rerank\` cannot fix (reranking only reorders whatever the vector search already retrieved). Pass \`rerank: false\` for "what does X do" / "where is X" lookups described without an exact name — measurement shows reranking hurts these (-0.13 MRR@10, hit@5 68% → 50%). If you already know the exact symbol name, use \`find_symbol\` instead, not \`search_codebase\` — it is faster and exact, and the rerank setting does not matter there. For conceptual/architectural queries reranking is roughly neutral (-0.05 MRR@10, not significant), so omitting \`rerank\` is fine.
 - **read_file_range** — read a specific line range from any file under the workspace, indexed or not.
 - **get_dependencies** — show what files a given file imports (direct or transitive). Use to understand what a file depends on.
 - **get_dependents** — show which files import a given file (reverse graph). Use before refactoring to find all callers.
@@ -106,7 +158,7 @@ Every file or directory argument (\`file_path\`, \`callee_file\`, \`path\`) is w
 1. Use \`list_projects\` to discover available projects before filtering by \`project\`.
 2. Use \`search_codebase\` to find relevant code by meaning. **Always pass \`project\` when the question names or implies one** — an unscoped search ranks candidates across every indexed project together, so an unrelated project's weak match can outrank the right project's real one. If your query uses an ambiguous term (e.g. "subscription" could mean pub/sub or billing), pass a lower \`threshold\` (e.g. \`0.40–0.45\`) to filter out weak matches.
 3. If a result looks **truncated or incomplete**, call \`read_file_range\` with the returned \`file_path\` and \`start_line\`.
-4. For exploratory searches where results span chunk boundaries, pass \`include_neighbors: true\`.
+4. For exploratory searches where results span chunk boundaries, pass \`include_neighbors: true\`. Results hold at most 2 chunks per file by default; pass \`per_file\` (e.g. \`5\`) when several answers are expected in one file, such as several methods of one class.
 5. To immediately see a file's imports and callers without extra tool calls, pass \`include_graph_context: true\` to \`search_codebase\`. Use this when doing a quick structural survey; switch to \`get_dependencies\`/\`get_dependents\` for full transitive graphs.
 6. Use \`find_symbol\` when you know the exact name — faster and exact, unlike semantic search. Use a qualified name (\`Class.method\`) to disambiguate same-named methods of different classes; a bare name searches every container. When you also want surrounding context (callers' intent, nearby helpers, how it's described elsewhere), call \`search_codebase\` in parallel rather than after — the two tools answer different questions and neither blocks the other. Hits marked \`(grep — not in index; may be stale or imprecise)\` come from a fallback text search, not the index — treat them as less reliable. After locating a symbol, use \`get_callers\` to find all call sites — faster and more precise than grep. For a NestJS GraphQL operation, resolve field or type, pass the matching \`graphql_query\`/\`graphql_mutation\`/\`graphql_subscription\`/\`graphql_field\`/\`graphql_type\` kind to look it up by the name the schema exposes, not the TypeScript declaration name.
 7. Use \`list_files\` to explore project structure before diving into files. Use \`read_file\` to read a complete file.
@@ -135,7 +187,7 @@ Every file or directory argument (\`file_path\`, \`callee_file\`, \`path\`) is w
 
 ## Dependency graph
 
-\`get_dependencies\` and \`get_dependents\` take \`file_path\` alone and list edges in every project. A path that names no file is an error, never an empty result. Pass \`transitive: true\` for the full dependency chain. depType values: \`import\` | \`import-default\` | \`import-namespace\` | \`import-side-effect\` | \`reexport\` | \`reexport-namespace\`. \`fromSymbol\` — the top-level class or function in the importing file that uses this import (null if ambiguous or not tracked).
+\`get_dependencies\` and \`get_dependents\` take \`file_path\` alone and list edges in every project. A path that names no file is an error, never an empty result. Pass \`transitive: true\` for the full dependency chain. The direct section prints one line per file, with the names imported from/by it (\`default\` / \`* as namespace\` / \`side-effect\` standing in for a nameless import, re-exports grouped after plain imports under one \`re-export \` prefix, \`export *\` for a namespace re-export); \`get_dependents\` also lists the enclosing declarations (\`· in \`PlansPage\`\`) that use the import — only those resolved unambiguously (a binding used in 2+ declarations yields none), so the list can be partial or absent.
 
 If \`get_dependents\` returns 0 results, add \`symbol\` (the exported name you care about) — this triggers a grep fallback that finds runtime usages in DI containers, string references, and dynamic lookups that the import graph misses.
 
@@ -144,12 +196,6 @@ If \`get_dependents\` returns 0 results, add \`symbol\` (the exported name you c
 Lower score = better match (cosine distance). Results above the configured threshold are filtered out automatically. Treat scores above 0.50 as weak hints — verify with \`read_file_range\` or \`Grep\`. Pass \`threshold\` to \`search_codebase\` to override per-query: \`0.40–0.45\` for precise technical queries (known term, exact concept); \`${t}\` default (broad but reliable). Avoid \`0.35\` — too strict for DSL files (GraphQL, Prisma) and infrastructure code.
 `.trim();
 }
-/**
- * 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().
- */
 class McpServer {
     searcher;
     config;
@@ -165,35 +211,22 @@ class McpServer {
     }
     async start(startupError) {
         if (startupError) {
-            this.logger.error('McpServer: startup failed, server will report error on every tool call', { reason: startupError.message });
+            this.logger.error('McpServer: startup failed, server will report error on every tool call', { err: startupError });
         }
+        await this.createServer(startupError).connect(new stdio_js_1.StdioServerTransport());
+        this.logger.info('McpServer: started', { version: this.version });
+    }
+    createServer(startupError) {
         const server = new index_js_1.Server({ name: 'local-rag', version: this.version }, { capabilities: { tools: {} }, instructions: buildInstructions(this.config.search.similarityThreshold) });
         server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
             tools: [...this.tools.values()].map(t => t.definition()),
         }));
-        server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
-            if (startupError) {
-                return {
-                    isError: true,
-                    content: [{
-                            type: 'text',
-                            text: `MCP server is unavailable: ${startupError.message}\n\nCheck the log file and fix the issue, then restart the MCP server.`,
-                        }],
-                };
-            }
-            const t0 = Date.now();
-            const result = await dispatchTool(this.tools, req.params.name, (req.params.arguments ?? {}), this.logger);
-            if (!result.isError)
-                this.logger.debug('McpServer: tool handled', { tool: req.params.name, ms: Date.now() - t0 });
-            return result;
-        });
-        await server.connect(new stdio_js_1.StdioServerTransport());
-        this.logger.info('McpServer: started', { version: this.version });
+        server.setRequestHandler(types_js_1.CallToolRequestSchema, createToolCallHandler(this.tools, server, {
+            session: (0, tool_call_log_1.resolveSession)(process.env),
+            startupError,
+        }, this.logger));
+        return server;
     }
-    /**
-     * Factory method: creates and registers all tool handlers.
-     * New tools are added here without modifying the dispatch logic above.
-     */
     createTools() {
         const handlers = [
             new tools_1.ListProjectsTool(this.searcher),

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

@@ -6,57 +6,13 @@ export interface WorkspaceInfo {
     rootTsConfigPath: string | null;
     projects: DiscoveredProject[];
 }
-/**
- * Expand discovery units into the leaf projects to index: a nested monorepo
- * unit (with `children`) becomes its sub-projects; an ordinary project stays
- * itself. Shared by IndexCommand (indexing loop) and SearcherService (name→path
- * resolution) so both agree on the leaf set.
- */
 export declare function toLeafProjects(projects: DiscoveredProject[]): DiscoveredProject[];
-/**
- * Project discovery that is monorepo-aware.
- *
- * When a monorepo is detected (via the resolver), it uses the resolver
- * to discover projects. Otherwise, it falls back to the original
- * flat-workspace discovery (directories with package.json). Cross-project
- * import resolution relies on the tsconfig `paths` attached via
- * `rootTsConfigPath` — no separate scope map is built.
- *
- * Single Responsibility: only discovers projects and workspace metadata.
- * Does not index or search.
- *
- * Implements {@link IProjectDiscovery} so it can be wired as the default
- * discovery in the container. `discover()` returns one entry per top-level
- * project: when the root itself is a monorepo, each entry carries the
- * workspace-wide `rootTsConfigPath`; under a flat root, an ordinary project
- * gets `rootTsConfigPath: null`, while a top-level directory that is itself a
- * nested monorepo is returned as a single unit with expanded `children` (see
- * `toLeafProjects`). `analyzeWorkspace()` exposes the full workspace metadata
- * (monorepo flag, root tsconfig, project list).
- */
 export declare class MonorepoAwareDiscoveryService implements IProjectDiscovery {
     private resolvers;
     private logger;
-    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
     private flatDiscovery;
-    constructor(resolvers: IMonorepoResolver[], logger: ILogger, 
-    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
-    flatDiscovery?: IProjectDiscovery);
-    /**
-     * IProjectDiscovery contract: enumerate projects in the workspace.
-     * Attaches the workspace-wide root tsconfig to every project so the
-     * indexer can resolve cross-project path aliases.
-     */
+    constructor(resolvers: IMonorepoResolver[], logger: ILogger, flatDiscovery?: IProjectDiscovery);
     discover(rootDir: string): DiscoveredProject[];
-    /**
-     * If `project`'s directory is itself a monorepo (resolver detects it),
-     * return it with expanded `children` named `<repo>/<sub-project>`, each
-     * carrying the repo's workspace-wide tsconfig. Otherwise return it unchanged.
-     */
     private expandIfNestedMonorepo;
-    /**
-     * Analyze the workspace root and return full workspace information:
-     * monorepo detection flag, root tsconfig path, and project list.
-     */
     analyzeWorkspace(rootDir: string): WorkspaceInfo;
 }

package/dist/src/services/MonorepoAwareDiscoveryService.js

@@ -3,71 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MonorepoAwareDiscoveryService = void 0;
 exports.toLeafProjects = toLeafProjects;
 const ProjectDiscoveryService_1 = require("./ProjectDiscoveryService");
-/**
- * Expand discovery units into the leaf projects to index: a nested monorepo
- * unit (with `children`) becomes its sub-projects; an ordinary project stays
- * itself. Shared by IndexCommand (indexing loop) and SearcherService (name→path
- * resolution) so both agree on the leaf set.
- */
 function toLeafProjects(projects) {
     return projects.flatMap(p => (p.children && p.children.length > 0 ? p.children : [p]));
 }
-/**
- * Project discovery that is monorepo-aware.
- *
- * When a monorepo is detected (via the resolver), it uses the resolver
- * to discover projects. Otherwise, it falls back to the original
- * flat-workspace discovery (directories with package.json). Cross-project
- * import resolution relies on the tsconfig `paths` attached via
- * `rootTsConfigPath` — no separate scope map is built.
- *
- * Single Responsibility: only discovers projects and workspace metadata.
- * Does not index or search.
- *
- * Implements {@link IProjectDiscovery} so it can be wired as the default
- * discovery in the container. `discover()` returns one entry per top-level
- * project: when the root itself is a monorepo, each entry carries the
- * workspace-wide `rootTsConfigPath`; under a flat root, an ordinary project
- * gets `rootTsConfigPath: null`, while a top-level directory that is itself a
- * nested monorepo is returned as a single unit with expanded `children` (see
- * `toLeafProjects`). `analyzeWorkspace()` exposes the full workspace metadata
- * (monorepo flag, root tsconfig, project list).
- */
 class MonorepoAwareDiscoveryService {
     resolvers;
     logger;
     flatDiscovery;
-    constructor(resolvers, logger, 
-    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
-    flatDiscovery = new ProjectDiscoveryService_1.ProjectDiscoveryService()) {
+    constructor(resolvers, logger, flatDiscovery = new ProjectDiscoveryService_1.ProjectDiscoveryService()) {
         this.resolvers = resolvers;
         this.logger = logger;
         this.flatDiscovery = flatDiscovery;
     }
-    /**
-     * IProjectDiscovery contract: enumerate projects in the workspace.
-     * Attaches the workspace-wide root tsconfig to every project so the
-     * indexer can resolve cross-project path aliases.
-     */
     discover(rootDir) {
         const workspace = this.analyzeWorkspace(rootDir);
-        // Case A: workspaceRoot itself is a monorepo — attach the workspace-wide
-        // tsconfig to every project (original behavior).
         if (workspace.isMonorepo) {
             return workspace.projects.map(p => ({ ...p, rootTsConfigPath: workspace.rootTsConfigPath }));
         }
-        // Case B: flat workspaceRoot — a top-level project directory may itself be a
-        // nested monorepo (e.g. an Nx repo). Expand such a directory into its
-        // sub-projects as `children`, keeping the repo a single selectable unit.
         return workspace.projects.map(p => this.expandIfNestedMonorepo(p));
     }
-    /**
-     * If `project`'s directory is itself a monorepo (resolver detects it),
-     * return it with expanded `children` named `<repo>/<sub-project>`, each
-     * carrying the repo's workspace-wide tsconfig. Otherwise return it unchanged.
-     */
     expandIfNestedMonorepo(project) {
-        // Ordinary flat project — preserve the original contract (null root tsconfig).
         const flat = { ...project, rootTsConfigPath: null };
         const resolver = this.resolvers.find(r => r.isMonorepo(project.path));
         if (!resolver)
@@ -89,10 +44,6 @@ class MonorepoAwareDiscoveryService {
         });
         return { ...project, children };
     }
-    /**
-     * Analyze the workspace root and return full workspace information:
-     * monorepo detection flag, root tsconfig path, and project list.
-     */
     analyzeWorkspace(rootDir) {
         for (const resolver of this.resolvers) {
             if (resolver.isMonorepo(rootDir)) {
@@ -112,7 +63,6 @@ class MonorepoAwareDiscoveryService {
                 return { isMonorepo: true, rootTsConfigPath, projects };
             }
         }
-        // Fallback: flat workspace (original behavior) — delegated to the default discovery.
         this.logger.debug('MonorepoAwareDiscovery: no monorepo detected, using flat discovery', { rootDir });
         const projects = this.flatDiscovery.discover(rootDir);
         return {

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

@@ -1,40 +1,11 @@
 import type { IMonorepoResolver, MonorepoProject } from '../interfaces/IMonorepoResolver';
 import type { ILogger } from '../interfaces';
-/**
- * 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.
- */
 export declare class NxMonorepoResolver implements IMonorepoResolver {
     private logger;
     constructor(logger: ILogger);
     isMonorepo(rootDir: string): boolean;
     discoverProjects(rootDir: string): MonorepoProject[];
-    /**
-     * 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.
-     */
     private discoverFromTsconfigPaths;
-    /** Parse JSON that may contain comments / trailing commas (tsconfig style). */
     private parseJsonc;
     getRootTsConfigPath(rootDir: string): string | null;
     private readWorkspaceJson;

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;