@dexto/tools-filesystem 1.5.8 → 1.6.1

package/dist/directory-approval.js

@@ -0,0 +1,63 @@
+import * as path from "node:path";
+import { ApprovalStatus, 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 {
+    approval: {
+      async override(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
+          }
+        };
+      },
+      async onGranted(response, context, approvalRequest) {
+        const approvalManager = context.services?.approval;
+        if (!approvalManager) {
+          return;
+        }
+        if (response.status !== ApprovalStatus.APPROVED) {
+          return;
+        }
+        const data = response.data;
+        const rememberDirectory = data?.rememberDirectory ?? false;
+        const metadata = approvalRequest.metadata;
+        if (!metadata?.parentDir) {
+          return;
+        }
+        approvalManager.addApprovedDirectory(
+          metadata.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)")
@@ -58,134 +45,136 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
     deletions
   };
 }
-function createEditFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createEditFileTool(getFileSystemService) {
+  return (0, import_core.defineTool)({
     id: "edit_file",
+    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;
-    },
-    /**
-     * 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) => {
-      const { file_path, old_string, new_string, replace_all } = input;
-      try {
-        const originalFile = await fileSystemService.readFile(file_path);
-        const originalContent = originalFile.content;
-        if (context?.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        if (!replace_all) {
-          const occurrences = originalContent.split(old_string).length - 1;
-          if (occurrences > 1) {
-            throw import_core2.ToolError.validationFailed(
+    ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
+      toolName: "edit_file",
+      operation: "edit",
+      inputSchema: EditFileInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => (0, import_directory_approval.resolveFilePath)(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Update",
+        argsText: (0, import_core.truncateForHeader)(input.file_path, 140)
+      }),
+      /**
+       * 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.
+       */
+      preview: async (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 {
+          let originalContent;
+          try {
+            const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
+            originalContent = originalFile.content;
+          } catch (error) {
+            if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.INVALID_PATH) {
+              const originalFile = await resolvedFileSystemService.readFileForToolPreview(
+                resolvedPath
+              );
+              originalContent = originalFile.content;
+            } else {
+              throw error;
+            }
+          }
+          if (context.toolCallId) {
+            previewContentHashCache.set(
+              context.toolCallId,
+              computeContentHash(originalContent)
+            );
+          }
+          if (!replace_all) {
+            const occurrences = originalContent.split(old_string).length - 1;
+            if (occurrences > 1) {
+              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: resolvedPath, occurrences }
+              );
+            }
+          }
+          const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
+          if (originalContent === newContent) {
+            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 }
+              `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
+              {
+                file_path: resolvedPath,
+                old_string_preview: old_string.slice(0, 100)
+              }
             );
           }
+          return generateDiffPreview(resolvedPath, originalContent, newContent);
+        } catch (error) {
+          if (error instanceof import_core.DextoRuntimeError && error.code === import_core.ToolErrorCode.VALIDATION_FAILED) {
+            throw error;
+          }
+          if (error instanceof import_core.DextoRuntimeError) {
+            throw import_core.ToolError.validationFailed("edit_file", error.message, {
+              file_path: resolvedPath,
+              originalErrorCode: error.code
+            });
+          }
+          return null;
         }
-        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(
-            "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) }
-          );
-        }
-        return generateDiffPreview(file_path, originalContent, newContent);
-      } catch (error) {
-        if (error instanceof import_core4.DextoRuntimeError && error.code === import_core3.ToolErrorCode.VALIDATION_FAILED) {
-          throw error;
-        }
-        if (error instanceof import_core4.DextoRuntimeError) {
-          throw import_core2.ToolError.validationFailed("edit_file", error.message, {
-            file_path,
-            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 +186,7 @@ function createEditFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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;AAUxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAkBpE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;EAaZ,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,mBAAmB,CAAC,CA2LlC"}