@dexto/tools-filesystem 1.5.8 → 1.6.1

package/dist/glob-files-tool.cjs

@@ -34,61 +34,47 @@ module.exports = __toCommonJS(glob_files_tool_exports);
 var path = __toESM(require("node:path"), 1);
 var import_zod = require("zod");
 var import_core = require("@dexto/core");
+var import_directory_approval = require("./directory-approval.js");
 const GlobFilesInputSchema = import_zod.z.object({
   pattern: import_zod.z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
   path: import_zod.z.string().optional().describe("Base directory to search from (defaults to working directory)"),
   max_results: import_zod.z.number().int().positive().optional().default(1e3).describe("Maximum number of results to return (default: 1000)")
 }).strict();
-function createGlobFilesTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalSearchDir;
-  return {
+function createGlobFilesTool(getFileSystemService) {
+  return (0, import_core.defineTool)({
     id: "glob_files",
+    aliases: ["glob"],
     description: "Find files matching a glob pattern. Supports standard glob syntax like **/*.js for recursive matches, *.ts for files in current directory, and src/**/*.tsx for nested paths. Returns array of file paths with metadata (size, modified date). Results are limited to allowed paths only.",
     inputSchema: GlobFilesInputSchema,
-    /**
-     * Check if this glob operation needs directory access approval.
-     * Returns custom approval request if the search directory is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { path: searchPath } = args;
-      const baseDir = fileSystemService.getWorkingDirectory();
-      const searchDir = path.resolve(baseDir, searchPath || ".");
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(searchDir);
-      if (isAllowed) {
-        return null;
+    presentation: {
+      describeHeader: (input) => {
+        const bits = [`pattern=${input.pattern}`];
+        if (input.path) bits.push(`path=${input.path}`);
+        if (typeof input.max_results === "number") bits.push(`max=${input.max_results}`);
+        return (0, import_core.createLocalToolCallHeader)({
+          title: "Find Files",
+          argsText: (0, import_core.truncateForHeader)(bits.join(", "), 140)
+        });
       }
-      if (directoryApproval?.isSessionApproved(searchDir)) {
-        return null;
-      }
-      pendingApprovalSearchDir = searchDir;
-      return {
-        type: import_core.ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: searchDir,
-          parentDir: searchDir,
-          operation: "search",
-          toolName: "glob_files"
-        }
-      };
     },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalSearchDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalSearchDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalSearchDir = void 0;
-    },
-    execute: async (input, _context) => {
-      const { pattern, path: path2, max_results } = input;
-      const result = await fileSystemService.globFiles(pattern, {
-        cwd: path2,
+    ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
+      toolName: "glob_files",
+      operation: "read",
+      inputSchema: GlobFilesInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => {
+        const baseDir = fileSystemService.getWorkingDirectory();
+        const searchDir = path.resolve(baseDir, input.path || ".");
+        return { path: searchDir, parentDir: searchDir };
+      }
+    }),
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const { pattern, path: searchPath, max_results } = input;
+      const baseDir = resolvedFileSystemService.getWorkingDirectory();
+      const resolvedSearchPath = path.resolve(baseDir, searchPath || ".");
+      const result = await resolvedFileSystemService.globFiles(pattern, {
+        cwd: resolvedSearchPath,
         maxResults: max_results,
         includeMetadata: true
       });
@@ -115,7 +101,7 @@ function createGlobFilesTool(options) {
         _display
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/glob-files-tool.d.ts

@@ -1,17 +1,27 @@
-import { InternalTool } from '@dexto/core';
-import { FileToolOptions } from './file-tool-types.js';
-import './filesystem-service.js';
-import './types.js';
-
 /**
  * Glob Files Tool
  *
  * Internal tool for finding files using glob patterns
  */
-
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { FileSystemServiceGetter } from './file-tool-types.js';
+declare const GlobFilesInputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    max_results: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    pattern: string;
+    max_results: number;
+    path?: string | undefined;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    max_results?: number | undefined;
+}>;
 /**
  * Create the glob_files internal tool with directory approval support
  */
-declare function createGlobFilesTool(options: FileToolOptions): InternalTool;
-
-export { createGlobFilesTool };
+export declare function createGlobFilesTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof GlobFilesInputSchema>;
+export {};
+//# sourceMappingURL=glob-files-tool.d.ts.map

package/dist/glob-files-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-files-tool.d.ts","sourceRoot":"","sources":["../src/glob-files-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAGpE,QAAA,MAAM,oBAAoB;;;;;;;;;;;;EAiBb,CAAC;AAEd;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,oBAAoB,CAAC,CA2EnC"}

package/dist/glob-files-tool.js

@@ -1,61 +1,47 @@
 import * as path from "node:path";
 import { z } from "zod";
-import { ApprovalType } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
+import { createDirectoryAccessApprovalHandlers } from "./directory-approval.js";
 const GlobFilesInputSchema = z.object({
   pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
   path: z.string().optional().describe("Base directory to search from (defaults to working directory)"),
   max_results: z.number().int().positive().optional().default(1e3).describe("Maximum number of results to return (default: 1000)")
 }).strict();
-function createGlobFilesTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalSearchDir;
-  return {
+function createGlobFilesTool(getFileSystemService) {
+  return defineTool({
     id: "glob_files",
+    aliases: ["glob"],
     description: "Find files matching a glob pattern. Supports standard glob syntax like **/*.js for recursive matches, *.ts for files in current directory, and src/**/*.tsx for nested paths. Returns array of file paths with metadata (size, modified date). Results are limited to allowed paths only.",
     inputSchema: GlobFilesInputSchema,
-    /**
-     * Check if this glob operation needs directory access approval.
-     * Returns custom approval request if the search directory is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { path: searchPath } = args;
-      const baseDir = fileSystemService.getWorkingDirectory();
-      const searchDir = path.resolve(baseDir, searchPath || ".");
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(searchDir);
-      if (isAllowed) {
-        return null;
+    presentation: {
+      describeHeader: (input) => {
+        const bits = [`pattern=${input.pattern}`];
+        if (input.path) bits.push(`path=${input.path}`);
+        if (typeof input.max_results === "number") bits.push(`max=${input.max_results}`);
+        return createLocalToolCallHeader({
+          title: "Find Files",
+          argsText: truncateForHeader(bits.join(", "), 140)
+        });
       }
-      if (directoryApproval?.isSessionApproved(searchDir)) {
-        return null;
-      }
-      pendingApprovalSearchDir = searchDir;
-      return {
-        type: ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: searchDir,
-          parentDir: searchDir,
-          operation: "search",
-          toolName: "glob_files"
-        }
-      };
     },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalSearchDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalSearchDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalSearchDir = void 0;
-    },
-    execute: async (input, _context) => {
-      const { pattern, path: path2, max_results } = input;
-      const result = await fileSystemService.globFiles(pattern, {
-        cwd: path2,
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "glob_files",
+      operation: "read",
+      inputSchema: GlobFilesInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => {
+        const baseDir = fileSystemService.getWorkingDirectory();
+        const searchDir = path.resolve(baseDir, input.path || ".");
+        return { path: searchDir, parentDir: searchDir };
+      }
+    }),
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const { pattern, path: searchPath, max_results } = input;
+      const baseDir = resolvedFileSystemService.getWorkingDirectory();
+      const resolvedSearchPath = path.resolve(baseDir, searchPath || ".");
+      const result = await resolvedFileSystemService.globFiles(pattern, {
+        cwd: resolvedSearchPath,
         maxResults: max_results,
         includeMetadata: true
       });
@@ -82,7 +68,7 @@ function createGlobFilesTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createGlobFilesTool

package/dist/grep-content-tool.cjs

@@ -34,6 +34,7 @@ module.exports = __toCommonJS(grep_content_tool_exports);
 var path = __toESM(require("node:path"), 1);
 var import_zod = require("zod");
 var import_core = require("@dexto/core");
+var import_directory_approval = require("./directory-approval.js");
 const GrepContentInputSchema = import_zod.z.object({
   pattern: import_zod.z.string().describe("Regular expression pattern to search for"),
   path: import_zod.z.string().optional().describe("Directory to search in (defaults to working directory)"),
@@ -44,55 +45,49 @@ const GrepContentInputSchema = import_zod.z.object({
   case_insensitive: import_zod.z.boolean().optional().default(false).describe("Perform case-insensitive search (default: false)"),
   max_results: import_zod.z.number().int().positive().optional().default(100).describe("Maximum number of results to return (default: 100)")
 }).strict();
-function createGrepContentTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalSearchDir;
-  return {
+function createGrepContentTool(getFileSystemService) {
+  return (0, import_core.defineTool)({
     id: "grep_content",
+    aliases: ["grep"],
     description: 'Search for text patterns in files using regular expressions. Returns matching lines with file path, line number, and optional context lines. Use glob parameter to filter specific file types (e.g., "*.ts"). Supports case-insensitive search. Great for finding code patterns, function definitions, or specific text across multiple files.',
     inputSchema: GrepContentInputSchema,
-    /**
-     * Check if this grep operation needs directory access approval.
-     * Returns custom approval request if the search directory is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { path: searchPath } = args;
-      const searchDir = path.resolve(searchPath || process.cwd());
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(searchDir);
-      if (isAllowed) {
-        return null;
+    presentation: {
+      describeHeader: (input) => {
+        const bits = [`pattern=${input.pattern}`];
+        if (input.glob) bits.push(`glob=${input.glob}`);
+        if (input.path) bits.push(`path=${input.path}`);
+        if (typeof input.max_results === "number") bits.push(`max=${input.max_results}`);
+        return (0, import_core.createLocalToolCallHeader)({
+          title: "Search Files",
+          argsText: (0, import_core.truncateForHeader)(bits.join(", "), 140)
+        });
       }
-      if (directoryApproval?.isSessionApproved(searchDir)) {
-        return null;
-      }
-      pendingApprovalSearchDir = searchDir;
-      return {
-        type: import_core.ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: searchDir,
-          parentDir: searchDir,
-          operation: "search",
-          toolName: "grep_content"
-        }
-      };
-    },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalSearchDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalSearchDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalSearchDir = void 0;
     },
-    execute: async (input, _context) => {
-      const { pattern, path: path2, glob, context_lines, case_insensitive, max_results } = input;
-      const result = await fileSystemService.searchContent(pattern, {
-        path: path2,
+    ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
+      toolName: "grep_content",
+      operation: "read",
+      inputSchema: GrepContentInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => {
+        const baseDir = fileSystemService.getWorkingDirectory();
+        const searchDir = path.resolve(baseDir, input.path || ".");
+        return { path: searchDir, parentDir: searchDir };
+      }
+    }),
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const {
+        pattern,
+        path: searchPath,
+        glob,
+        context_lines,
+        case_insensitive,
+        max_results
+      } = input;
+      const baseDir = resolvedFileSystemService.getWorkingDirectory();
+      const resolvedSearchPath = path.resolve(baseDir, searchPath || ".");
+      const result = await resolvedFileSystemService.searchContent(pattern, {
+        path: resolvedSearchPath,
         glob,
         contextLines: context_lines,
         caseInsensitive: case_insensitive,
@@ -130,7 +125,7 @@ function createGrepContentTool(options) {
         _display
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/grep-content-tool.d.ts

@@ -1,17 +1,36 @@
-import { InternalTool } from '@dexto/core';
-import { FileToolOptions } from './file-tool-types.js';
-import './filesystem-service.js';
-import './types.js';
-
 /**
  * Grep Content Tool
  *
  * Internal tool for searching file contents using regex patterns
  */
-
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { FileSystemServiceGetter } from './file-tool-types.js';
+declare const GrepContentInputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    context_lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    case_insensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    max_results: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    pattern: string;
+    max_results: number;
+    context_lines: number;
+    case_insensitive: boolean;
+    path?: string | undefined;
+    glob?: string | undefined;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    max_results?: number | undefined;
+    glob?: string | undefined;
+    context_lines?: number | undefined;
+    case_insensitive?: boolean | undefined;
+}>;
 /**
  * Create the grep_content internal tool with directory approval support
  */
-declare function createGrepContentTool(options: FileToolOptions): InternalTool;
-
-export { createGrepContentTool };
+export declare function createGrepContentTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof GrepContentInputSchema>;
+export {};
+//# sourceMappingURL=grep-content-tool.d.ts.map

package/dist/grep-content-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep-content-tool.d.ts","sourceRoot":"","sources":["../src/grep-content-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAGpE,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EAiCf,CAAC;AAEd;;GAEG;AACH,wBAAgB,qBAAqB,CACjC,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,sBAAsB,CAAC,CA6FrC"}

package/dist/grep-content-tool.js

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { z } from "zod";
-import { ApprovalType } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
+import { createDirectoryAccessApprovalHandlers } from "./directory-approval.js";
 const GrepContentInputSchema = z.object({
   pattern: z.string().describe("Regular expression pattern to search for"),
   path: z.string().optional().describe("Directory to search in (defaults to working directory)"),
@@ -11,55 +12,49 @@ const GrepContentInputSchema = z.object({
   case_insensitive: z.boolean().optional().default(false).describe("Perform case-insensitive search (default: false)"),
   max_results: z.number().int().positive().optional().default(100).describe("Maximum number of results to return (default: 100)")
 }).strict();
-function createGrepContentTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalSearchDir;
-  return {
+function createGrepContentTool(getFileSystemService) {
+  return defineTool({
     id: "grep_content",
+    aliases: ["grep"],
     description: 'Search for text patterns in files using regular expressions. Returns matching lines with file path, line number, and optional context lines. Use glob parameter to filter specific file types (e.g., "*.ts"). Supports case-insensitive search. Great for finding code patterns, function definitions, or specific text across multiple files.',
     inputSchema: GrepContentInputSchema,
-    /**
-     * Check if this grep operation needs directory access approval.
-     * Returns custom approval request if the search directory is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { path: searchPath } = args;
-      const searchDir = path.resolve(searchPath || process.cwd());
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(searchDir);
-      if (isAllowed) {
-        return null;
+    presentation: {
+      describeHeader: (input) => {
+        const bits = [`pattern=${input.pattern}`];
+        if (input.glob) bits.push(`glob=${input.glob}`);
+        if (input.path) bits.push(`path=${input.path}`);
+        if (typeof input.max_results === "number") bits.push(`max=${input.max_results}`);
+        return createLocalToolCallHeader({
+          title: "Search Files",
+          argsText: truncateForHeader(bits.join(", "), 140)
+        });
       }
-      if (directoryApproval?.isSessionApproved(searchDir)) {
-        return null;
-      }
-      pendingApprovalSearchDir = searchDir;
-      return {
-        type: ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: searchDir,
-          parentDir: searchDir,
-          operation: "search",
-          toolName: "grep_content"
-        }
-      };
-    },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalSearchDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalSearchDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalSearchDir = void 0;
     },
-    execute: async (input, _context) => {
-      const { pattern, path: path2, glob, context_lines, case_insensitive, max_results } = input;
-      const result = await fileSystemService.searchContent(pattern, {
-        path: path2,
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "grep_content",
+      operation: "read",
+      inputSchema: GrepContentInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => {
+        const baseDir = fileSystemService.getWorkingDirectory();
+        const searchDir = path.resolve(baseDir, input.path || ".");
+        return { path: searchDir, parentDir: searchDir };
+      }
+    }),
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
+      const {
+        pattern,
+        path: searchPath,
+        glob,
+        context_lines,
+        case_insensitive,
+        max_results
+      } = input;
+      const baseDir = resolvedFileSystemService.getWorkingDirectory();
+      const resolvedSearchPath = path.resolve(baseDir, searchPath || ".");
+      const result = await resolvedFileSystemService.searchContent(pattern, {
+        path: resolvedSearchPath,
         glob,
         contextLines: context_lines,
         caseInsensitive: case_insensitive,
@@ -97,7 +92,7 @@ function createGrepContentTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createGrepContentTool

package/dist/index.cjs

@@ -21,16 +21,18 @@ __export(index_exports, {
   FileSystemError: () => import_errors.FileSystemError,
   FileSystemErrorCode: () => import_error_codes.FileSystemErrorCode,
   FileSystemService: () => import_filesystem_service.FileSystemService,
+  FileSystemToolsConfigSchema: () => import_tool_factory_config.FileSystemToolsConfigSchema,
   PathValidator: () => import_path_validator.PathValidator,
   createEditFileTool: () => import_edit_file_tool.createEditFileTool,
   createGlobFilesTool: () => import_glob_files_tool.createGlobFilesTool,
   createGrepContentTool: () => import_grep_content_tool.createGrepContentTool,
   createReadFileTool: () => import_read_file_tool.createReadFileTool,
   createWriteFileTool: () => import_write_file_tool.createWriteFileTool,
-  fileSystemToolsProvider: () => import_tool_provider.fileSystemToolsProvider
+  fileSystemToolsFactory: () => import_tool_factory.fileSystemToolsFactory
 });
 module.exports = __toCommonJS(index_exports);
-var import_tool_provider = require("./tool-provider.js");
+var import_tool_factory = require("./tool-factory.js");
+var import_tool_factory_config = require("./tool-factory-config.js");
 var import_filesystem_service = require("./filesystem-service.js");
 var import_path_validator = require("./path-validator.js");
 var import_errors = require("./errors.js");
@@ -45,11 +47,12 @@ var import_grep_content_tool = require("./grep-content-tool.js");
   FileSystemError,
   FileSystemErrorCode,
   FileSystemService,
+  FileSystemToolsConfigSchema,
   PathValidator,
   createEditFileTool,
   createGlobFilesTool,
   createGrepContentTool,
   createReadFileTool,
   createWriteFileTool,
-  fileSystemToolsProvider
+  fileSystemToolsFactory
 });