@dexto/tools-filesystem 1.7.1 → 1.8.0

package/dist/edit-file-tool.js

@@ -3,14 +3,15 @@ import { z } from "zod";
 import { createPatch } from "diff";
 import {
   createLocalToolCallHeader,
-  DextoRuntimeError,
   ToolError,
   ToolErrorCode,
   defineTool,
   truncateForHeader
-} from "@dexto/core";
+} from "@dexto/core/tools";
+import { DextoRuntimeError } from "@dexto/core/errors";
 import { FileSystemErrorCode } from "./error-codes.js";
 import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
+import { toWorkspaceRelativePath } from "./workspace-paths.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
 function computeContentHash(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
@@ -51,7 +52,7 @@ function createEditFileTool(getFileSystemService) {
     }),
     presentation: {
       describeHeader: (input) => createLocalToolCallHeader({
-        title: "Update",
+        title: "Edit",
         argsText: truncateForHeader(input.file_path, 140)
       }),
       /**
@@ -124,54 +125,67 @@ function createEditFileTool(getFileSystemService) {
       }
     },
     async execute(input, context) {
-      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, old_string, new_string, replace_all } = input;
-      const { path: resolvedPath } = resolveFilePath(
-        resolvedFileSystemService.getWorkingDirectory(),
+      const handle = await openWorkspace(context, "edit_file");
+      const workspacePath = toWorkspaceRelativePath(
+        "edit_file",
+        handle.context.path,
         file_path
       );
+      let currentContent = await handle.files.readText(workspacePath);
       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;
+            currentContent = await handle.files.readText(workspacePath);
+          } catch {
+            throw ToolError.fileModifiedSincePreview("edit_file", file_path);
           }
           const currentHash = computeContentHash(currentContent);
           if (expectedHash !== currentHash) {
-            throw ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
+            throw ToolError.fileModifiedSincePreview("edit_file", file_path);
           }
         }
       }
-      const result = await resolvedFileSystemService.editFile(resolvedPath, {
-        oldString: old_string,
-        newString: new_string,
-        replaceAll: replace_all
-      });
-      const _display = generateDiffPreview(
-        resolvedPath,
-        result.originalContent,
-        result.newContent
-      );
+      const occurrences = currentContent.split(old_string).length - 1;
+      if (occurrences === 0) {
+        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)
+          }
+        );
+      }
+      if (!replace_all && occurrences > 1) {
+        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 }
+        );
+      }
+      const newContent = replace_all ? currentContent.split(old_string).join(new_string) : currentContent.replace(old_string, new_string);
+      await handle.files.writeFile(workspacePath, newContent);
+      const _display = generateDiffPreview(file_path, currentContent, newContent);
       return {
-        success: result.success,
-        path: result.path,
-        changes_count: result.changesCount,
-        ...result.backupPath && { backup_path: result.backupPath },
+        success: true,
+        path: file_path,
+        changes_count: occurrences,
         _display
       };
     }
   });
 }
+async function openWorkspace(context, toolName) {
+  if (!context.services) {
+    throw new Error(`${toolName} requires ToolExecutionContext.services`);
+  }
+  return context.services.workspaceManager.open({ intent: "write" });
+}
 export {
   createEditFileTool
 };

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

@@ -46,8 +46,49 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger, overrides = {}) {
-  return { logger, ...overrides };
+function createToolContext(logger, overrides = {}, workspaceRoot = currentWorkspaceRoot) {
+  return {
+    logger,
+    services: createWorkspaceServices(workspaceRoot),
+    ...overrides
+  };
+}
+let currentWorkspaceRoot = process.cwd();
+function createWorkspaceServices(workspaceRoot) {
+  const workspaceManager = {
+    open: import_vitest.vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: workspaceRoot,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8"),
+        readText: async (filePath) => fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8"),
+        glob: import_vitest.vi.fn(async () => []),
+        writeFile: async (filePath, content) => {
+          const resolvedPath = resolveWorkspacePath(workspaceRoot, filePath);
+          await fs.writeFile(resolvedPath, content, "utf-8");
+        },
+        listFiles: import_vitest.vi.fn(async () => [])
+      }
+    }))
+  };
+  return {
+    approval: {},
+    search: {},
+    resources: {},
+    prompts: {},
+    skills: {},
+    mcp: {},
+    taskForker: null,
+    workspaceManager
+  };
+}
+function resolveWorkspacePath(workspaceRoot, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
 }
 (0, import_vitest.describe)("edit_file tool", () => {
   let mockLogger;
@@ -70,6 +111,7 @@ function createToolContext(logger, overrides = {}) {
       mockLogger
     );
     await fileSystemService.initialize();
+    currentWorkspaceRoot = tempDir;
     import_vitest.vi.clearAllMocks();
   });
   (0, import_vitest.afterEach)(async () => {
@@ -78,6 +120,121 @@ function createToolContext(logger, overrides = {}) {
     } catch {
     }
   });
+  (0, import_vitest.it)("edits through WorkspaceManager.open without FileSystemService execution", async () => {
+    await fs.writeFile(path.join(tempDir, "workspace.txt"), "hello world");
+    const getFileSystemService = import_vitest.vi.fn(async () => {
+      throw new Error("edit_file execute must not use FileSystemService");
+    });
+    const tool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "workspace.txt",
+      old_string: "world",
+      new_string: "workspace"
+    });
+    const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+    (0, import_vitest.expect)(getFileSystemService).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(result).toMatchObject({
+      success: true,
+      path: "workspace.txt",
+      changes_count: 1
+    });
+    await (0, import_vitest.expect)(fs.readFile(path.join(tempDir, "workspace.txt"), "utf-8")).resolves.toBe(
+      "hello workspace"
+    );
+  });
+  (0, import_vitest.it)("normalizes workspace-contained absolute paths before editing", async () => {
+    const readText = import_vitest.vi.fn(async () => "hello world");
+    const writeFile = import_vitest.vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: import_vitest.vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: import_vitest.vi.fn(async () => []),
+          writeFile,
+          listFiles: import_vitest.vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = (0, import_edit_file_tool.createEditFileTool)(import_vitest.vi.fn());
+    await tool.execute(
+      tool.inputSchema.parse({
+        file_path: path.join(tempDir, "workspace.txt"),
+        old_string: "world",
+        new_string: "workspace"
+      }),
+      createToolContext(mockLogger, {
+        services: {
+          ...createWorkspaceServices(tempDir),
+          workspaceManager
+        }
+      })
+    );
+    (0, import_vitest.expect)(readText).toHaveBeenCalledWith("workspace.txt");
+    (0, import_vitest.expect)(writeFile).toHaveBeenCalledWith("workspace.txt", "hello workspace");
+  });
+  (0, import_vitest.it)("rejects external absolute paths before file provider calls", async () => {
+    const readText = import_vitest.vi.fn(async () => "hello world");
+    const writeFile = import_vitest.vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: import_vitest.vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: import_vitest.vi.fn(async () => []),
+          writeFile,
+          listFiles: import_vitest.vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = (0, import_edit_file_tool.createEditFileTool)(import_vitest.vi.fn());
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({
+          file_path: "/outside/workspace.txt",
+          old_string: "world",
+          new_string: "workspace"
+        }),
+        createToolContext(mockLogger, {
+          services: {
+            ...createWorkspaceServices(tempDir),
+            workspaceManager
+          }
+        })
+      )
+    ).rejects.toMatchObject({ code: import_core.ToolErrorCode.VALIDATION_FAILED });
+    (0, import_vitest.expect)(readText).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(writeFile).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should describe edit calls with an Edit header", () => {
+    const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+    const header = tool.presentation?.describeHeader?.(
+      tool.inputSchema.parse({
+        file_path: "snake.py",
+        old_string: "old",
+        new_string: "new"
+      }),
+      createToolContext(mockLogger)
+    );
+    (0, import_vitest.expect)(header).toEqual({
+      argsText: "snake.py",
+      title: "Edit"
+    });
+  });
   (0, import_vitest.describe)("File Modification Detection", () => {
     (0, import_vitest.it)("should generate preview for files outside config-allowed roots (preview read only)", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);

package/dist/edit-file-tool.test.js

@@ -23,8 +23,49 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger, overrides = {}) {
-  return { logger, ...overrides };
+function createToolContext(logger, overrides = {}, workspaceRoot = currentWorkspaceRoot) {
+  return {
+    logger,
+    services: createWorkspaceServices(workspaceRoot),
+    ...overrides
+  };
+}
+let currentWorkspaceRoot = process.cwd();
+function createWorkspaceServices(workspaceRoot) {
+  const workspaceManager = {
+    open: vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: workspaceRoot,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8"),
+        readText: async (filePath) => fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8"),
+        glob: vi.fn(async () => []),
+        writeFile: async (filePath, content) => {
+          const resolvedPath = resolveWorkspacePath(workspaceRoot, filePath);
+          await fs.writeFile(resolvedPath, content, "utf-8");
+        },
+        listFiles: vi.fn(async () => [])
+      }
+    }))
+  };
+  return {
+    approval: {},
+    search: {},
+    resources: {},
+    prompts: {},
+    skills: {},
+    mcp: {},
+    taskForker: null,
+    workspaceManager
+  };
+}
+function resolveWorkspacePath(workspaceRoot, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
 }
 describe("edit_file tool", () => {
   let mockLogger;
@@ -47,6 +88,7 @@ describe("edit_file tool", () => {
       mockLogger
     );
     await fileSystemService.initialize();
+    currentWorkspaceRoot = tempDir;
     vi.clearAllMocks();
   });
   afterEach(async () => {
@@ -55,6 +97,121 @@ describe("edit_file tool", () => {
     } catch {
     }
   });
+  it("edits through WorkspaceManager.open without FileSystemService execution", async () => {
+    await fs.writeFile(path.join(tempDir, "workspace.txt"), "hello world");
+    const getFileSystemService = vi.fn(async () => {
+      throw new Error("edit_file execute must not use FileSystemService");
+    });
+    const tool = createEditFileTool(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "workspace.txt",
+      old_string: "world",
+      new_string: "workspace"
+    });
+    const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+    expect(getFileSystemService).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      success: true,
+      path: "workspace.txt",
+      changes_count: 1
+    });
+    await expect(fs.readFile(path.join(tempDir, "workspace.txt"), "utf-8")).resolves.toBe(
+      "hello workspace"
+    );
+  });
+  it("normalizes workspace-contained absolute paths before editing", async () => {
+    const readText = vi.fn(async () => "hello world");
+    const writeFile = vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: vi.fn(async () => []),
+          writeFile,
+          listFiles: vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = createEditFileTool(vi.fn());
+    await tool.execute(
+      tool.inputSchema.parse({
+        file_path: path.join(tempDir, "workspace.txt"),
+        old_string: "world",
+        new_string: "workspace"
+      }),
+      createToolContext(mockLogger, {
+        services: {
+          ...createWorkspaceServices(tempDir),
+          workspaceManager
+        }
+      })
+    );
+    expect(readText).toHaveBeenCalledWith("workspace.txt");
+    expect(writeFile).toHaveBeenCalledWith("workspace.txt", "hello workspace");
+  });
+  it("rejects external absolute paths before file provider calls", async () => {
+    const readText = vi.fn(async () => "hello world");
+    const writeFile = vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: vi.fn(async () => []),
+          writeFile,
+          listFiles: vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = createEditFileTool(vi.fn());
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({
+          file_path: "/outside/workspace.txt",
+          old_string: "world",
+          new_string: "workspace"
+        }),
+        createToolContext(mockLogger, {
+          services: {
+            ...createWorkspaceServices(tempDir),
+            workspaceManager
+          }
+        })
+      )
+    ).rejects.toMatchObject({ code: ToolErrorCode.VALIDATION_FAILED });
+    expect(readText).not.toHaveBeenCalled();
+    expect(writeFile).not.toHaveBeenCalled();
+  });
+  it("should describe edit calls with an Edit header", () => {
+    const tool = createEditFileTool(async () => fileSystemService);
+    const header = tool.presentation?.describeHeader?.(
+      tool.inputSchema.parse({
+        file_path: "snake.py",
+        old_string: "old",
+        new_string: "new"
+      }),
+      createToolContext(mockLogger)
+    );
+    expect(header).toEqual({
+      argsText: "snake.py",
+      title: "Edit"
+    });
+  });
   describe("File Modification Detection", () => {
     it("should generate preview for files outside config-allowed roots (preview read only)", async () => {
       const tool = createEditFileTool(async () => fileSystemService);