@dexto/tools-filesystem 1.5.8 → 1.6.0

package/dist/directory-approval.js

@@ -0,0 +1,59 @@
+import * as path from "node:path";
+import { ApprovalType, ToolError } from "@dexto/core";
+function resolveFilePath(workingDirectory, filePath) {
+  const resolvedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDirectory, filePath);
+  return { path: resolvedPath, parentDir: path.dirname(resolvedPath) };
+}
+function createDirectoryAccessApprovalHandlers(options) {
+  return {
+    async getApprovalOverride(input, context) {
+      const resolvedFileSystemService = await options.getFileSystemService(context);
+      const paths = options.resolvePaths(input, resolvedFileSystemService);
+      const isAllowed = await resolvedFileSystemService.isPathWithinConfigAllowed(paths.path);
+      if (isAllowed) {
+        return null;
+      }
+      const approvalManager = context.services?.approval;
+      if (!approvalManager) {
+        throw ToolError.configInvalid(
+          `${options.toolName} requires ToolExecutionContext.services.approval`
+        );
+      }
+      if (approvalManager.isDirectorySessionApproved(paths.path)) {
+        return null;
+      }
+      return {
+        type: ApprovalType.DIRECTORY_ACCESS,
+        metadata: {
+          path: paths.path,
+          parentDir: paths.parentDir,
+          operation: options.operation,
+          toolName: options.toolName
+        }
+      };
+    },
+    onApprovalGranted(response, context, approvalRequest) {
+      if (approvalRequest.type !== ApprovalType.DIRECTORY_ACCESS) {
+        return;
+      }
+      const metadata = approvalRequest.metadata;
+      const parentDir = typeof metadata?.parentDir === "string" ? metadata.parentDir : null;
+      if (!parentDir) {
+        return;
+      }
+      const data = response.data;
+      const rememberDirectory = data?.rememberDirectory ?? false;
+      const approvalManager = context.services?.approval;
+      if (!approvalManager) {
+        throw ToolError.configInvalid(
+          `${options.toolName} requires ToolExecutionContext.services.approval`
+        );
+      }
+      approvalManager.addApprovedDirectory(parentDir, rememberDirectory ? "session" : "once");
+    }
+  };
+}
+export {
+  createDirectoryAccessApprovalHandlers,
+  resolveFilePath
+};

package/dist/edit-file-tool.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,35 +15,24 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var edit_file_tool_exports = {};
 __export(edit_file_tool_exports, {
   createEditFileTool: () => createEditFileTool
 });
 module.exports = __toCommonJS(edit_file_tool_exports);
-var path = __toESM(require("node:path"), 1);
 var import_node_crypto = require("node:crypto");
 var import_zod = require("zod");
 var import_diff = require("diff");
 var import_core = require("@dexto/core");
-var import_core2 = require("@dexto/core");
-var import_core3 = require("@dexto/core");
-var import_core4 = require("@dexto/core");
 var import_error_codes = require("./error-codes.js");
+var import_directory_approval = require("./directory-approval.js");
 const previewContentHashCache = /* @__PURE__ */ new Map();
 function computeContentHash(content) {
   return (0, import_node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
 }
 const EditFileInputSchema = import_zod.z.object({
-  file_path: import_zod.z.string().describe("Absolute path to the file to edit"),
+  file_path: import_zod.z.string().min(1).describe("Absolute path to the file to edit"),
   old_string: import_zod.z.string().describe("Text to replace (must be unique unless replace_all is true)"),
   new_string: import_zod.z.string().describe("Replacement text"),
   replace_all: import_zod.z.boolean().optional().default(false).describe("Replace all occurrences (default: false, requires unique match)")
@@ -64,64 +51,35 @@ function generateDiffPreview(filePath, originalContent, newContent) {
     deletions
   };
 }
-function createEditFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createEditFileTool(getFileSystemService) {
+  return (0, import_core.defineTool)({
     id: "edit_file",
+    displayName: "Update",
+    aliases: ["edit"],
     description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
     inputSchema: EditFileInputSchema,
-    /**
-     * Check if this edit operation needs directory access approval.
-     * Returns custom approval request if the file is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { file_path } = args;
-      if (!file_path) return null;
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
-      if (isAllowed) {
-        return null;
-      }
-      if (directoryApproval?.isSessionApproved(file_path)) {
-        return null;
-      }
-      const absolutePath = path.resolve(file_path);
-      const parentDir = path.dirname(absolutePath);
-      pendingApprovalParentDir = parentDir;
-      return {
-        type: import_core.ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: absolutePath,
-          parentDir,
-          operation: "edit",
-          toolName: "edit_file"
-        }
-      };
-    },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalParentDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalParentDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalParentDir = void 0;
-    },
+    ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
+      toolName: "edit_file",
+      operation: "edit",
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => (0, import_directory_approval.resolveFilePath)(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
     /**
      * Generate preview for approval UI - shows diff without modifying file
      * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
      * Stores content hash for change detection in execute phase.
      */
-    generatePreview: async (input, context) => {
+    async generatePreview(input, context) {
       const { file_path, old_string, new_string, replace_all } = input;
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
       try {
-        const originalFile = await fileSystemService.readFile(file_path);
+        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
         const originalContent = originalFile.content;
-        if (context?.toolCallId) {
+        if (context.toolCallId) {
           previewContentHashCache.set(
             context.toolCallId,
             computeContentHash(originalContent)
@@ -130,62 +88,71 @@ function createEditFileTool(options) {
         if (!replace_all) {
           const occurrences = originalContent.split(old_string).length - 1;
           if (occurrences > 1) {
-            throw import_core2.ToolError.validationFailed(
+            throw import_core.ToolError.validationFailed(
               "edit_file",
               `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
-              { file_path, occurrences }
+              { file_path: resolvedPath, occurrences }
             );
           }
         }
         const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
         if (originalContent === newContent) {
-          throw import_core2.ToolError.validationFailed(
+          throw import_core.ToolError.validationFailed(
             "edit_file",
             `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
-            { file_path, old_string_preview: old_string.slice(0, 100) }
+            { file_path: resolvedPath, old_string_preview: old_string.slice(0, 100) }
           );
         }
-        return generateDiffPreview(file_path, originalContent, newContent);
+        return generateDiffPreview(resolvedPath, originalContent, newContent);
       } catch (error) {
-        if (error instanceof import_core4.DextoRuntimeError && error.code === import_core3.ToolErrorCode.VALIDATION_FAILED) {
+        if (error instanceof import_core.DextoRuntimeError && error.code === import_core.ToolErrorCode.VALIDATION_FAILED) {
           throw error;
         }
-        if (error instanceof import_core4.DextoRuntimeError) {
-          throw import_core2.ToolError.validationFailed("edit_file", error.message, {
-            file_path,
+        if (error instanceof import_core.DextoRuntimeError) {
+          throw import_core.ToolError.validationFailed("edit_file", error.message, {
+            file_path: resolvedPath,
             originalErrorCode: error.code
           });
         }
         return null;
       }
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, old_string, new_string, replace_all } = input;
-      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
-        const expectedHash = previewContentHashCache.get(context.toolCallId);
-        previewContentHashCache.delete(context.toolCallId);
-        let currentContent;
-        try {
-          const currentFile = await fileSystemService.readFile(file_path);
-          currentContent = currentFile.content;
-        } catch (error) {
-          if (error instanceof import_core4.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
-            throw import_core2.ToolError.fileModifiedSincePreview("edit_file", file_path);
+      const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
+      const toolCallId = context.toolCallId;
+      if (toolCallId) {
+        const expectedHash = previewContentHashCache.get(toolCallId);
+        if (expectedHash === void 0) {
+        } else {
+          previewContentHashCache.delete(toolCallId);
+          let currentContent;
+          try {
+            const currentFile = await resolvedFileSystemService.readFile(resolvedPath);
+            currentContent = currentFile.content;
+          } catch (error) {
+            if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
+              throw import_core.ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
+            }
+            throw error;
+          }
+          const currentHash = computeContentHash(currentContent);
+          if (expectedHash !== currentHash) {
+            throw import_core.ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
           }
-          throw error;
-        }
-        const currentHash = computeContentHash(currentContent);
-        if (expectedHash !== currentHash) {
-          throw import_core2.ToolError.fileModifiedSincePreview("edit_file", file_path);
         }
       }
-      const result = await fileSystemService.editFile(file_path, {
+      const result = await resolvedFileSystemService.editFile(resolvedPath, {
         oldString: old_string,
         newString: new_string,
         replaceAll: replace_all
       });
       const _display = generateDiffPreview(
-        file_path,
+        resolvedPath,
         result.originalContent,
         result.newContent
       );
@@ -197,7 +164,7 @@ function createEditFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/edit-file-tool.d.cts

@@ -1,5 +1,6 @@
-import { InternalTool } from '@dexto/core';
-import { FileToolOptions } from './file-tool-types.cjs';
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+import { FileSystemServiceGetter } from './file-tool-types.cjs';
 import './filesystem-service.cjs';
 import './types.cjs';
 
@@ -9,9 +10,25 @@ import './types.cjs';
  * Internal tool for editing files by replacing text (requires approval)
  */
 
+declare const EditFileInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    replace_all: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all: boolean;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean | undefined;
+}>;
 /**
  * Create the edit_file internal tool with directory approval support
  */
-declare function createEditFileTool(options: FileToolOptions): InternalTool;
+declare function createEditFileTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof EditFileInputSchema>;
 
 export { createEditFileTool };

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

@@ -1,17 +1,30 @@
-import { InternalTool } from '@dexto/core';
-import { FileToolOptions } from './file-tool-types.js';
-import './filesystem-service.js';
-import './types.js';
-
 /**
  * Edit File Tool
  *
  * Internal tool for editing files by replacing text (requires approval)
  */
-
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { FileSystemServiceGetter } from './file-tool-types.js';
+declare const EditFileInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    replace_all: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all: boolean;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean | undefined;
+}>;
 /**
  * Create the edit_file internal tool with directory approval support
  */
-declare function createEditFileTool(options: FileToolOptions): InternalTool;
-
-export { createEditFileTool };
+export declare function createEditFileTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof EditFileInputSchema>;
+export {};
+//# sourceMappingURL=edit-file-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edit-file-tool.d.ts","sourceRoot":"","sources":["../src/edit-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAkBpE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;EAaZ,CAAC;AAyBd;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAgKlC"}

package/dist/edit-file-tool.js

@@ -1,18 +1,15 @@
-import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { ApprovalType } from "@dexto/core";
-import { ToolError } from "@dexto/core";
-import { ToolErrorCode } from "@dexto/core";
-import { DextoRuntimeError } from "@dexto/core";
+import { DextoRuntimeError, ToolError, ToolErrorCode, defineTool } from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
+import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
 function computeContentHash(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 const EditFileInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to the file to edit"),
+  file_path: z.string().min(1).describe("Absolute path to the file to edit"),
   old_string: z.string().describe("Text to replace (must be unique unless replace_all is true)"),
   new_string: z.string().describe("Replacement text"),
   replace_all: z.boolean().optional().default(false).describe("Replace all occurrences (default: false, requires unique match)")
@@ -31,64 +28,35 @@ function generateDiffPreview(filePath, originalContent, newContent) {
     deletions
   };
 }
-function createEditFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createEditFileTool(getFileSystemService) {
+  return defineTool({
     id: "edit_file",
+    displayName: "Update",
+    aliases: ["edit"],
     description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
     inputSchema: EditFileInputSchema,
-    /**
-     * Check if this edit operation needs directory access approval.
-     * Returns custom approval request if the file is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { file_path } = args;
-      if (!file_path) return null;
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
-      if (isAllowed) {
-        return null;
-      }
-      if (directoryApproval?.isSessionApproved(file_path)) {
-        return null;
-      }
-      const absolutePath = path.resolve(file_path);
-      const parentDir = path.dirname(absolutePath);
-      pendingApprovalParentDir = parentDir;
-      return {
-        type: ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: absolutePath,
-          parentDir,
-          operation: "edit",
-          toolName: "edit_file"
-        }
-      };
-    },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalParentDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalParentDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalParentDir = void 0;
-    },
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "edit_file",
+      operation: "edit",
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
     /**
      * Generate preview for approval UI - shows diff without modifying file
      * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
      * Stores content hash for change detection in execute phase.
      */
-    generatePreview: async (input, context) => {
+    async generatePreview(input, context) {
       const { file_path, old_string, new_string, replace_all } = input;
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const { path: resolvedPath } = resolveFilePath(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
       try {
-        const originalFile = await fileSystemService.readFile(file_path);
+        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
         const originalContent = originalFile.content;
-        if (context?.toolCallId) {
+        if (context.toolCallId) {
           previewContentHashCache.set(
             context.toolCallId,
             computeContentHash(originalContent)
@@ -100,7 +68,7 @@ function createEditFileTool(options) {
             throw ToolError.validationFailed(
               "edit_file",
               `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
-              { file_path, occurrences }
+              { file_path: resolvedPath, occurrences }
             );
           }
         }
@@ -109,50 +77,59 @@ function createEditFileTool(options) {
           throw ToolError.validationFailed(
             "edit_file",
             `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
-            { file_path, old_string_preview: old_string.slice(0, 100) }
+            { file_path: resolvedPath, old_string_preview: old_string.slice(0, 100) }
           );
         }
-        return generateDiffPreview(file_path, originalContent, newContent);
+        return generateDiffPreview(resolvedPath, originalContent, newContent);
       } catch (error) {
         if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.VALIDATION_FAILED) {
           throw error;
         }
         if (error instanceof DextoRuntimeError) {
           throw ToolError.validationFailed("edit_file", error.message, {
-            file_path,
+            file_path: resolvedPath,
             originalErrorCode: error.code
           });
         }
         return null;
       }
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, old_string, new_string, replace_all } = input;
-      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
-        const expectedHash = previewContentHashCache.get(context.toolCallId);
-        previewContentHashCache.delete(context.toolCallId);
-        let currentContent;
-        try {
-          const currentFile = await fileSystemService.readFile(file_path);
-          currentContent = currentFile.content;
-        } catch (error) {
-          if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
-            throw ToolError.fileModifiedSincePreview("edit_file", file_path);
+      const { path: resolvedPath } = resolveFilePath(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
+      const toolCallId = context.toolCallId;
+      if (toolCallId) {
+        const expectedHash = previewContentHashCache.get(toolCallId);
+        if (expectedHash === void 0) {
+        } else {
+          previewContentHashCache.delete(toolCallId);
+          let currentContent;
+          try {
+            const currentFile = await resolvedFileSystemService.readFile(resolvedPath);
+            currentContent = currentFile.content;
+          } catch (error) {
+            if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
+              throw ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
+            }
+            throw error;
+          }
+          const currentHash = computeContentHash(currentContent);
+          if (expectedHash !== currentHash) {
+            throw ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
           }
-          throw error;
-        }
-        const currentHash = computeContentHash(currentContent);
-        if (expectedHash !== currentHash) {
-          throw ToolError.fileModifiedSincePreview("edit_file", file_path);
         }
       }
-      const result = await fileSystemService.editFile(file_path, {
+      const result = await resolvedFileSystemService.editFile(resolvedPath, {
         oldString: old_string,
         newString: new_string,
         replaceAll: replace_all
       });
       const _display = generateDiffPreview(
-        file_path,
+        resolvedPath,
         result.originalContent,
         result.newContent
       );
@@ -164,7 +141,7 @@ function createEditFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createEditFileTool