@dexto/tools-filesystem 1.6.0 → 1.6.2

package/dist/write-file-tool.js

@@ -1,7 +1,13 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { DextoRuntimeError, ToolError, defineTool } from "@dexto/core";
+import {
+  createLocalToolCallHeader,
+  DextoRuntimeError,
+  ToolError,
+  defineTool,
+  truncateForHeader
+} from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
 import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
@@ -23,6 +29,7 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
@@ -32,55 +39,74 @@ function generateDiffPreview(filePath, originalContent, newContent) {
 function createWriteFileTool(getFileSystemService) {
   return defineTool({
     id: "write_file",
-    displayName: "Write",
     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,
     ...createDirectoryAccessApprovalHandlers({
       toolName: "write_file",
       operation: "write",
+      inputSchema: WriteFileInputSchema,
       getFileSystemService,
       resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
     }),
-    /**
-     * Generate preview for approval UI - shows diff or file creation info
-     * Stores content hash for change detection in execute phase.
-     */
-    async generatePreview(input, context) {
-      const { file_path, content } = input;
-      const resolvedFileSystemService = await getFileSystemService(context);
-      const { path: resolvedPath } = resolveFilePath(
-        resolvedFileSystemService.getWorkingDirectory(),
-        file_path
-      );
-      try {
-        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
-        const originalContent = originalFile.content;
-        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) {
+    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, FILE_NOT_EXISTS_MARKER);
+            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: resolvedPath,
-            operation: "create",
-            size: Buffer.byteLength(content, "utf8"),
-            lineCount,
-            content
-            // Include content for approval preview
-          };
-          return preview;
+          throw error;
         }
-        throw error;
       }
     },
     async execute(input, context) {
@@ -136,10 +162,12 @@ function createWriteFileTool(getFileSystemService) {
         const lineCount = content.split("\n").length;
         _display = {
           type: "file",
+          title: "Create file",
           path: resolvedPath,
           operation: "create",
           size: result.bytesWritten,
-          lineCount
+          lineCount,
+          content
         };
       } else {
         _display = generateDiffPreview(resolvedPath, originalContent, content);

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

@@ -38,6 +38,7 @@ const createMockLogger = () => {
     error: import_vitest.vi.fn(),
     trackException: import_vitest.vi.fn(),
     createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
     setLevel: import_vitest.vi.fn(),
     getLevel: import_vitest.vi.fn(() => "debug"),
     getLogFilePath: import_vitest.vi.fn(() => null),
@@ -78,6 +79,36 @@ function createToolContext(logger, overrides = {}) {
     }
   });
   (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
+    (0, import_vitest.it)("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-write-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "original content");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          content: "new content"
+        });
+        const preview = await tool.presentation.preview(
+          parsedInput,
+          createToolContext(mockLogger, { toolCallId })
+        );
+        (0, import_vitest.expect)(preview).toBeDefined();
+        (0, import_vitest.expect)(preview?.type).toBe("diff");
+        if (preview?.type === "diff") {
+          (0, import_vitest.expect)(preview.title).toBe("Update file");
+          (0, import_vitest.expect)(preview.filename).toBe(externalFile);
+        } else {
+          import_vitest.expect.fail("Expected diff preview");
+        }
+      } finally {
+        await fs.rm(externalDir, { recursive: true, force: true });
+      }
+    });
     (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)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
@@ -88,12 +119,17 @@ function createToolContext(logger, overrides = {}) {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await tool.presentation.preview(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       (0, import_vitest.expect)(preview).toBeDefined();
       (0, import_vitest.expect)(preview?.type).toBe("diff");
+      if (preview?.type === "diff") {
+        (0, import_vitest.expect)(preview.title).toBe("Update file");
+      } else {
+        import_vitest.expect.fail("Expected diff preview");
+      }
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
@@ -113,7 +149,10 @@ function createToolContext(logger, overrides = {}) {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.writeFile(testFile, "user modified this");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -137,7 +176,10 @@ function createToolContext(logger, overrides = {}) {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.unlink(testFile);
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -160,23 +202,39 @@ function createToolContext(logger, overrides = {}) {
         content: "brand new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await tool.presentation.preview(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       (0, import_vitest.expect)(preview).toBeDefined();
       (0, import_vitest.expect)(preview?.type).toBe("file");
-      (0, import_vitest.expect)(preview.operation).toBe("create");
+      if (preview?.type === "file") {
+        (0, import_vitest.expect)(preview.operation).toBe("create");
+        (0, import_vitest.expect)(preview.title).toBe("Create file");
+      } else {
+        import_vitest.expect.fail("Expected file preview");
+      }
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       (0, import_vitest.expect)(result.success).toBe(true);
+      const display = result._display;
+      if (display && typeof display === "object" && "type" in display) {
+        (0, import_vitest.expect)(display.type).toBe("file");
+        const fileDisplay = display;
+        (0, import_vitest.expect)(fileDisplay.title).toBe("Create file");
+        (0, import_vitest.expect)(fileDisplay.content).toBe("brand new content");
+      } else {
+        import_vitest.expect.fail("Expected result._display");
+      }
       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)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "race-condition.txt");
       const toolCallId = "test-call-race";
       const input = {
@@ -184,7 +242,7 @@ function createToolContext(logger, overrides = {}) {
         content: "agent content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -214,17 +272,19 @@ function createToolContext(logger, overrides = {}) {
         content: "first write"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         content: "second write"
       };
       const parsedInput2 = tool.inputSchema.parse(input2);
-      await tool.generatePreview(
-        parsedInput2,
-        createToolContext(mockLogger, { toolCallId })
-      );
+      const previewFn2 = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn2).toBeDefined();
+      await previewFn2(parsedInput2, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput2,
         createToolContext(mockLogger, { toolCallId })
@@ -243,14 +303,16 @@ function createToolContext(logger, overrides = {}) {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "reset content");
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })

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

@@ -15,6 +15,7 @@ const createMockLogger = () => {
     error: vi.fn(),
     trackException: vi.fn(),
     createChild: vi.fn(() => logger),
+    createFileOnlyChild: vi.fn(() => logger),
     setLevel: vi.fn(),
     getLevel: vi.fn(() => "debug"),
     getLogFilePath: vi.fn(() => null),
@@ -55,6 +56,36 @@ describe("write_file tool", () => {
     }
   });
   describe("File Modification Detection - Existing Files", () => {
+    it("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
+      const tool = createWriteFileTool(async () => fileSystemService);
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-write-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "original content");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          content: "new content"
+        });
+        const preview = await tool.presentation.preview(
+          parsedInput,
+          createToolContext(mockLogger, { toolCallId })
+        );
+        expect(preview).toBeDefined();
+        expect(preview?.type).toBe("diff");
+        if (preview?.type === "diff") {
+          expect(preview.title).toBe("Update file");
+          expect(preview.filename).toBe(externalFile);
+        } else {
+          expect.fail("Expected diff preview");
+        }
+      } finally {
+        await fs.rm(externalDir, { recursive: true, force: true });
+      }
+    });
     it("should succeed when existing file is not modified between preview and execute", async () => {
       const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
@@ -65,12 +96,17 @@ describe("write_file tool", () => {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await tool.presentation.preview(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("diff");
+      if (preview?.type === "diff") {
+        expect(preview.title).toBe("Update file");
+      } else {
+        expect.fail("Expected diff preview");
+      }
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
@@ -90,7 +126,10 @@ describe("write_file tool", () => {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.writeFile(testFile, "user modified this");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -114,7 +153,10 @@ describe("write_file tool", () => {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.unlink(testFile);
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -137,23 +179,39 @@ describe("write_file tool", () => {
         content: "brand new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await tool.presentation.preview(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("file");
-      expect(preview.operation).toBe("create");
+      if (preview?.type === "file") {
+        expect(preview.operation).toBe("create");
+        expect(preview.title).toBe("Create file");
+      } else {
+        expect.fail("Expected file preview");
+      }
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
       expect(result.success).toBe(true);
+      const display = result._display;
+      if (display && typeof display === "object" && "type" in display) {
+        expect(display.type).toBe("file");
+        const fileDisplay = display;
+        expect(fileDisplay.title).toBe("Create file");
+        expect(fileDisplay.content).toBe("brand new content");
+      } else {
+        expect.fail("Expected result._display");
+      }
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("brand new content");
     });
     it("should fail when file is created by someone else between preview and execute", async () => {
       const tool = createWriteFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "race-condition.txt");
       const toolCallId = "test-call-race";
       const input = {
@@ -161,7 +219,7 @@ describe("write_file tool", () => {
         content: "agent content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -191,17 +249,19 @@ describe("write_file tool", () => {
         content: "first write"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         content: "second write"
       };
       const parsedInput2 = tool.inputSchema.parse(input2);
-      await tool.generatePreview(
-        parsedInput2,
-        createToolContext(mockLogger, { toolCallId })
-      );
+      const previewFn2 = tool.presentation?.preview;
+      expect(previewFn2).toBeDefined();
+      await previewFn2(parsedInput2, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput2,
         createToolContext(mockLogger, { toolCallId })
@@ -220,14 +280,16 @@ describe("write_file tool", () => {
         content: "new content"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "reset content");
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-filesystem",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "FileSystem tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,12 +18,12 @@
     "file-operations"
   ],
   "dependencies": {
-    "diff": "^7.0.0",
-    "glob": "^11.1.0",
+    "diff": "^8.0.3",
+    "glob": "^12.0.0",
     "safe-regex": "^2.1.1",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/agent-config": "1.6.2",
+    "@dexto/core": "1.6.2"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",
@@ -36,7 +36,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

package/dist/directory-approval.d.cts

@@ -1,22 +0,0 @@
-import { ToolExecutionContext, ApprovalRequestDetails, ApprovalResponse } from '@dexto/core';
-import { FileSystemService } from './filesystem-service.cjs';
-import { FileSystemServiceGetter } from './file-tool-types.cjs';
-import './types.cjs';
-
-type DirectoryApprovalOperation = 'read' | 'write' | 'edit';
-type DirectoryApprovalPaths = {
-    path: string;
-    parentDir: string;
-};
-declare function resolveFilePath(workingDirectory: string, filePath: string): DirectoryApprovalPaths;
-declare function createDirectoryAccessApprovalHandlers<TInput>(options: {
-    toolName: string;
-    operation: DirectoryApprovalOperation;
-    getFileSystemService: FileSystemServiceGetter;
-    resolvePaths: (input: TInput, fileSystemService: FileSystemService) => DirectoryApprovalPaths;
-}): {
-    getApprovalOverride: (input: TInput, context: ToolExecutionContext) => Promise<ApprovalRequestDetails | null>;
-    onApprovalGranted: (response: ApprovalResponse, context: ToolExecutionContext, approvalRequest: ApprovalRequestDetails) => void;
-};
-
-export { createDirectoryAccessApprovalHandlers, resolveFilePath };

package/dist/directory-approval.integration.test.d.cts

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

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

@@ -1,34 +0,0 @@
-import { z } from 'zod';
-import { Tool } from '@dexto/core';
-import { FileSystemServiceGetter } from './file-tool-types.cjs';
-import './filesystem-service.cjs';
-import './types.cjs';
-
-/**
- * Edit File Tool
- *
- * 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(getFileSystemService: FileSystemServiceGetter): Tool<typeof EditFileInputSchema>;
-
-export { createEditFileTool };

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

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

package/dist/error-codes.d.cts

@@ -1,32 +0,0 @@
-/**
- * FileSystem Service Error Codes
- *
- * Standardized error codes for file system operations
- */
-declare enum FileSystemErrorCode {
-    FILE_NOT_FOUND = "FILESYSTEM_FILE_NOT_FOUND",
-    DIRECTORY_NOT_FOUND = "FILESYSTEM_DIRECTORY_NOT_FOUND",
-    PERMISSION_DENIED = "FILESYSTEM_PERMISSION_DENIED",
-    PATH_NOT_ALLOWED = "FILESYSTEM_PATH_NOT_ALLOWED",
-    PATH_BLOCKED = "FILESYSTEM_PATH_BLOCKED",
-    INVALID_PATH = "FILESYSTEM_INVALID_PATH",
-    PATH_TRAVERSAL_DETECTED = "FILESYSTEM_PATH_TRAVERSAL_DETECTED",
-    INVALID_FILE_EXTENSION = "FILESYSTEM_INVALID_FILE_EXTENSION",
-    INVALID_ENCODING = "FILESYSTEM_INVALID_ENCODING",
-    FILE_TOO_LARGE = "FILESYSTEM_FILE_TOO_LARGE",
-    TOO_MANY_RESULTS = "FILESYSTEM_TOO_MANY_RESULTS",
-    READ_FAILED = "FILESYSTEM_READ_FAILED",
-    WRITE_FAILED = "FILESYSTEM_WRITE_FAILED",
-    BACKUP_FAILED = "FILESYSTEM_BACKUP_FAILED",
-    EDIT_FAILED = "FILESYSTEM_EDIT_FAILED",
-    STRING_NOT_UNIQUE = "FILESYSTEM_STRING_NOT_UNIQUE",
-    STRING_NOT_FOUND = "FILESYSTEM_STRING_NOT_FOUND",
-    GLOB_FAILED = "FILESYSTEM_GLOB_FAILED",
-    SEARCH_FAILED = "FILESYSTEM_SEARCH_FAILED",
-    INVALID_PATTERN = "FILESYSTEM_INVALID_PATTERN",
-    REGEX_TIMEOUT = "FILESYSTEM_REGEX_TIMEOUT",
-    INVALID_CONFIG = "FILESYSTEM_INVALID_CONFIG",
-    SERVICE_NOT_INITIALIZED = "FILESYSTEM_SERVICE_NOT_INITIALIZED"
-}
-
-export { FileSystemErrorCode };