@dexto/tools-filesystem 1.5.2 → 1.5.4

package/dist/read-file-tool.js

@@ -17,10 +17,10 @@ function createReadFileTool(options) {
      * Check if this read operation needs directory access approval.
      * Returns custom approval request if the file is outside allowed paths.
      */
-    getApprovalOverride: (args) => {
+    getApprovalOverride: async (args) => {
       const { file_path } = args;
       if (!file_path) return null;
-      const isAllowed = fileSystemService.isPathWithinConfigAllowed(file_path);
+      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
       if (isAllowed) {
         return null;
       }

package/dist/tool-provider.cjs

@@ -34,6 +34,13 @@ const DEFAULT_BLOCKED_EXTENSIONS = [".exe", ".dll", ".so"];
 const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
 const DEFAULT_ENABLE_BACKUPS = false;
 const DEFAULT_BACKUP_RETENTION_DAYS = 7;
+const FILESYSTEM_TOOL_NAMES = [
+  "read_file",
+  "write_file",
+  "edit_file",
+  "glob_files",
+  "grep_content"
+];
 const FileSystemToolsConfigSchema = import_zod.z.object({
   type: import_zod.z.literal("filesystem-tools"),
   allowedPaths: import_zod.z.array(import_zod.z.string()).default(DEFAULT_ALLOWED_PATHS).describe("List of allowed base paths for file operations"),
@@ -47,6 +54,9 @@ const FileSystemToolsConfigSchema = import_zod.z.object({
   backupPath: import_zod.z.string().optional().describe("Absolute path for storing file backups (if enableBackups is true)"),
   backupRetentionDays: import_zod.z.number().int().positive().default(DEFAULT_BACKUP_RETENTION_DAYS).describe(
     `Number of days to retain backup files (default: ${DEFAULT_BACKUP_RETENTION_DAYS})`
+  ),
+  enabledTools: import_zod.z.array(import_zod.z.enum(FILESYSTEM_TOOL_NAMES)).optional().describe(
+    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${FILESYSTEM_TOOL_NAMES.join(", ")}`
   )
 }).strict();
 const fileSystemToolsProvider = {
@@ -88,13 +98,18 @@ const fileSystemToolsProvider = {
       fileSystemService,
       directoryApproval
     };
-    return [
-      (0, import_read_file_tool.createReadFileTool)(fileToolOptions),
-      (0, import_write_file_tool.createWriteFileTool)(fileToolOptions),
-      (0, import_edit_file_tool.createEditFileTool)(fileToolOptions),
-      (0, import_glob_files_tool.createGlobFilesTool)(fileSystemService),
-      (0, import_grep_content_tool.createGrepContentTool)(fileSystemService)
-    ];
+    const toolCreators = {
+      read_file: () => (0, import_read_file_tool.createReadFileTool)(fileToolOptions),
+      write_file: () => (0, import_write_file_tool.createWriteFileTool)(fileToolOptions),
+      edit_file: () => (0, import_edit_file_tool.createEditFileTool)(fileToolOptions),
+      glob_files: () => (0, import_glob_files_tool.createGlobFilesTool)(fileToolOptions),
+      grep_content: () => (0, import_grep_content_tool.createGrepContentTool)(fileToolOptions)
+    };
+    const toolsToCreate = config.enabledTools ?? FILESYSTEM_TOOL_NAMES;
+    if (config.enabledTools) {
+      logger.debug(`Creating subset of filesystem tools: ${toolsToCreate.join(", ")}`);
+    }
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
   },
   metadata: {
     displayName: "FileSystem Tools",

package/dist/tool-provider.d.cts

@@ -34,16 +34,18 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enableBackups: z.ZodDefault<z.ZodBoolean>;
     backupPath: z.ZodOptional<z.ZodString>;
     backupRetentionDays: z.ZodDefault<z.ZodNumber>;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["read_file", "write_file", "edit_file", "glob_files", "grep_content"]>, "many">>;
 }, "strict", z.ZodTypeAny, {
-    type: "filesystem-tools";
     allowedPaths: string[];
     blockedExtensions: string[];
     blockedPaths: string[];
     maxFileSize: number;
     enableBackups: boolean;
     backupRetentionDays: number;
+    type: "filesystem-tools";
     backupPath?: string | undefined;
     workingDirectory?: string | undefined;
+    enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
 }, {
     type: "filesystem-tools";
     allowedPaths?: string[] | undefined;
@@ -54,6 +56,7 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enableBackups?: boolean | undefined;
     backupRetentionDays?: number | undefined;
     workingDirectory?: string | undefined;
+    enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
 }>;
 type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
 /**

package/dist/tool-provider.d.ts

@@ -34,16 +34,18 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enableBackups: z.ZodDefault<z.ZodBoolean>;
     backupPath: z.ZodOptional<z.ZodString>;
     backupRetentionDays: z.ZodDefault<z.ZodNumber>;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["read_file", "write_file", "edit_file", "glob_files", "grep_content"]>, "many">>;
 }, "strict", z.ZodTypeAny, {
-    type: "filesystem-tools";
     allowedPaths: string[];
     blockedExtensions: string[];
     blockedPaths: string[];
     maxFileSize: number;
     enableBackups: boolean;
     backupRetentionDays: number;
+    type: "filesystem-tools";
     backupPath?: string | undefined;
     workingDirectory?: string | undefined;
+    enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
 }, {
     type: "filesystem-tools";
     allowedPaths?: string[] | undefined;
@@ -54,6 +56,7 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enableBackups?: boolean | undefined;
     backupRetentionDays?: number | undefined;
     workingDirectory?: string | undefined;
+    enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
 }>;
 type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
 /**

package/dist/tool-provider.js

@@ -11,6 +11,13 @@ const DEFAULT_BLOCKED_EXTENSIONS = [".exe", ".dll", ".so"];
 const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
 const DEFAULT_ENABLE_BACKUPS = false;
 const DEFAULT_BACKUP_RETENTION_DAYS = 7;
+const FILESYSTEM_TOOL_NAMES = [
+  "read_file",
+  "write_file",
+  "edit_file",
+  "glob_files",
+  "grep_content"
+];
 const FileSystemToolsConfigSchema = z.object({
   type: z.literal("filesystem-tools"),
   allowedPaths: z.array(z.string()).default(DEFAULT_ALLOWED_PATHS).describe("List of allowed base paths for file operations"),
@@ -24,6 +31,9 @@ const FileSystemToolsConfigSchema = z.object({
   backupPath: z.string().optional().describe("Absolute path for storing file backups (if enableBackups is true)"),
   backupRetentionDays: z.number().int().positive().default(DEFAULT_BACKUP_RETENTION_DAYS).describe(
     `Number of days to retain backup files (default: ${DEFAULT_BACKUP_RETENTION_DAYS})`
+  ),
+  enabledTools: z.array(z.enum(FILESYSTEM_TOOL_NAMES)).optional().describe(
+    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${FILESYSTEM_TOOL_NAMES.join(", ")}`
   )
 }).strict();
 const fileSystemToolsProvider = {
@@ -65,13 +75,18 @@ const fileSystemToolsProvider = {
       fileSystemService,
       directoryApproval
     };
-    return [
-      createReadFileTool(fileToolOptions),
-      createWriteFileTool(fileToolOptions),
-      createEditFileTool(fileToolOptions),
-      createGlobFilesTool(fileSystemService),
-      createGrepContentTool(fileSystemService)
-    ];
+    const toolCreators = {
+      read_file: () => createReadFileTool(fileToolOptions),
+      write_file: () => createWriteFileTool(fileToolOptions),
+      edit_file: () => createEditFileTool(fileToolOptions),
+      glob_files: () => createGlobFilesTool(fileToolOptions),
+      grep_content: () => createGrepContentTool(fileToolOptions)
+    };
+    const toolsToCreate = config.enabledTools ?? FILESYSTEM_TOOL_NAMES;
+    if (config.enabledTools) {
+      logger.debug(`Creating subset of filesystem tools: ${toolsToCreate.join(", ")}`);
+    }
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
   },
   metadata: {
     displayName: "FileSystem Tools",

package/dist/types.d.cts

@@ -112,6 +112,8 @@ interface WriteResult {
     path: string;
     bytesWritten: number;
     backupPath?: string | undefined;
+    /** Original content if file was overwritten (undefined for new files) */
+    originalContent?: string | undefined;
 }
 /**
  * Edit operation
@@ -138,6 +140,10 @@ interface EditResult {
     path: string;
     changesCount: number;
     backupPath?: string | undefined;
+    /** Original content before edit (for diff generation) */
+    originalContent: string;
+    /** New content after edit (for diff generation) */
+    newContent: string;
 }
 /**
  * Path validation result

package/dist/types.d.ts

@@ -112,6 +112,8 @@ interface WriteResult {
     path: string;
     bytesWritten: number;
     backupPath?: string | undefined;
+    /** Original content if file was overwritten (undefined for new files) */
+    originalContent?: string | undefined;
 }
 /**
  * Edit operation
@@ -138,6 +140,10 @@ interface EditResult {
     path: string;
     changesCount: number;
     backupPath?: string | undefined;
+    /** Original content before edit (for diff generation) */
+    originalContent: string;
+    /** New content after edit (for diff generation) */
+    newContent: string;
 }
 /**
  * Path validation result

package/dist/write-file-tool.cjs

@@ -32,10 +32,16 @@ __export(write_file_tool_exports, {
 });
 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");
+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"),
   content: import_zod.z.string().describe("Content to write to the file"),
@@ -67,10 +73,10 @@ function createWriteFileTool(options) {
      * Check if this write operation needs directory access approval.
      * Returns custom approval request if the file is outside allowed paths.
      */
-    getApprovalOverride: (args) => {
+    getApprovalOverride: async (args) => {
       const { file_path } = args;
       if (!file_path) return null;
-      const isAllowed = fileSystemService.isPathWithinConfigAllowed(file_path);
+      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
       if (isAllowed) {
         return null;
       }
@@ -105,15 +111,25 @@ function createWriteFileTool(options) {
     },
     /**
      * Generate preview for approval UI - shows diff or file creation info
+     * Stores content hash for change detection in execute phase.
      */
-    generatePreview: async (input, _context) => {
+    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);
+          }
           const lineCount = content.split("\n").length;
           const preview = {
             type: "file",
@@ -129,24 +145,42 @@ function createWriteFileTool(options) {
         throw error;
       }
     },
-    execute: async (input, _context) => {
+    execute: async (input, context) => {
       const { file_path, content, create_dirs, encoding } = input;
       let originalContent = null;
+      let fileExistsNow = false;
       try {
         const originalFile = await fileSystemService.readFile(file_path);
         originalContent = originalFile.content;
+        fileExistsNow = true;
       } catch (error) {
         if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
           originalContent = null;
+          fileExistsNow = false;
         } else {
           throw error;
         }
       }
+      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);
+          }
+        } else if (expectedHash !== null) {
+          if (!fileExistsNow) {
+            throw import_core.ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+          const currentHash = computeContentHash(originalContent);
+          if (expectedHash !== currentHash) {
+            throw import_core.ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+        }
+      }
       const result = await fileSystemService.writeFile(file_path, content, {
         createDirs: create_dirs,
-        encoding,
-        backup: true
-        // Always create backup for internal tools
+        encoding
       });
       let _display;
       if (originalContent === null) {

package/dist/write-file-tool.js

@@ -1,8 +1,18 @@
 import * as path from "node:path";
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { DextoRuntimeError, ApprovalType } from "@dexto/core";
+import {
+  DextoRuntimeError,
+  ApprovalType,
+  ToolError
+} from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.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"),
   content: z.string().describe("Content to write to the file"),
@@ -34,10 +44,10 @@ function createWriteFileTool(options) {
      * Check if this write operation needs directory access approval.
      * Returns custom approval request if the file is outside allowed paths.
      */
-    getApprovalOverride: (args) => {
+    getApprovalOverride: async (args) => {
       const { file_path } = args;
       if (!file_path) return null;
-      const isAllowed = fileSystemService.isPathWithinConfigAllowed(file_path);
+      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
       if (isAllowed) {
         return null;
       }
@@ -72,15 +82,25 @@ function createWriteFileTool(options) {
     },
     /**
      * Generate preview for approval UI - shows diff or file creation info
+     * Stores content hash for change detection in execute phase.
      */
-    generatePreview: async (input, _context) => {
+    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);
+          }
           const lineCount = content.split("\n").length;
           const preview = {
             type: "file",
@@ -96,24 +116,42 @@ function createWriteFileTool(options) {
         throw error;
       }
     },
-    execute: async (input, _context) => {
+    execute: async (input, context) => {
       const { file_path, content, create_dirs, encoding } = input;
       let originalContent = null;
+      let fileExistsNow = false;
       try {
         const originalFile = await fileSystemService.readFile(file_path);
         originalContent = originalFile.content;
+        fileExistsNow = true;
       } catch (error) {
         if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
           originalContent = null;
+          fileExistsNow = false;
         } else {
           throw error;
         }
       }
+      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);
+          }
+        } else if (expectedHash !== null) {
+          if (!fileExistsNow) {
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+          const currentHash = computeContentHash(originalContent);
+          if (expectedHash !== currentHash) {
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+        }
+      }
       const result = await fileSystemService.writeFile(file_path, content, {
         createDirs: create_dirs,
-        encoding,
-        backup: true
-        // Always create backup for internal tools
+        encoding
       });
       let _display;
       if (originalContent === null) {

package/dist/write-file-tool.test.cjs

@@ -0,0 +1,217 @@
+"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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 import_vitest = require("vitest");
+var path = __toESM(require("node:path"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var import_write_file_tool = require("./write-file-tool.js");
+var import_filesystem_service = require("./filesystem-service.js");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+const createMockLogger = () => ({
+  debug: import_vitest.vi.fn(),
+  info: import_vitest.vi.fn(),
+  warn: import_vitest.vi.fn(),
+  error: import_vitest.vi.fn(),
+  createChild: import_vitest.vi.fn().mockReturnThis()
+});
+(0, import_vitest.describe)("write_file tool", () => {
+  let mockLogger;
+  let tempDir;
+  let fileSystemService;
+  (0, import_vitest.beforeEach)(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-write-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    fileSystemService = new import_filesystem_service.FileSystemService(
+      {
+        allowedPaths: [tempDir],
+        blockedPaths: [],
+        blockedExtensions: [],
+        maxFileSize: 10 * 1024 * 1024,
+        workingDirectory: tempDir,
+        enableBackups: false,
+        backupRetentionDays: 7
+      },
+      mockLogger
+    );
+    await fileSystemService.initialize();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
+    (0, import_vitest.it)("should succeed when existing file is not modified between preview and execute", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-123";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      (0, import_vitest.expect)(preview).toBeDefined();
+      (0, import_vitest.expect)(preview?.type).toBe("diff");
+      const result = await tool.execute(input, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      (0, import_vitest.expect)(result.path).toBe(testFile);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("new content");
+    });
+    (0, import_vitest.it)("should fail when existing file is modified between preview and execute", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-456";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.writeFile(testFile, "user modified this");
+      try {
+        await tool.execute(input, { toolCallId });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("user modified this");
+    });
+    (0, import_vitest.it)("should fail when existing file is deleted between preview and execute", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-deleted";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.unlink(testFile);
+      try {
+        await tool.execute(input, { toolCallId });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+    });
+  });
+  (0, import_vitest.describe)("File Modification Detection - New Files", () => {
+    (0, import_vitest.it)("should succeed when creating new file that still does not exist", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "new-file.txt");
+      const toolCallId = "test-call-new";
+      const input = {
+        file_path: testFile,
+        content: "brand new content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      (0, import_vitest.expect)(preview).toBeDefined();
+      (0, import_vitest.expect)(preview?.type).toBe("file");
+      (0, import_vitest.expect)(preview.operation).toBe("create");
+      const result = await tool.execute(input, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("brand new content");
+    });
+    (0, import_vitest.it)("should fail when file is created by someone else between preview and execute", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "race-condition.txt");
+      const toolCallId = "test-call-race";
+      const input = {
+        file_path: testFile,
+        content: "agent content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      (0, import_vitest.expect)(preview?.type).toBe("file");
+      await fs.writeFile(testFile, "someone else created this");
+      try {
+        await tool.execute(input, { toolCallId });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("someone else created this");
+    });
+  });
+  (0, import_vitest.describe)("Cache Cleanup", () => {
+    (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original");
+      const toolCallId = "test-call-cleanup";
+      const input = {
+        file_path: testFile,
+        content: "first write"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await tool.execute(input, { toolCallId });
+      const input2 = {
+        file_path: testFile,
+        content: "second write"
+      };
+      await tool.generatePreview(input2, { toolCallId });
+      const result = await tool.execute(input2, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("second write");
+    });
+    (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original");
+      const toolCallId = "test-call-fail";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.writeFile(testFile, "modified");
+      try {
+        await tool.execute(input, { toolCallId });
+      } catch {
+      }
+      await fs.writeFile(testFile, "reset content");
+      await tool.generatePreview(input, { toolCallId });
+      const result = await tool.execute(input, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+    });
+  });
+});

package/dist/write-file-tool.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

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

@@ -0,0 +1,2 @@
+
+export {  }