@dexto/tools-filesystem 1.5.8 → 1.6.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"read-file-tool.d.ts","sourceRoot":"","sources":["../src/read-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAmB,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAGpE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;EAgBZ,CAAC;AAEd;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAqDlC"}

package/dist/read-file-tool.js

@@ -1,67 +1,38 @@
-import * as path from "node:path";
 import { z } from "zod";
-import { ApprovalType } from "@dexto/core";
+import { defineTool } from "@dexto/core";
+import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const ReadFileInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to the file to read"),
+  file_path: z.string().min(1).describe("Absolute path to the file to read"),
   limit: z.number().int().positive().optional().describe("Maximum number of lines to read (optional)"),
   offset: z.number().int().min(1).optional().describe("Starting line number (1-based, optional)")
 }).strict();
-function createReadFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createReadFileTool(getFileSystemService) {
+  return defineTool({
     id: "read_file",
+    displayName: "Read",
+    aliases: ["read"],
     description: "Read the contents of a file with optional pagination. Returns file content, line count, encoding, and whether the output was truncated. Use limit and offset parameters for large files to read specific sections. This tool is for reading files within allowed paths only.",
     inputSchema: ReadFileInputSchema,
-    /**
-     * Check if this read 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: "read",
-          toolName: "read_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;
-    },
-    execute: async (input, _context) => {
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "read_file",
+      operation: "read",
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, limit, offset } = input;
-      const result = await fileSystemService.readFile(file_path, {
+      const { path: resolvedPath } = resolveFilePath(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
+      const result = await resolvedFileSystemService.readFile(resolvedPath, {
         limit,
         offset
       });
       const _display = {
         type: "file",
-        path: file_path,
+        path: resolvedPath,
         operation: "read",
         size: result.size,
         lineCount: result.lines
@@ -76,7 +47,7 @@ function createReadFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createReadFileTool

package/dist/tool-factory-config.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_factory_config_exports = {};
+__export(tool_factory_config_exports, {
+  FILESYSTEM_TOOL_NAMES: () => FILESYSTEM_TOOL_NAMES,
+  FileSystemToolsConfigSchema: () => FileSystemToolsConfigSchema
+});
+module.exports = __toCommonJS(tool_factory_config_exports);
+var import_zod = require("zod");
+const DEFAULT_ALLOWED_PATHS = ["."];
+const DEFAULT_BLOCKED_PATHS = [".git", "node_modules/.bin", ".env"];
+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"),
+  blockedPaths: import_zod.z.array(import_zod.z.string()).default(DEFAULT_BLOCKED_PATHS).describe("List of blocked paths to exclude from operations"),
+  blockedExtensions: import_zod.z.array(import_zod.z.string()).default(DEFAULT_BLOCKED_EXTENSIONS).describe("List of blocked file extensions"),
+  maxFileSize: import_zod.z.number().int().positive().default(DEFAULT_MAX_FILE_SIZE).describe(
+    `Maximum file size in bytes (default: ${DEFAULT_MAX_FILE_SIZE / 1024 / 1024}MB)`
+  ),
+  workingDirectory: import_zod.z.string().optional().describe("Working directory for file operations (defaults to process.cwd())"),
+  enableBackups: import_zod.z.boolean().default(DEFAULT_ENABLE_BACKUPS).describe("Enable automatic backups of modified files"),
+  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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FILESYSTEM_TOOL_NAMES,
+  FileSystemToolsConfigSchema
+});

package/dist/{tool-provider.d.ts → tool-factory-config.d.cts}

@@ -1,19 +1,19 @@
 import { z } from 'zod';
-import { CustomToolProvider } from '@dexto/core';
-export { FileToolOptions } from './file-tool-types.js';
-import './filesystem-service.js';
-import './types.js';
 
 /**
- * FileSystem Tools Provider
+ * FileSystem Tools Factory
  *
  * Provides file operation tools by wrapping FileSystemService.
- * When registered, the provider initializes FileSystemService and creates tools
+ * When registered, the factory initializes FileSystemService and creates tools
  * for file operations (read, write, edit, glob, grep).
  */
 
 /**
- * Configuration schema for FileSystem tools provider.
+ * Available filesystem tool names for enabledTools configuration.
+ */
+declare const FILESYSTEM_TOOL_NAMES: readonly ["read_file", "write_file", "edit_file", "glob_files", "grep_content"];
+/**
+ * Configuration schema for FileSystem tools factory.
  *
  * This is the SINGLE SOURCE OF TRUTH for all configuration:
  * - Validation rules
@@ -36,13 +36,13 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     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;
@@ -59,19 +59,5 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
 }>;
 type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
-/**
- * FileSystem tools provider.
- *
- * Wraps FileSystemService and provides file operation tools:
- * - read_file: Read file contents with pagination
- * - write_file: Write or overwrite file contents
- * - edit_file: Edit files using search/replace operations
- * - glob_files: Find files matching glob patterns
- * - grep_content: Search file contents using regex
- *
- * When registered via customToolRegistry, FileSystemService is automatically
- * initialized and file operation tools become available to the agent.
- */
-declare const fileSystemToolsProvider: CustomToolProvider<'filesystem-tools', FileSystemToolsConfig>;
 
-export { fileSystemToolsProvider };
+export { FILESYSTEM_TOOL_NAMES, type FileSystemToolsConfig, FileSystemToolsConfigSchema };

package/dist/{tool-provider.d.cts → tool-factory-config.d.ts}

@@ -1,19 +1,17 @@
-import { z } from 'zod';
-import { CustomToolProvider } from '@dexto/core';
-export { FileToolOptions } from './file-tool-types.cjs';
-import './filesystem-service.cjs';
-import './types.cjs';
-
 /**
- * FileSystem Tools Provider
+ * FileSystem Tools Factory
  *
  * Provides file operation tools by wrapping FileSystemService.
- * When registered, the provider initializes FileSystemService and creates tools
+ * When registered, the factory initializes FileSystemService and creates tools
  * for file operations (read, write, edit, glob, grep).
  */
-
+import { z } from 'zod';
+/**
+ * Available filesystem tool names for enabledTools configuration.
+ */
+export declare const FILESYSTEM_TOOL_NAMES: readonly ["read_file", "write_file", "edit_file", "glob_files", "grep_content"];
 /**
- * Configuration schema for FileSystem tools provider.
+ * Configuration schema for FileSystem tools factory.
  *
  * This is the SINGLE SOURCE OF TRUTH for all configuration:
  * - Validation rules
@@ -24,7 +22,7 @@ import './types.cjs';
  * Services receive fully-validated config from this schema and use it as-is,
  * with no additional defaults or fallbacks needed.
  */
-declare const FileSystemToolsConfigSchema: z.ZodObject<{
+export declare const FileSystemToolsConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"filesystem-tools">;
     allowedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     blockedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -45,7 +43,7 @@ declare const FileSystemToolsConfigSchema: z.ZodObject<{
     type: "filesystem-tools";
     backupPath?: string | undefined;
     workingDirectory?: string | undefined;
-    enabledTools?: ("edit_file" | "glob_files" | "grep_content" | "read_file" | "write_file")[] | undefined;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content")[] | undefined;
 }, {
     type: "filesystem-tools";
     allowedPaths?: string[] | undefined;
@@ -56,22 +54,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;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content")[] | undefined;
 }>;
-type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
-/**
- * FileSystem tools provider.
- *
- * Wraps FileSystemService and provides file operation tools:
- * - read_file: Read file contents with pagination
- * - write_file: Write or overwrite file contents
- * - edit_file: Edit files using search/replace operations
- * - glob_files: Find files matching glob patterns
- * - grep_content: Search file contents using regex
- *
- * When registered via customToolRegistry, FileSystemService is automatically
- * initialized and file operation tools become available to the agent.
- */
-declare const fileSystemToolsProvider: CustomToolProvider<'filesystem-tools', FileSystemToolsConfig>;
-
-export { fileSystemToolsProvider };
+export type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
+//# sourceMappingURL=tool-factory-config.d.ts.map

package/dist/tool-factory-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory-config.d.ts","sourceRoot":"","sources":["../src/tool-factory-config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB;;GAEG;AACH,eAAO,MAAM,qBAAqB,iFAMxB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkD3B,CAAC;AAEd,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/tool-factory-config.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+const DEFAULT_ALLOWED_PATHS = ["."];
+const DEFAULT_BLOCKED_PATHS = [".git", "node_modules/.bin", ".env"];
+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"),
+  blockedPaths: z.array(z.string()).default(DEFAULT_BLOCKED_PATHS).describe("List of blocked paths to exclude from operations"),
+  blockedExtensions: z.array(z.string()).default(DEFAULT_BLOCKED_EXTENSIONS).describe("List of blocked file extensions"),
+  maxFileSize: z.number().int().positive().default(DEFAULT_MAX_FILE_SIZE).describe(
+    `Maximum file size in bytes (default: ${DEFAULT_MAX_FILE_SIZE / 1024 / 1024}MB)`
+  ),
+  workingDirectory: z.string().optional().describe("Working directory for file operations (defaults to process.cwd())"),
+  enableBackups: z.boolean().default(DEFAULT_ENABLE_BACKUPS).describe("Enable automatic backups of modified files"),
+  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();
+export {
+  FILESYSTEM_TOOL_NAMES,
+  FileSystemToolsConfigSchema
+};

package/dist/tool-factory.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_factory_exports = {};
+__export(tool_factory_exports, {
+  fileSystemToolsFactory: () => fileSystemToolsFactory
+});
+module.exports = __toCommonJS(tool_factory_exports);
+var import_core = require("@dexto/core");
+var import_filesystem_service = require("./filesystem-service.js");
+var import_read_file_tool = require("./read-file-tool.js");
+var import_write_file_tool = require("./write-file-tool.js");
+var import_edit_file_tool = require("./edit-file-tool.js");
+var import_glob_files_tool = require("./glob-files-tool.js");
+var import_grep_content_tool = require("./grep-content-tool.js");
+var import_tool_factory_config = require("./tool-factory-config.js");
+const fileSystemToolsFactory = {
+  configSchema: import_tool_factory_config.FileSystemToolsConfigSchema,
+  metadata: {
+    displayName: "Filesystem Tools",
+    description: "File system operations (read, write, edit, glob, grep)",
+    category: "filesystem"
+  },
+  create: (config) => {
+    const fileSystemConfig = {
+      allowedPaths: config.allowedPaths,
+      blockedPaths: config.blockedPaths,
+      blockedExtensions: config.blockedExtensions,
+      maxFileSize: config.maxFileSize,
+      workingDirectory: config.workingDirectory ?? process.cwd(),
+      enableBackups: config.enableBackups,
+      backupPath: config.backupPath,
+      backupRetentionDays: config.backupRetentionDays
+    };
+    let fileSystemService;
+    const resolveWorkingDirectory = (context) => context.workspace?.path ?? fileSystemConfig.workingDirectory ?? process.cwd();
+    const applyWorkspace = (context, service) => {
+      const workingDirectory = resolveWorkingDirectory(context);
+      service.setWorkingDirectory(workingDirectory);
+    };
+    const getFileSystemService = async (context) => {
+      if (fileSystemService) {
+        const approvalManager2 = context.services?.approval;
+        if (!approvalManager2) {
+          throw import_core.ToolError.configInvalid(
+            "filesystem-tools requires ToolExecutionContext.services.approval"
+          );
+        }
+        fileSystemService.setDirectoryApprovalChecker(
+          (filePath) => approvalManager2.isDirectoryApproved(filePath)
+        );
+        applyWorkspace(context, fileSystemService);
+        return fileSystemService;
+      }
+      const logger = context.logger;
+      fileSystemService = new import_filesystem_service.FileSystemService(fileSystemConfig, logger);
+      const approvalManager = context.services?.approval;
+      if (!approvalManager) {
+        throw import_core.ToolError.configInvalid(
+          "filesystem-tools requires ToolExecutionContext.services.approval"
+        );
+      }
+      fileSystemService.setDirectoryApprovalChecker(
+        (filePath) => approvalManager.isDirectoryApproved(filePath)
+      );
+      applyWorkspace(context, fileSystemService);
+      fileSystemService.initialize().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to initialize FileSystemService: ${message}`);
+      });
+      return fileSystemService;
+    };
+    const toolCreators = {
+      read_file: () => (0, import_read_file_tool.createReadFileTool)(getFileSystemService),
+      write_file: () => (0, import_write_file_tool.createWriteFileTool)(getFileSystemService),
+      edit_file: () => (0, import_edit_file_tool.createEditFileTool)(getFileSystemService),
+      glob_files: () => (0, import_glob_files_tool.createGlobFilesTool)(getFileSystemService),
+      grep_content: () => (0, import_grep_content_tool.createGrepContentTool)(getFileSystemService)
+    };
+    const toolsToCreate = config.enabledTools ?? import_tool_factory_config.FILESYSTEM_TOOL_NAMES;
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileSystemToolsFactory
+});

package/dist/tool-factory.d.cts

@@ -0,0 +1,7 @@
+import { ToolFactory } from '@dexto/agent-config';
+import { FileSystemToolsConfig } from './tool-factory-config.cjs';
+import 'zod';
+
+declare const fileSystemToolsFactory: ToolFactory<FileSystemToolsConfig>;
+
+export { fileSystemToolsFactory };

package/dist/tool-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolFactory } from '@dexto/agent-config';
+import { type FileSystemToolsConfig } from './tool-factory-config.js';
+export declare const fileSystemToolsFactory: ToolFactory<FileSystemToolsConfig>;
+//# sourceMappingURL=tool-factory.d.ts.map

package/dist/tool-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AASvD,OAAO,EAGH,KAAK,qBAAqB,EAC7B,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,qBAAqB,CAgFrE,CAAC"}

package/dist/tool-factory.js

@@ -0,0 +1,81 @@
+import { ToolError } from "@dexto/core";
+import { FileSystemService } from "./filesystem-service.js";
+import { createReadFileTool } from "./read-file-tool.js";
+import { createWriteFileTool } from "./write-file-tool.js";
+import { createEditFileTool } from "./edit-file-tool.js";
+import { createGlobFilesTool } from "./glob-files-tool.js";
+import { createGrepContentTool } from "./grep-content-tool.js";
+import {
+  FILESYSTEM_TOOL_NAMES,
+  FileSystemToolsConfigSchema
+} from "./tool-factory-config.js";
+const fileSystemToolsFactory = {
+  configSchema: FileSystemToolsConfigSchema,
+  metadata: {
+    displayName: "Filesystem Tools",
+    description: "File system operations (read, write, edit, glob, grep)",
+    category: "filesystem"
+  },
+  create: (config) => {
+    const fileSystemConfig = {
+      allowedPaths: config.allowedPaths,
+      blockedPaths: config.blockedPaths,
+      blockedExtensions: config.blockedExtensions,
+      maxFileSize: config.maxFileSize,
+      workingDirectory: config.workingDirectory ?? process.cwd(),
+      enableBackups: config.enableBackups,
+      backupPath: config.backupPath,
+      backupRetentionDays: config.backupRetentionDays
+    };
+    let fileSystemService;
+    const resolveWorkingDirectory = (context) => context.workspace?.path ?? fileSystemConfig.workingDirectory ?? process.cwd();
+    const applyWorkspace = (context, service) => {
+      const workingDirectory = resolveWorkingDirectory(context);
+      service.setWorkingDirectory(workingDirectory);
+    };
+    const getFileSystemService = async (context) => {
+      if (fileSystemService) {
+        const approvalManager2 = context.services?.approval;
+        if (!approvalManager2) {
+          throw ToolError.configInvalid(
+            "filesystem-tools requires ToolExecutionContext.services.approval"
+          );
+        }
+        fileSystemService.setDirectoryApprovalChecker(
+          (filePath) => approvalManager2.isDirectoryApproved(filePath)
+        );
+        applyWorkspace(context, fileSystemService);
+        return fileSystemService;
+      }
+      const logger = context.logger;
+      fileSystemService = new FileSystemService(fileSystemConfig, logger);
+      const approvalManager = context.services?.approval;
+      if (!approvalManager) {
+        throw ToolError.configInvalid(
+          "filesystem-tools requires ToolExecutionContext.services.approval"
+        );
+      }
+      fileSystemService.setDirectoryApprovalChecker(
+        (filePath) => approvalManager.isDirectoryApproved(filePath)
+      );
+      applyWorkspace(context, fileSystemService);
+      fileSystemService.initialize().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to initialize FileSystemService: ${message}`);
+      });
+      return fileSystemService;
+    };
+    const toolCreators = {
+      read_file: () => createReadFileTool(getFileSystemService),
+      write_file: () => createWriteFileTool(getFileSystemService),
+      edit_file: () => createEditFileTool(getFileSystemService),
+      glob_files: () => createGlobFilesTool(getFileSystemService),
+      grep_content: () => createGrepContentTool(getFileSystemService)
+    };
+    const toolsToCreate = config.enabledTools ?? FILESYSTEM_TOOL_NAMES;
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
+  }
+};
+export {
+  fileSystemToolsFactory
+};