@travisennis/acai 0.0.8 → 0.0.10

package/dist/tools/code-search.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const CodeSearchTool: {
+    name: "CodeSearch";
+};
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+    path: z.ZodDefault<z.ZodString>;
+    regexPattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+    filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+    excludePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+    excludeDir: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    filesOnly: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    showContent: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    codeOnly: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+}, z.core.$strip>;
+type CodeSearchInputSchema = z.infer<typeof inputSchema>;
+export declare const createCodeSearchTool: () => {
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            query: z.ZodString;
+            path: z.ZodDefault<z.ZodString>;
+            regexPattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+            filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+            excludePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+            excludeDir: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            filesOnly: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            showContent: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            codeOnly: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+        }, z.core.$strip>;
+    };
+    display({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: CodeSearchInputSchema): string;
+    execute({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: CodeSearchInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+};
+export {};
+//# sourceMappingURL=code-search.d.ts.map

package/dist/tools/code-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-search.d.ts","sourceRoot":"","sources":["../../source/tools/code-search.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAMvD,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;iBA8Bf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA4GzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;iJAkB1B,qBAAqB;iJAsDnB,qBAAqB,mBACP,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAgCrB,CAAC"}

package/dist/tools/code-search.js

@@ -0,0 +1,195 @@
+import { execSync } from "node:child_process";
+import { inspect } from "node:util";
+import { z } from "zod";
+import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
+import { convertNullString } from "../utils/zod.js";
+// default limit
+const DEFAULT_MAX_RESULTS = 15;
+const DEFAULT_CONTEXT_LINES = 6;
+export const CodeSearchTool = {
+    name: "CodeSearch",
+};
+const inputSchema = z.object({
+    query: z.string().describe("Natural language query for semantic search"),
+    path: z.string().describe("Path to search in").default("."),
+    regexPattern: z
+        .preprocess((val) => convertNullString(val), z.string().nullable())
+        .describe("Regex pre-filter (-e flag)"),
+    filePattern: z
+        .preprocess((val) => convertNullString(val), z.string().nullable())
+        .describe("File filter (--include flag)"),
+    excludePattern: z
+        .preprocess((val) => convertNullString(val), z.string().nullable())
+        .describe("Exclude pattern (--exclude flag)"),
+    excludeDir: z
+        .preprocess((val) => convertNullString(val), z.string().nullable())
+        .describe("Exclude directories (--exclude-dir flag)"),
+    maxResults: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Number of results (-k flag)"),
+    contextLines: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Context lines (-n flag)"),
+    filesOnly: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .describe("List only files (-l flag)"),
+    showContent: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .describe("Show full content (-c flag)"),
+    codeOnly: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .describe("Skip config/text files (--code-only flag)"),
+});
+/**
+ * Converts string "null"/"undefined" back to actual null.
+ * Zod preprocess converts null to "null" string, this reverses that.
+ */
+function normalizeNullableString(value) {
+    if (value === "null" || value === "undefined") {
+        return null;
+    }
+    return value;
+}
+/**
+ * Builds colgrep command arguments from search options
+ */
+function buildColgrepArgs(options) {
+    const effectivePath = options.path !== "." ? options.path : ".";
+    const effectiveMaxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
+    const effectiveContextLines = options.contextLines ?? DEFAULT_CONTEXT_LINES;
+    const safeRegexPattern = normalizeNullableString(options.regexPattern);
+    const safeFilePattern = normalizeNullableString(options.filePattern);
+    const safeExcludePattern = normalizeNullableString(options.excludePattern);
+    const safeExcludeDir = normalizeNullableString(options.excludeDir);
+    const quotedQuery = JSON.stringify(options.query);
+    const args = [quotedQuery];
+    if (effectivePath !== ".") {
+        args.push(effectivePath);
+    }
+    if (safeRegexPattern) {
+        args.push("-e", safeRegexPattern);
+    }
+    if (safeFilePattern) {
+        args.push("--include", safeFilePattern);
+    }
+    if (safeExcludePattern) {
+        args.push("--exclude", safeExcludePattern);
+    }
+    if (safeExcludeDir) {
+        args.push("--exclude-dir", safeExcludeDir);
+    }
+    if (effectiveMaxResults !== DEFAULT_MAX_RESULTS) {
+        args.push("-k", String(effectiveMaxResults));
+    }
+    if (effectiveContextLines !== DEFAULT_CONTEXT_LINES) {
+        args.push("-n", String(effectiveContextLines));
+    }
+    if (options.filesOnly) {
+        args.push("-l");
+    }
+    if (options.showContent) {
+        args.push("-c");
+    }
+    if (options.codeOnly) {
+        args.push("--code-only");
+    }
+    return args;
+}
+/**
+ * Converts execSync error to user-friendly message
+ */
+function handleColgrepError(error, query, path) {
+    const errorMessage = error.message;
+    // Check if colgrep is not installed
+    if (errorMessage.includes("ENOENT") || errorMessage.includes("not found")) {
+        throw new Error("colgrep is not installed. Please install it from https://github.com/lightonai/next-plaid");
+    }
+    let userFriendlyError = `Error searching "${query}" in ${path}: ${errorMessage}`;
+    if (errorMessage.includes("No such file or directory")) {
+        userFriendlyError = `Path not found: "${path}" - check if the path exists and is accessible`;
+    }
+    else if (errorMessage.includes("permission denied")) {
+        userFriendlyError = `Permission denied accessing "${path}"`;
+    }
+    else if (errorMessage.includes("timed out")) {
+        userFriendlyError =
+            "Search timed out after 30 seconds - try reducing maxResults";
+    }
+    throw new Error(userFriendlyError);
+}
+export const createCodeSearchTool = () => {
+    return {
+        toolDef: {
+            description: "Semantic code search using natural language.",
+            inputSchema,
+        },
+        display({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }) {
+            const safeRegexPattern = normalizeNullableString(regexPattern);
+            const safeFilePattern = normalizeNullableString(filePattern);
+            const safeExcludePattern = normalizeNullableString(excludePattern);
+            const safeExcludeDir = normalizeNullableString(excludeDir);
+            const displayPath = toDisplayPath(path);
+            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
+            const effectiveContextLines = contextLines ?? DEFAULT_CONTEXT_LINES;
+            let initMessage = `${style.cyan(inspect(query))} in ${style.cyan(displayPath)}`;
+            if (safeRegexPattern) {
+                initMessage += ` ${style.dim(`(regex: ${safeRegexPattern})`)}`;
+            }
+            if (safeFilePattern) {
+                initMessage += ` ${style.dim(`(include: ${safeFilePattern})`)}`;
+            }
+            if (safeExcludePattern) {
+                initMessage += ` ${style.dim(`(exclude: ${safeExcludePattern})`)}`;
+            }
+            if (safeExcludeDir) {
+                initMessage += ` ${style.dim(`(exclude-dir: ${safeExcludeDir})`)}`;
+            }
+            if (effectiveMaxResults !== DEFAULT_MAX_RESULTS) {
+                initMessage += ` ${style.dim(`(max: ${effectiveMaxResults})`)}`;
+            }
+            if (effectiveContextLines !== DEFAULT_CONTEXT_LINES) {
+                initMessage += ` ${style.dim(`(context: ${effectiveContextLines})`)}`;
+            }
+            if (filesOnly) {
+                initMessage += ` ${style.dim("(files only)")}`;
+            }
+            if (showContent) {
+                initMessage += ` ${style.dim("(show content)")}`;
+            }
+            if (codeOnly) {
+                initMessage += ` ${style.dim("(code only)")}`;
+            }
+            return initMessage;
+        },
+        async execute({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("CodeSearch aborted");
+            }
+            const args = buildColgrepArgs({
+                query,
+                path,
+                regexPattern: normalizeNullableString(regexPattern),
+                filePattern: normalizeNullableString(filePattern),
+                excludePattern: normalizeNullableString(excludePattern),
+                excludeDir: normalizeNullableString(excludeDir),
+                maxResults,
+                contextLines,
+                filesOnly,
+                showContent,
+                codeOnly,
+            });
+            try {
+                const colgrepResult = execSync(["colgrep", ...args].join(" "), {
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "pipe"],
+                    timeout: 30000,
+                });
+                return colgrepResult;
+            }
+            catch (error) {
+                handleColgrepError(error, query, path);
+            }
+        },
+    };
+};

package/dist/tools/directory-tree.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const DirectoryTreeTool: {
     name: "DirectoryTree";
@@ -9,9 +10,8 @@ declare const inputSchema: z.ZodObject<{
     maxDepth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
-export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
+export declare const createDirectoryTreeTool: (options: {
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;

package/dist/tools/directory-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAYf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,8BAG3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;4CAO2C,wBAAwB;4CAW9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAYf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,SAAS;IACrD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;4CAQ2C,wBAAwB;4CAY9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}

package/dist/tools/directory-tree.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
 import ignore from "../utils/ignore.js";
 import { convertNullString } from "../utils/zod.js";
@@ -19,15 +20,17 @@ const inputSchema = z.object({
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
         .describe(`Maximum recursion depth. Set to 0 for no limit. (default: ${DEFAULT_DEPTH_LIMIT})`),
 });
-export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
+export const createDirectoryTreeTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectory = allowedDirs ?? [primaryDir];
     return {
         toolDef: {
-            description: `Get a directory tree structure for a given path. This tool will ignore any directories or files listed in a .gitignore file. Use this tool when you need to see a complete directory tree for a path in the allowed directories. This can be used to get an understanding of how a project is organized and what files are available before using other file system tools. Results are automatically limited to prevent overwhelming output. Default limits are ${DEFAULT_ITEM_LIMIT} items and ${DEFAULT_DEPTH_LIMIT} depth. Use maxResults and maxDepth parameters for better control over output size.`,
+            description: "Show directory structure as a tree.",
             inputSchema,
         },
         display({ path, maxDepth, maxResults }) {
-            let display = `\n> ${style.cyan(path)}`;
+            const displayPath = toDisplayPath(path);
+            let display = `${style.cyan(displayPath)}`;
             if (maxDepth || maxResults) {
                 const parts = [];
                 if (maxDepth)
@@ -42,7 +45,7 @@ export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, }) => {
             if (abortSignal?.aborted) {
                 throw new Error("Directory tree listing aborted");
             }
-            const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+            const validPath = await validatePath(joinWorkingDir(path, primaryDir), allowedDirectory, { abortSignal });
             if (abortSignal?.aborted) {
                 throw new Error("Directory tree listing aborted before tree generation");
             }

package/dist/tools/dynamic-tool-loader.d.ts

@@ -24,13 +24,10 @@ interface DynamicToolObject {
         inputSchema: any;
     };
     execute: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<string>;
-    ask?: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<{
-        approve: boolean;
-        reason?: string;
-    }>;
 }
-export declare function loadDynamicTools({ baseDir }: {
+export declare function loadDynamicTools({ baseDir, existingToolNames, }: {
     baseDir: string;
+    existingToolNames?: string[];
 }): Promise<Record<string, DynamicToolObject>>;
 export {};
 //# sourceMappingURL=dynamic-tool-loader.d.ts.map

package/dist/tools/dynamic-tool-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AA2LD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,GAAG,CAAC,EAAE,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAwCD,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,8CAgEtE"}
+{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AA2LD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAwCD,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,iBAAsB,GACvB,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,8CA2FA"}

package/dist/tools/dynamic-tool-loader.js

@@ -3,8 +3,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
-import { config } from "../config.js";
-import { logger } from "../logger.js";
+import { config } from "../config/index.js";
+import { logger } from "../utils/logger.js";
 // Tool Metadata Schema and Parser
 const toolMetadataSchema = z.object({
     name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
@@ -183,7 +183,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
 }
 function createDynamicTool(scriptPath, metadata) {
     const inputSchema = generateZodSchema(metadata.parameters);
-    const toolName = `dynamic-${metadata.name}`;
+    const toolName = metadata.name;
     return {
         [toolName]: {
             toolDef: {
@@ -208,7 +208,7 @@ function createDynamicTool(scriptPath, metadata) {
         },
     };
 }
-export async function loadDynamicTools({ baseDir }) {
+export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
     const projectConfig = await config.getConfig();
     const dynamicConfig = projectConfig.tools.dynamicTools;
     if (!dynamicConfig.enabled) {
@@ -260,8 +260,24 @@ export async function loadDynamicTools({ baseDir }) {
         }
     }
     const tools = {};
+    const conflictingTools = [];
     for (const [_, { path, metadata }] of toolMap) {
+        const toolName = metadata.name;
+        // Check for conflicts with existing tools
+        if (existingToolNames.includes(toolName)) {
+            conflictingTools.push(toolName);
+            logger.warn(`Dynamic tool '${toolName}' conflicts with existing tool. Skipping.`);
+            continue;
+        }
+        // Check for duplicate dynamic tool names
+        if (tools[toolName]) {
+            logger.warn(`Duplicate dynamic tool name '${toolName}' found. Skipping duplicate.`);
+            continue;
+        }
         Object.assign(tools, createDynamicTool(path, metadata));
     }
+    if (conflictingTools.length > 0) {
+        logger.warn(`Warning: ${conflictingTools.length} dynamic tool(s) skipped due to name conflicts: ${conflictingTools.join(", ")}`);
+    }
     return tools;
 }

package/dist/tools/edit-file.d.ts

@@ -1,28 +1,28 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const EditFileTool: {
     name: "Edit";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
-    edits: z.ZodArray<z.ZodObject<{
+    edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
         oldText: z.ZodString;
         newText: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type EditFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createEditFileTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
+export declare const createEditFileTool: (options: {
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
-            edits: z.ZodArray<z.ZodObject<{
+            edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
                 oldText: z.ZodString;
                 newText: z.ZodString;
-            }, z.core.$strip>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
     };
     display({ path, edits }: EditFileInputSchema): string;

package/dist/tools/edit-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;iBAcf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;6BAa4B,mBAAmB;6BAIzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqBrB,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAsDjB"}
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAIF,QAAA,MAAM,WAAW;;;;;;iBAqCf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;6BAY4B,mBAAmB;6BAKzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC;AAiDF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAwDD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CA6CjB"}