codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/tools/GetDependenciesTool.js

@@ -1,45 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDependenciesTool = void 0;
+const zod_1 = require("zod");
 const format_helpers_1 = require("./format-helpers");
-class GetDependenciesTool {
-    searcher;
-    logger;
-    constructor(searcher, logger) {
-        this.searcher = searcher;
-        this.logger = logger;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const tool_args_1 = require("./tool-args");
+const ARGS = zod_1.z.object({
+    file_path: (0, tool_args_1.pathArg)((0, format_helpers_1.pathArgDescription)()),
+    symbol: (0, tool_args_1.optionalText)('Filter direct dependencies to named imports of this name (optional). Only named imports match, so default, namespace, side-effect and `export *` imports never match it; indirect (transitive) rows are not filtered by it.'),
+    transitive: (0, tool_args_1.flag)('Include transitive (indirect) dependencies. Default: false.'),
+});
+class GetDependenciesTool extends McpTool_1.McpTool {
+    paths;
+    dependencies;
+    constructor(paths, dependencies, logger) {
+        super({
             name: 'get_dependencies',
             description: 'Show what files a given file imports (direct or transitive), in any project. Use to understand what a file depends on before modifying it. The direct section prints one line per imported file, with the names imported from it.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file_path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)() },
-                    symbol: { type: 'string', description: 'Filter to a specific imported symbol name (optional)' },
-                    transitive: { type: 'boolean', description: 'Include transitive (indirect) dependencies. Default: false.' },
-                },
-                required: ['file_path'],
-            },
-        };
+            args: ARGS,
+        }, logger);
+        this.paths = paths;
+        this.dependencies = dependencies;
     }
-    async handle(args) {
-        const input = args.file_path == null ? '' : String(args.file_path);
-        const symbol = args.symbol ? String(args.symbol) : null;
-        const transitive = Boolean(args.transitive);
-        const resolved = await this.searcher.resolveToolPath(input);
+    async run(args) {
+        const input = args.file_path;
+        const symbol = args.symbol ?? null;
+        const transitive = args.transitive ?? false;
+        const resolved = await this.paths.resolveToolPath(input);
         if (!resolved.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependencies', 'file_path', input, input, resolved);
         const filePath = resolved.relPath;
-        const rows = await this.searcher.getDependencies(filePath, symbol, transitive);
+        const rows = await this.dependencies.getDependencies(filePath, symbol, transitive);
         if (rows.length === 0) {
-            const failure = await this.searcher.checkGraphPath(filePath);
+            const failure = await this.paths.checkGraphPath(filePath);
             if (failure)
                 return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependencies', 'file_path', input, filePath, failure);
-            return (0, format_helpers_1.textResponse)(`No dependencies found for: ${filePath}`);
         }
-        return (0, format_helpers_1.textResponse)((0, format_helpers_1.formatDependencies)(filePath, rows, transitive));
+        if (symbol && !rows.some(r => (r.depth ?? 1) === 1)) {
+            const unfiltered = await this.dependencies.getDependencies(filePath, null, false);
+            if (unfiltered.length > 0) {
+                const miss = (0, format_helpers_1.formatDependenciesFilterMiss)(filePath, symbol, unfiltered);
+                const indirect = (0, format_helpers_1.formatTransitiveSection)(rows, symbol, 'dependencies');
+                return (0, format_helpers_1.textResponse)(indirect ? `${miss}\n\n${indirect}` : miss);
+            }
+        }
+        if (rows.length === 0)
+            return (0, format_helpers_1.textResponse)(`No dependencies found for: ${filePath}`);
+        return (0, format_helpers_1.textResponse)((0, format_helpers_1.formatDependencies)(filePath, rows, transitive, symbol));
     }
 }
 exports.GetDependenciesTool = GetDependenciesTool;

package/dist/src/tools/GetDependentsTool.d.ts

@@ -1,10 +1,22 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IToolPaths } from '../interfaces/IToolPaths';
+import type { IDependencyGraph } from '../interfaces/IDependencyGraph';
+import type { IProjectRoots } from '../interfaces/IProjectRoots';
+import type { ISymbolLookup } from '../interfaces/ISymbolLookup';
 import type { ILogger } from '../interfaces/ILogger';
-export declare class GetDependentsTool implements IMcpToolHandler {
-    private searcher;
-    private logger;
-    constructor(searcher: ISearcher, logger: ILogger);
-    definition(): ToolDefinition;
-    handle(args: Record<string, unknown>): Promise<ToolResponse>;
+import { McpTool } from './McpTool';
+declare const ARGS: z.ZodObject<{
+    file_path: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    symbol: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    transitive: z.ZodType<boolean | undefined, unknown, z.core.$ZodTypeInternals<boolean | undefined, unknown>>;
+}, z.core.$strip>;
+export declare class GetDependentsTool extends McpTool<typeof ARGS> {
+    private paths;
+    private dependencies;
+    private roots;
+    private symbols;
+    constructor(paths: IToolPaths, dependencies: IDependencyGraph, roots: IProjectRoots, symbols: ISymbolLookup, logger: ILogger);
+    protected run(args: z.output<typeof ARGS>): Promise<ToolResponse>;
 }
+export {};

package/dist/src/tools/GetDependentsTool.js

@@ -1,53 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDependentsTool = void 0;
+const zod_1 = require("zod");
+const symbol_name_1 = require("../symbol-name");
 const format_helpers_1 = require("./format-helpers");
-class GetDependentsTool {
-    searcher;
-    logger;
-    constructor(searcher, logger) {
-        this.searcher = searcher;
-        this.logger = logger;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const tool_args_1 = require("./tool-args");
+const ARGS = zod_1.z.object({
+    file_path: (0, tool_args_1.pathArg)((0, format_helpers_1.pathArgDescription)()),
+    symbol: (0, tool_args_1.optionalText)('Exported symbol name. Two behaviors: (1) narrows direct graph dependents to named imports of this symbol — only named imports match, so default, namespace, side-effect and `export *` imports never match it, and indirect (transitive) rows are not filtered by it; (2) if no graph row remains after the filter, triggers a whole-word text-search fallback (grep -F -w) across all .ts/.tsx/.js/.jsx files of the project owning the file to find runtime usages — DI containers, singletons, dynamic lookups, string references. Capped at 200 matches.'),
+    transitive: (0, tool_args_1.flag)('Include transitive (indirect) dependents. Default: false.'),
+});
+class GetDependentsTool extends McpTool_1.McpTool {
+    paths;
+    dependencies;
+    roots;
+    symbols;
+    constructor(paths, dependencies, roots, symbols, logger) {
+        super({
             name: 'get_dependents',
             description: 'Show which files import a given file (reverse graph), in any project. Use before refactoring to find all callers and avoid breaking changes. The direct section prints one line per importing file, with the names imported and the enclosing declarations that use them — only those resolved unambiguously, so the list can be partial or absent.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file_path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)() },
-                    symbol: { type: 'string', description: 'Exported symbol name. Two behaviors: (1) if graph dependents exist, narrows them to imports of this symbol; (2) if the import graph returns zero results, triggers a whole-word text-search fallback (grep -F -w) across all .ts/.tsx/.js/.jsx files of the project owning the file to find runtime usages — DI containers, singletons, dynamic lookups, string references. Capped at 200 matches.' },
-                    transitive: { type: 'boolean', description: 'Include transitive (indirect) dependents. Default: false.' },
-                },
-                required: ['file_path'],
-            },
-        };
+            args: ARGS,
+        }, logger);
+        this.paths = paths;
+        this.dependencies = dependencies;
+        this.roots = roots;
+        this.symbols = symbols;
     }
-    async handle(args) {
-        const input = args.file_path == null ? '' : String(args.file_path);
-        const symbol = args.symbol ? String(args.symbol) : null;
-        const transitive = Boolean(args.transitive);
-        const resolved = await this.searcher.resolveToolPath(input);
+    async run(args) {
+        const input = args.file_path;
+        const symbol = args.symbol ?? null;
+        const transitive = args.transitive ?? false;
+        if (symbol && symbol.length > symbol_name_1.MAX_GREPPED_NAME_LEN)
+            return (0, format_helpers_1.errorResponse)('Invalid symbol name');
+        const resolved = await this.paths.resolveToolPath(input);
         if (!resolved.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependents', 'file_path', input, input, resolved);
         const filePath = resolved.relPath;
-        const rows = await this.searcher.getDependents(filePath, symbol, transitive);
-        if (rows.length > 0) {
-            return (0, format_helpers_1.textResponse)((0, format_helpers_1.formatDependents)(filePath, rows, transitive));
+        const rows = await this.dependencies.getDependents(filePath, symbol, transitive);
+        if (rows.length === 0) {
+            const failure = await this.paths.checkGraphPath(filePath);
+            if (failure)
+                return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependents', 'file_path', input, filePath, failure);
+        }
+        let header = `**Dependents of** \`${filePath}\`\n\n**Direct:** No direct import dependents found.`;
+        if (symbol && !rows.some(r => (r.depth ?? 1) === 1)) {
+            const unfiltered = await this.dependencies.getDependents(filePath, null, false);
+            if (unfiltered.length > 0)
+                header = (0, format_helpers_1.formatDependentsFilterMiss)(filePath, symbol, unfiltered);
+            const indirect = (0, format_helpers_1.formatTransitiveSection)(rows, symbol, 'dependents');
+            if (indirect && unfiltered.length > 0)
+                return (0, format_helpers_1.textResponse)(`${header}\n\n${indirect}`);
         }
-        const failure = await this.searcher.checkGraphPath(filePath);
-        if (failure)
-            return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependents', 'file_path', input, filePath, failure);
-        const header = `**Dependents of** \`${filePath}\`\n\n**Direct:** No direct import dependents found.`;
+        if (rows.length > 0)
+            return (0, format_helpers_1.textResponse)((0, format_helpers_1.formatDependents)(filePath, rows, transitive, symbol));
         if (!symbol) {
             return (0, format_helpers_1.textResponse)(`${header}\n\nTip: pass \`symbol\` to trigger a text-search fallback for runtime usages (e.g. via singleton or container).`);
         }
-        const rootDir = this.searcher.fallbackRoot(filePath);
+        const rootDir = this.roots.fallbackRoot(filePath);
         if (rootDir === null)
             return (0, format_helpers_1.textResponse)(header);
         const fallbackHeader = `**Fallback \`[text search]\` for \`${symbol}\`:**`;
-        const grep = await this.searcher.grepSymbol(symbol, rootDir, filePath);
+        const grep = await this.symbols.grepSymbol(symbol, rootDir, filePath);
         if (!grep.ok) {
             return (0, format_helpers_1.textResponse)(`${header}\n\n${fallbackHeader} failed`);
         }

package/dist/src/tools/ListFilesTool.d.ts

@@ -1,10 +1,18 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IToolPaths } from '../interfaces/IToolPaths';
+import type { IWorkspaceFiles } from '../interfaces/IWorkspaceFiles';
 import type { ILogger } from '../interfaces/ILogger';
-export declare class ListFilesTool implements IMcpToolHandler {
-    private searcher;
-    private logger;
-    constructor(searcher: ISearcher, logger: ILogger);
-    definition(): ToolDefinition;
-    handle(args: Record<string, unknown>): Promise<ToolResponse>;
+import { McpTool } from './McpTool';
+declare const ARGS: z.ZodObject<{
+    path: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    depth: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    pattern: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+}, z.core.$strip>;
+export declare class ListFilesTool extends McpTool<typeof ARGS> {
+    private paths;
+    private files;
+    constructor(paths: IToolPaths, files: IWorkspaceFiles, logger: ILogger);
+    protected run({ path: input, depth, pattern }: z.output<typeof ARGS>): Promise<ToolResponse>;
 }
+export {};

package/dist/src/tools/ListFilesTool.js

@@ -1,38 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListFilesTool = void 0;
+const zod_1 = require("zod");
 const format_helpers_1 = require("./format-helpers");
-class ListFilesTool {
-    searcher;
-    logger;
-    constructor(searcher, logger) {
-        this.searcher = searcher;
-        this.logger = logger;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const tool_args_1 = require("./tool-args");
+const ARGS = zod_1.z.object({
+    path: (0, tool_args_1.pathArg)((0, format_helpers_1.pathArgDescription)('directory'), 'directory'),
+    depth: (0, tool_args_1.intInRange)('Tree depth: 1 = immediate children only, up to 5. Default: 2.', { min: 1, max: 5, fallback: 2 }),
+    pattern: (0, tool_args_1.optionalText)('Optional filename filter (substring or extension like ".ts"). Only matching files are shown.'),
+});
+class ListFilesTool extends McpTool_1.McpTool {
+    paths;
+    files;
+    constructor(paths, files, logger) {
+        super({
             name: 'list_files',
             description: 'List files and directories under a workspace directory as an indented tree. Use to understand project structure before reading files; list_projects prints each project\'s directory.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)('directory') },
-                    depth: { type: 'number', description: 'Tree depth: 1 = immediate children only, up to 5. Default: 2.' },
-                    pattern: { type: 'string', description: 'Optional filename filter (substring or extension like ".ts"). Only matching files are shown.' },
-                },
-                required: ['path'],
-            },
-        };
+            args: ARGS,
+        }, logger);
+        this.paths = paths;
+        this.files = files;
     }
-    async handle(args) {
-        const input = args.path == null ? '' : String(args.path);
-        const rawDepth = Number(args.depth);
-        const depth = isNaN(rawDepth) || rawDepth < 1 ? 2 : Math.min(5, rawDepth);
-        const pattern = args.pattern ? String(args.pattern) : null;
-        const resolved = await this.searcher.resolveToolPath(input);
+    async run({ path: input, depth, pattern }) {
+        const resolved = await this.paths.resolveToolPath(input);
         if (!resolved.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'list_files', 'path', input, input, resolved, 'directory');
-        const result = await this.searcher.listFiles(resolved.relPath, depth, pattern);
+        const result = await this.files.listFiles(resolved.relPath, depth, pattern ?? null);
         if (!result.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'list_files', 'path', input, resolved.relPath, result, 'directory');
         return (0, format_helpers_1.textResponse)(`**Directory:** ${resolved.relPath}\n\`\`\`\n${result.tree}\n\`\`\``);

package/dist/src/tools/ListProjectsTool.d.ts

@@ -1,8 +1,12 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
-export declare class ListProjectsTool implements IMcpToolHandler {
-    private searcher;
-    constructor(searcher: ISearcher);
-    definition(): ToolDefinition;
-    handle(_args: Record<string, unknown>): Promise<ToolResponse>;
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IProjectCatalog } from '../interfaces/IProjectCatalog';
+import type { ILogger } from '../interfaces/ILogger';
+import { McpTool } from './McpTool';
+declare const ARGS: z.ZodObject<{}, z.core.$strip>;
+export declare class ListProjectsTool extends McpTool<typeof ARGS> {
+    private catalog;
+    constructor(catalog: IProjectCatalog, logger?: ILogger);
+    protected run(): Promise<ToolResponse>;
 }
+export {};

package/dist/src/tools/ListProjectsTool.js

@@ -1,21 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListProjectsTool = void 0;
+const zod_1 = require("zod");
+const LoggerService_1 = require("../services/LoggerService");
 const format_helpers_1 = require("./format-helpers");
-class ListProjectsTool {
-    searcher;
-    constructor(searcher) {
-        this.searcher = searcher;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const ARGS = zod_1.z.object({});
+class ListProjectsTool extends McpTool_1.McpTool {
+    catalog;
+    constructor(catalog, logger = LoggerService_1.LoggerService.silent()) {
+        super({
             name: 'list_projects',
             description: 'List all indexed projects with their chunk counts, workspace-relative directory (`path:`) and metadata (description, stack, notes, relations from .ragmeta.json).',
-            inputSchema: { type: 'object', properties: {} },
-        };
+            args: ARGS,
+        }, logger);
+        this.catalog = catalog;
     }
-    async handle(_args) {
-        const rows = await this.searcher.listProjects();
+    async run() {
+        const rows = await this.catalog.listProjects();
         if (rows.length === 0) {
             return (0, format_helpers_1.textResponse)('No indexed projects found.');
         }

package/dist/src/tools/McpTool.d.ts

@@ -0,0 +1,17 @@
+import type { z } from 'zod';
+import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { ILogger } from '../interfaces/ILogger';
+export interface McpToolSpec<S extends z.ZodObject> {
+    name: string;
+    description: string;
+    args: S;
+}
+export declare abstract class McpTool<S extends z.ZodObject> implements IMcpToolHandler {
+    private readonly spec;
+    protected readonly logger: ILogger;
+    private cachedDefinition?;
+    constructor(spec: McpToolSpec<S>, logger: ILogger);
+    definition(): ToolDefinition;
+    handle(raw: Record<string, unknown>): Promise<ToolResponse>;
+    protected abstract run(args: z.output<S>): Promise<ToolResponse>;
+}

package/dist/src/tools/McpTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpTool = void 0;
+const format_helpers_1 = require("./format-helpers");
+const tool_args_1 = require("./tool-args");
+class McpTool {
+    spec;
+    logger;
+    cachedDefinition;
+    constructor(spec, logger) {
+        this.spec = spec;
+        this.logger = logger;
+    }
+    definition() {
+        const { name, description, args } = this.spec;
+        return this.cachedDefinition ??= { name, description, inputSchema: (0, tool_args_1.toInputSchema)(args) };
+    }
+    async handle(raw) {
+        const parsed = (0, tool_args_1.parseToolArgs)(this.spec.args, raw);
+        if (parsed.ok)
+            return this.run(parsed.args);
+        const { failure } = parsed;
+        return failure.kind === 'missing-path'
+            ? (0, format_helpers_1.pathErrorResponse)(this.logger, this.spec.name, failure.arg, '', '', { ok: false, reason: 'invalid', missing: true }, failure.pathKind)
+            : (0, format_helpers_1.errorResponse)(failure.text);
+    }
+}
+exports.McpTool = McpTool;

package/dist/src/tools/ReadFileRangeTool.d.ts

@@ -1,10 +1,18 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IToolPaths } from '../interfaces/IToolPaths';
+import type { IWorkspaceFiles } from '../interfaces/IWorkspaceFiles';
 import type { ILogger } from '../interfaces/ILogger';
-export declare class ReadFileRangeTool implements IMcpToolHandler {
-    private searcher;
-    private logger;
-    constructor(searcher: ISearcher, logger: ILogger);
-    definition(): ToolDefinition;
-    handle(args: Record<string, unknown>): Promise<ToolResponse>;
+import { McpTool } from './McpTool';
+declare const ARGS: z.ZodObject<{
+    file_path: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    start_line: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    end_line: z.ZodType<number | undefined, unknown, z.core.$ZodTypeInternals<number | undefined, unknown>>;
+}, z.core.$strip>;
+export declare class ReadFileRangeTool extends McpTool<typeof ARGS> {
+    private paths;
+    private files;
+    constructor(paths: IToolPaths, files: IWorkspaceFiles, logger: ILogger);
+    protected run(args: z.output<typeof ARGS>): Promise<ToolResponse>;
 }
+export {};

package/dist/src/tools/ReadFileRangeTool.js

@@ -1,37 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadFileRangeTool = void 0;
+const zod_1 = require("zod");
 const format_helpers_1 = require("./format-helpers");
-class ReadFileRangeTool {
-    searcher;
-    logger;
-    constructor(searcher, logger) {
-        this.searcher = searcher;
-        this.logger = logger;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const tool_args_1 = require("./tool-args");
+const ARGS = zod_1.z.object({
+    file_path: (0, tool_args_1.pathArg)((0, format_helpers_1.pathArgDescription)()),
+    start_line: (0, tool_args_1.intInRange)('First line to read (1-based). Use the **Line** number from search_codebase results. Default: 1.', { min: 1, fallback: 1 }),
+    end_line: (0, tool_args_1.intInRange)('Last line to read (1-based, inclusive). Default: start_line + 99.'),
+});
+class ReadFileRangeTool extends McpTool_1.McpTool {
+    paths;
+    files;
+    constructor(paths, files, logger) {
+        super({
             name: 'read_file_range',
             description: 'Read a specific line range from a file under the workspace, indexed or not. Use this when a search result looks incomplete — read the surrounding lines to get full context.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file_path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)() },
-                    start_line: { type: 'number', description: 'First line to read (1-based). Use the **Line** number from search_codebase results. Default: 1.' },
-                    end_line: { type: 'number', description: 'Last line to read (1-based, inclusive). Default: start_line + 99.' },
-                },
-                required: ['file_path'],
-            },
-        };
+            args: ARGS,
+        }, logger);
+        this.paths = paths;
+        this.files = files;
     }
-    async handle(args) {
-        const input = args.file_path == null ? '' : String(args.file_path);
-        const startLine = Math.max(1, Number(args.start_line) || 1);
-        const endLine = Number(args.end_line) || startLine + 99;
-        const resolved = await this.searcher.resolveToolPath(input);
+    async run(args) {
+        const input = args.file_path;
+        const startLine = args.start_line;
+        const endLine = args.end_line ?? startLine + 99;
+        const resolved = await this.paths.resolveToolPath(input);
         if (!resolved.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'read_file_range', 'file_path', input, input, resolved);
-        const range = await this.searcher.readFileRange(resolved.relPath, startLine, endLine);
+        const range = await this.files.readFileRange(resolved.relPath, startLine, endLine);
         if (!range.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'read_file_range', 'file_path', input, resolved.relPath, range);
         const numbered = range.lines.map((line, i) => `${startLine + i}: ${line}`).join('\n');

package/dist/src/tools/ReadFileTool.d.ts

@@ -1,10 +1,17 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IToolPaths } from '../interfaces/IToolPaths';
+import type { IWorkspaceFiles } from '../interfaces/IWorkspaceFiles';
 import type { ILogger } from '../interfaces/ILogger';
-export declare class ReadFileTool implements IMcpToolHandler {
-    private searcher;
-    private logger;
-    constructor(searcher: ISearcher, logger: ILogger);
-    definition(): ToolDefinition;
-    handle(args: Record<string, unknown>): Promise<ToolResponse>;
+import { McpTool } from './McpTool';
+declare const ARGS: z.ZodObject<{
+    file_path: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    max_lines: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+}, z.core.$strip>;
+export declare class ReadFileTool extends McpTool<typeof ARGS> {
+    private paths;
+    private files;
+    constructor(paths: IToolPaths, files: IWorkspaceFiles, logger: ILogger);
+    protected run({ file_path: input, max_lines: maxLines }: z.output<typeof ARGS>): Promise<ToolResponse>;
 }
+export {};

package/dist/src/tools/ReadFileTool.js

@@ -1,36 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadFileTool = void 0;
+const zod_1 = require("zod");
 const format_helpers_1 = require("./format-helpers");
-class ReadFileTool {
-    searcher;
-    logger;
-    constructor(searcher, logger) {
-        this.searcher = searcher;
-        this.logger = logger;
-    }
-    definition() {
-        return {
+const McpTool_1 = require("./McpTool");
+const tool_args_1 = require("./tool-args");
+const ARGS = zod_1.z.object({
+    file_path: (0, tool_args_1.pathArg)((0, format_helpers_1.pathArgDescription)()),
+    max_lines: (0, tool_args_1.intInRange)('Maximum lines to return (default 300, max 1000)', { min: 1, max: 1000, fallback: 300 }),
+});
+class ReadFileTool extends McpTool_1.McpTool {
+    paths;
+    files;
+    constructor(paths, files, logger) {
+        super({
             name: 'read_file',
             description: 'Read a complete file under the workspace, indexed or not. Returns contents with line numbers. Truncates at max_lines with a hint to continue with read_file_range.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file_path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)() },
-                    max_lines: { type: 'number', description: 'Maximum lines to return (default 300, max 1000)' },
-                },
-                required: ['file_path'],
-            },
-        };
+            args: ARGS,
+        }, logger);
+        this.paths = paths;
+        this.files = files;
     }
-    async handle(args) {
-        const input = args.file_path == null ? '' : String(args.file_path);
-        const rawMax = Number(args.max_lines);
-        const maxLines = isNaN(rawMax) || rawMax < 1 ? 300 : Math.min(1000, rawMax);
-        const resolved = await this.searcher.resolveToolPath(input);
+    async run({ file_path: input, max_lines: maxLines }) {
+        const resolved = await this.paths.resolveToolPath(input);
         if (!resolved.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'read_file', 'file_path', input, input, resolved);
-        const result = await this.searcher.readFile(resolved.relPath, maxLines);
+        const result = await this.files.readFile(resolved.relPath, maxLines);
         if (!result.ok)
             return (0, format_helpers_1.pathErrorResponse)(this.logger, 'read_file', 'file_path', input, resolved.relPath, result);
         const numbered = result.lines.map((line, i) => `${i + 1}: ${line}`).join('\n');

package/dist/src/tools/SearchCodebaseTool.d.ts

@@ -1,13 +1,25 @@
-import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
-import type { ISearcher } from '../interfaces/ISearcher';
+import { z } from 'zod';
+import type { ToolResponse } from '../interfaces/IMcpToolHandler';
+import type { IChunkSearch } from '../interfaces/IChunkSearch';
+import type { IDependencyGraph } from '../interfaces/IDependencyGraph';
 import type { ILogger } from '../interfaces/ILogger';
-export declare class SearchCodebaseTool implements IMcpToolHandler {
-    private searcher;
-    private defaultLimit;
-    private maxLimit;
+import { McpTool } from './McpTool';
+declare function searchArgs(defaultLimit: number, maxLimit: number, defaultThreshold: number): z.ZodObject<{
+    query: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    limit: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    project: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    include_neighbors: z.ZodType<boolean | undefined, unknown, z.core.$ZodTypeInternals<boolean | undefined, unknown>>;
+    include_graph_context: z.ZodType<boolean | undefined, unknown, z.core.$ZodTypeInternals<boolean | undefined, unknown>>;
+    threshold: z.ZodType<number | undefined, unknown, z.core.$ZodTypeInternals<number | undefined, unknown>>;
+    per_file: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    rerank: z.ZodType<boolean | undefined, unknown, z.core.$ZodTypeInternals<boolean | undefined, unknown>>;
+}, z.core.$strip>;
+type SearchArgs = ReturnType<typeof searchArgs>;
+export declare class SearchCodebaseTool extends McpTool<SearchArgs> {
+    private chunks;
+    private dependencies;
     private defaultThreshold;
-    private logger;
-    constructor(searcher: ISearcher, defaultLimit: number, maxLimit: number, defaultThreshold: number, logger: ILogger);
-    definition(): ToolDefinition;
-    handle(args: Record<string, unknown>): Promise<ToolResponse>;
+    constructor(chunks: IChunkSearch, dependencies: IDependencyGraph, defaultLimit: number, maxLimit: number, defaultThreshold: number, logger: ILogger);
+    protected run(args: z.output<SearchArgs>): Promise<ToolResponse>;
 }
+export {};