@dexto/tools-filesystem 1.5.8 → 1.6.1

package/dist/write-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,33 +15,25 @@ 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 write_file_tool_exports = {};
 __export(write_file_tool_exports, {
   createWriteFileTool: () => createWriteFileTool
 });
 module.exports = __toCommonJS(write_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_error_codes = require("./error-codes.js");
+var import_directory_approval = require("./directory-approval.js");
 const previewContentHashCache = /* @__PURE__ */ new Map();
 const FILE_NOT_EXISTS_MARKER = null;
 function computeContentHash(content) {
   return (0, import_node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
 }
 const WriteFileInputSchema = import_zod.z.object({
-  file_path: import_zod.z.string().describe("Absolute path where the file should be written"),
+  file_path: import_zod.z.string().min(1).describe("Absolute path where the file should be written"),
   content: import_zod.z.string().describe("Content to write to the file"),
   create_dirs: import_zod.z.boolean().optional().default(false).describe("Create parent directories if they don't exist (default: false)"),
   encoding: import_zod.z.enum(["utf-8", "ascii", "latin1", "utf16le"]).optional().default("utf-8").describe("File encoding (default: utf-8)")
@@ -56,101 +46,97 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
     deletions
   };
 }
-function createWriteFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createWriteFileTool(getFileSystemService) {
+  return (0, import_core.defineTool)({
     id: "write_file",
+    aliases: ["write"],
     description: "Write content to a file. Creates a new file or overwrites existing file. Automatically creates backup of existing files before overwriting. Use create_dirs to create parent directories. Requires approval for all write operations. Returns success status, path, bytes written, and backup path if applicable.",
     inputSchema: WriteFileInputSchema,
-    /**
-     * Check if this write 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: "write",
-          toolName: "write_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 or file creation info
-     * Stores content hash for change detection in execute phase.
-     */
-    generatePreview: async (input, context) => {
-      const { file_path, content } = input;
-      try {
-        const originalFile = await fileSystemService.readFile(file_path);
-        const originalContent = originalFile.content;
-        if (context?.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        return generateDiffPreview(file_path, originalContent, content);
-      } catch (error) {
-        if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
-          if (context?.toolCallId) {
-            previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+    ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
+      toolName: "write_file",
+      operation: "write",
+      inputSchema: WriteFileInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => (0, import_directory_approval.resolveFilePath)(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Write",
+        argsText: (0, import_core.truncateForHeader)(input.file_path, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows diff or file creation info
+       * Stores content hash for change detection in execute phase.
+       */
+      preview: async (input, context) => {
+        const { file_path, content } = 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)
+            );
+          }
+          return generateDiffPreview(resolvedPath, originalContent, content);
+        } catch (error) {
+          if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
+            if (context.toolCallId) {
+              previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+            }
+            const lineCount = content.split("\n").length;
+            const preview = {
+              type: "file",
+              title: "Create file",
+              path: resolvedPath,
+              operation: "create",
+              size: Buffer.byteLength(content, "utf8"),
+              lineCount,
+              content
+              // Include content for approval preview
+            };
+            return preview;
           }
-          const lineCount = content.split("\n").length;
-          const preview = {
-            type: "file",
-            path: file_path,
-            operation: "create",
-            size: content.length,
-            lineCount,
-            content
-            // Include content for approval preview
-          };
-          return preview;
+          throw error;
         }
-        throw error;
       }
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, content, create_dirs, encoding } = input;
+      const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
       let originalContent = null;
       let fileExistsNow = false;
       try {
-        const originalFile = await fileSystemService.readFile(file_path);
+        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
         originalContent = originalFile.content;
         fileExistsNow = true;
       } catch (error) {
@@ -161,24 +147,30 @@ function createWriteFileTool(options) {
           throw error;
         }
       }
-      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
+      if (context.toolCallId && previewContentHashCache.has(context.toolCallId)) {
         const expectedHash = previewContentHashCache.get(context.toolCallId);
         previewContentHashCache.delete(context.toolCallId);
         if (expectedHash === FILE_NOT_EXISTS_MARKER) {
           if (fileExistsNow) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
           }
         } else if (expectedHash !== null) {
           if (!fileExistsNow) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+          }
+          if (originalContent === null) {
+            throw import_core.ToolError.executionFailed(
+              "write_file",
+              "Expected original file content when fileExistsNow is true"
+            );
           }
           const currentHash = computeContentHash(originalContent);
           if (expectedHash !== currentHash) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
           }
         }
       }
-      const result = await fileSystemService.writeFile(file_path, content, {
+      const result = await resolvedFileSystemService.writeFile(resolvedPath, content, {
         createDirs: create_dirs,
         encoding
       });
@@ -187,13 +179,15 @@ function createWriteFileTool(options) {
         const lineCount = content.split("\n").length;
         _display = {
           type: "file",
-          path: file_path,
+          title: "Create file",
+          path: resolvedPath,
           operation: "create",
           size: result.bytesWritten,
-          lineCount
+          lineCount,
+          content
         };
       } else {
-        _display = generateDiffPreview(file_path, originalContent, content);
+        _display = generateDiffPreview(resolvedPath, originalContent, content);
       }
       return {
         success: result.success,
@@ -203,7 +197,7 @@ function createWriteFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/write-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';
-
 /**
  * Write File Tool
  *
  * Internal tool for writing content to files (requires approval)
  */
-
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { FileSystemServiceGetter } from './file-tool-types.js';
+declare const WriteFileInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    content: z.ZodString;
+    create_dirs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    encoding: z.ZodDefault<z.ZodOptional<z.ZodEnum<["utf-8", "ascii", "latin1", "utf16le"]>>>;
+}, "strict", z.ZodTypeAny, {
+    content: string;
+    encoding: "ascii" | "utf-8" | "utf16le" | "latin1";
+    file_path: string;
+    create_dirs: boolean;
+}, {
+    content: string;
+    file_path: string;
+    encoding?: "ascii" | "utf-8" | "utf16le" | "latin1" | undefined;
+    create_dirs?: boolean | undefined;
+}>;
 /**
  * Create the write_file internal tool with directory approval support
  */
-declare function createWriteFileTool(options: FileToolOptions): InternalTool;
-
-export { createWriteFileTool };
+export declare function createWriteFileTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof WriteFileInputSchema>;
+export {};
+//# sourceMappingURL=write-file-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write-file-tool.d.ts","sourceRoot":"","sources":["../src/write-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAuBpE,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EAeb,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAqMnC"}

package/dist/write-file-tool.js

@@ -1,20 +1,22 @@
-import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
 import {
+  createLocalToolCallHeader,
   DextoRuntimeError,
-  ApprovalType,
-  ToolError
+  ToolError,
+  defineTool,
+  truncateForHeader
 } from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
+import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
 const FILE_NOT_EXISTS_MARKER = null;
 function computeContentHash(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 const WriteFileInputSchema = z.object({
-  file_path: z.string().describe("Absolute path where the file should be written"),
+  file_path: z.string().min(1).describe("Absolute path where the file should be written"),
   content: z.string().describe("Content to write to the file"),
   create_dirs: z.boolean().optional().default(false).describe("Create parent directories if they don't exist (default: false)"),
   encoding: z.enum(["utf-8", "ascii", "latin1", "utf16le"]).optional().default("utf-8").describe("File encoding (default: utf-8)")
@@ -27,101 +29,97 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
     deletions
   };
 }
-function createWriteFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createWriteFileTool(getFileSystemService) {
+  return defineTool({
     id: "write_file",
+    aliases: ["write"],
     description: "Write content to a file. Creates a new file or overwrites existing file. Automatically creates backup of existing files before overwriting. Use create_dirs to create parent directories. Requires approval for all write operations. Returns success status, path, bytes written, and backup path if applicable.",
     inputSchema: WriteFileInputSchema,
-    /**
-     * Check if this write 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: "write",
-          toolName: "write_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 or file creation info
-     * Stores content hash for change detection in execute phase.
-     */
-    generatePreview: async (input, context) => {
-      const { file_path, content } = input;
-      try {
-        const originalFile = await fileSystemService.readFile(file_path);
-        const originalContent = originalFile.content;
-        if (context?.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        return generateDiffPreview(file_path, originalContent, content);
-      } catch (error) {
-        if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
-          if (context?.toolCallId) {
-            previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "write_file",
+      operation: "write",
+      inputSchema: WriteFileInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Write",
+        argsText: truncateForHeader(input.file_path, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows diff or file creation info
+       * Stores content hash for change detection in execute phase.
+       */
+      preview: async (input, context) => {
+        const { file_path, content } = input;
+        const resolvedFileSystemService = await getFileSystemService(context);
+        const { path: resolvedPath } = resolveFilePath(
+          resolvedFileSystemService.getWorkingDirectory(),
+          file_path
+        );
+        try {
+          let originalContent;
+          try {
+            const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
+            originalContent = originalFile.content;
+          } catch (error) {
+            if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.INVALID_PATH) {
+              const originalFile = await resolvedFileSystemService.readFileForToolPreview(
+                resolvedPath
+              );
+              originalContent = originalFile.content;
+            } else {
+              throw error;
+            }
+          }
+          if (context.toolCallId) {
+            previewContentHashCache.set(
+              context.toolCallId,
+              computeContentHash(originalContent)
+            );
+          }
+          return generateDiffPreview(resolvedPath, originalContent, content);
+        } catch (error) {
+          if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
+            if (context.toolCallId) {
+              previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+            }
+            const lineCount = content.split("\n").length;
+            const preview = {
+              type: "file",
+              title: "Create file",
+              path: resolvedPath,
+              operation: "create",
+              size: Buffer.byteLength(content, "utf8"),
+              lineCount,
+              content
+              // Include content for approval preview
+            };
+            return preview;
           }
-          const lineCount = content.split("\n").length;
-          const preview = {
-            type: "file",
-            path: file_path,
-            operation: "create",
-            size: content.length,
-            lineCount,
-            content
-            // Include content for approval preview
-          };
-          return preview;
+          throw error;
         }
-        throw error;
       }
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, content, create_dirs, encoding } = input;
+      const { path: resolvedPath } = resolveFilePath(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
       let originalContent = null;
       let fileExistsNow = false;
       try {
-        const originalFile = await fileSystemService.readFile(file_path);
+        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
         originalContent = originalFile.content;
         fileExistsNow = true;
       } catch (error) {
@@ -132,24 +130,30 @@ function createWriteFileTool(options) {
           throw error;
         }
       }
-      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
+      if (context.toolCallId && previewContentHashCache.has(context.toolCallId)) {
         const expectedHash = previewContentHashCache.get(context.toolCallId);
         previewContentHashCache.delete(context.toolCallId);
         if (expectedHash === FILE_NOT_EXISTS_MARKER) {
           if (fileExistsNow) {
-            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
           }
         } else if (expectedHash !== null) {
           if (!fileExistsNow) {
-            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+          }
+          if (originalContent === null) {
+            throw ToolError.executionFailed(
+              "write_file",
+              "Expected original file content when fileExistsNow is true"
+            );
           }
           const currentHash = computeContentHash(originalContent);
           if (expectedHash !== currentHash) {
-            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
           }
         }
       }
-      const result = await fileSystemService.writeFile(file_path, content, {
+      const result = await resolvedFileSystemService.writeFile(resolvedPath, content, {
         createDirs: create_dirs,
         encoding
       });
@@ -158,13 +162,15 @@ function createWriteFileTool(options) {
         const lineCount = content.split("\n").length;
         _display = {
           type: "file",
-          path: file_path,
+          title: "Create file",
+          path: resolvedPath,
           operation: "create",
           size: result.bytesWritten,
-          lineCount
+          lineCount,
+          content
         };
       } else {
-        _display = generateDiffPreview(file_path, originalContent, content);
+        _display = generateDiffPreview(resolvedPath, originalContent, content);
       }
       return {
         success: result.success,
@@ -174,7 +180,7 @@ function createWriteFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createWriteFileTool