@dexto/tools-filesystem 1.6.0 → 1.6.2

package/dist/index.d.cts

@@ -1,16 +1,852 @@
-export { fileSystemToolsFactory } from './tool-factory.cjs';
-export { FileSystemServiceGetter } from './file-tool-types.cjs';
-export { FileSystemService } from './filesystem-service.cjs';
-export { PathValidator } from './path-validator.cjs';
-export { FileSystemError } from './errors.cjs';
-export { FileSystemErrorCode } from './error-codes.cjs';
-export { BufferEncoding, EditFileOptions, EditOperation, EditResult, FileContent, FileMetadata, FileSystemConfig, GlobOptions, GlobResult, GrepOptions, PathValidation, ReadFileOptions, SearchMatch, SearchResult, WriteFileOptions, WriteResult } from './types.cjs';
-export { createReadFileTool } from './read-file-tool.cjs';
-export { createWriteFileTool } from './write-file-tool.cjs';
-export { createEditFileTool } from './edit-file-tool.cjs';
-export { createGlobFilesTool } from './glob-files-tool.cjs';
-export { createGrepContentTool } from './grep-content-tool.cjs';
-import '@dexto/agent-config';
-import './tool-factory-config.cjs';
-import 'zod';
-import '@dexto/core';
+import { ToolFactory } from '@dexto/agent-config';
+import { z } from 'zod';
+import { Logger, ToolExecutionContext, DextoRuntimeError, Tool } from '@dexto/core';
+
+/**
+ * FileSystem Tools Factory
+ *
+ * Provides file operation tools by wrapping FileSystemService.
+ * When registered, the factory initializes FileSystemService and creates tools
+ * for file operations (read, write, edit, glob, grep).
+ */
+
+/**
+ * Configuration schema for FileSystem tools factory.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all configuration:
+ * - Validation rules
+ * - Default values (using constants above)
+ * - Documentation
+ * - Type definitions
+ *
+ * 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<{
+    type: z.ZodLiteral<"filesystem-tools">;
+    allowedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    blockedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    blockedExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    maxFileSize: z.ZodDefault<z.ZodNumber>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    enableBackups: z.ZodDefault<z.ZodBoolean>;
+    backupPath: z.ZodOptional<z.ZodString>;
+    backupRetentionDays: z.ZodDefault<z.ZodNumber>;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["read_file", "write_file", "edit_file", "glob_files", "grep_content"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    allowedPaths: string[];
+    blockedExtensions: string[];
+    blockedPaths: string[];
+    maxFileSize: number;
+    enableBackups: boolean;
+    backupRetentionDays: number;
+    type: "filesystem-tools";
+    backupPath?: string | undefined;
+    workingDirectory?: string | undefined;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content")[] | undefined;
+}, {
+    type: "filesystem-tools";
+    allowedPaths?: string[] | undefined;
+    blockedExtensions?: string[] | undefined;
+    backupPath?: string | undefined;
+    blockedPaths?: string[] | undefined;
+    maxFileSize?: number | undefined;
+    enableBackups?: boolean | undefined;
+    backupRetentionDays?: number | undefined;
+    workingDirectory?: string | undefined;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content")[] | undefined;
+}>;
+type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
+
+declare const fileSystemToolsFactory: ToolFactory<FileSystemToolsConfig>;
+
+/**
+ * FileSystem Service Types
+ *
+ * Types and interfaces for file system operations including reading, writing,
+ * searching, and validation.
+ */
+type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+/**
+ * File content with metadata
+ */
+interface FileContent {
+    content: string;
+    lines: number;
+    encoding: string;
+    mimeType?: string;
+    truncated: boolean;
+    size: number;
+}
+/**
+ * Options for reading files
+ */
+interface ReadFileOptions {
+    /** Maximum number of lines to read */
+    limit?: number | undefined;
+    /** Starting line number (1-based) */
+    offset?: number | undefined;
+    /** File encoding (default: utf-8) */
+    encoding?: BufferEncoding | undefined;
+}
+/**
+ * File metadata for glob results
+ */
+interface FileMetadata {
+    path: string;
+    size: number;
+    modified: Date;
+    isDirectory: boolean;
+}
+/**
+ * Directory entry metadata
+ */
+interface DirectoryEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    size: number;
+    modified: Date;
+}
+/**
+ * Options for listing directory contents
+ */
+interface ListDirectoryOptions {
+    /** Include hidden files/directories (dotfiles) */
+    includeHidden?: boolean | undefined;
+    /** Include stat metadata */
+    includeMetadata?: boolean | undefined;
+    /** Maximum number of entries to return */
+    maxEntries?: number | undefined;
+}
+/**
+ * Directory listing result
+ */
+interface ListDirectoryResult {
+    path: string;
+    entries: DirectoryEntry[];
+    truncated: boolean;
+    totalEntries: number;
+}
+/**
+ * Options for creating directories
+ */
+interface CreateDirectoryOptions {
+    /** Create intermediate directories if they don't exist */
+    recursive?: boolean | undefined;
+}
+/**
+ * Create directory result
+ */
+interface CreateDirectoryResult {
+    path: string;
+    created: boolean;
+}
+/**
+ * Options for deleting paths
+ */
+interface DeletePathOptions {
+    /** Recursively delete directories */
+    recursive?: boolean | undefined;
+}
+/**
+ * Delete path result
+ */
+interface DeletePathResult {
+    path: string;
+    deleted: boolean;
+}
+/**
+ * Rename path result
+ */
+interface RenamePathResult {
+    from: string;
+    to: string;
+}
+/**
+ * Options for glob operations
+ */
+interface GlobOptions {
+    /** Base directory to search from */
+    cwd?: string | undefined;
+    /** Maximum number of results */
+    maxResults?: number | undefined;
+    /** Include file metadata */
+    includeMetadata?: boolean | undefined;
+}
+/**
+ * Glob result
+ */
+interface GlobResult {
+    files: FileMetadata[];
+    truncated: boolean;
+    totalFound: number;
+}
+/**
+ * Search match with context
+ */
+interface SearchMatch {
+    file: string;
+    lineNumber: number;
+    line: string;
+    context?: {
+        before: string[];
+        after: string[];
+    };
+}
+/**
+ * Options for content search (grep)
+ */
+interface GrepOptions {
+    /** Base directory to search */
+    path?: string | undefined;
+    /** Glob pattern to filter files */
+    glob?: string | undefined;
+    /** Number of context lines before/after match */
+    contextLines?: number | undefined;
+    /** Case-insensitive search */
+    caseInsensitive?: boolean | undefined;
+    /** Maximum number of results */
+    maxResults?: number | undefined;
+    /** Include line numbers */
+    lineNumbers?: boolean | undefined;
+}
+/**
+ * Search result
+ */
+interface SearchResult {
+    matches: SearchMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    filesSearched: number;
+}
+/**
+ * Options for writing files
+ */
+interface WriteFileOptions {
+    /** Create parent directories if they don't exist */
+    createDirs?: boolean | undefined;
+    /** File encoding (default: utf-8) */
+    encoding?: BufferEncoding | undefined;
+    /** Create backup before overwriting */
+    backup?: boolean | undefined;
+}
+/**
+ * Write result
+ */
+interface WriteResult {
+    success: boolean;
+    path: string;
+    bytesWritten: number;
+    backupPath?: string | undefined;
+    /** Original content if file was overwritten (undefined for new files) */
+    originalContent?: string | undefined;
+}
+/**
+ * Edit operation
+ */
+interface EditOperation {
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean | undefined;
+}
+/**
+ * Options for editing files
+ */
+interface EditFileOptions {
+    /** Create backup before editing */
+    backup?: boolean;
+    /** File encoding */
+    encoding?: BufferEncoding;
+}
+/**
+ * Edit result
+ */
+interface EditResult {
+    success: boolean;
+    path: string;
+    changesCount: number;
+    backupPath?: string | undefined;
+    /** Original content before edit (for diff generation) */
+    originalContent: string;
+    /** New content after edit (for diff generation) */
+    newContent: string;
+}
+/**
+ * Path validation result
+ */
+interface PathValidation {
+    isValid: boolean;
+    error?: string;
+    normalizedPath?: string;
+}
+/**
+ * File system configuration
+ */
+interface FileSystemConfig {
+    /** Allowed base paths */
+    allowedPaths: string[];
+    /** Blocked paths (relative to allowed paths) */
+    blockedPaths: string[];
+    /** Blocked file extensions */
+    blockedExtensions: string[];
+    /** Maximum file size in bytes */
+    maxFileSize: number;
+    /** Enable automatic backups */
+    enableBackups: boolean;
+    /** Backup directory absolute path (required when enableBackups is true - provided by CLI enrichment) */
+    backupPath?: string | undefined;
+    /** Backup retention period in days (default: 7) */
+    backupRetentionDays: number;
+    /** Working directory for glob/grep operations (defaults to process.cwd()) */
+    workingDirectory?: string | undefined;
+}
+
+/**
+ * FileSystem Service
+ *
+ * Secure file system operations for Dexto internal tools
+ */
+
+/**
+ * FileSystemService - Handles all file system operations with security checks
+ *
+ * This service receives fully-validated configuration from the FileSystem Tools Factory.
+ * All defaults have been applied by the factory's schema, so the service trusts the config
+ * and uses it as-is without any fallback logic.
+ *
+ * TODO: instantiate only when internal file tools are enabled to avoid file dependencies which won't work in serverless
+ */
+declare class FileSystemService {
+    private config;
+    private pathValidator;
+    private initialized;
+    private initPromise;
+    private logger;
+    private directoryApprovalChecker?;
+    /**
+     * Create a new FileSystemService with validated configuration.
+     *
+     * @param config - Fully-validated configuration from the factory schema.
+     *                 All required fields have values, defaults already applied.
+     * @param logger - Logger instance for this service
+     */
+    constructor(config: FileSystemConfig, logger: Logger);
+    /**
+     * Get backup directory path (context-aware with optional override)
+     * TODO: Migrate to explicit configuration via CLI enrichment layer (per-agent paths)
+     */
+    private getBackupDir;
+    /**
+     * Get the effective working directory for file operations.
+     * Falls back to process.cwd() if not configured.
+     */
+    getWorkingDirectory(): string;
+    /**
+     * Initialize the service.
+     * Safe to call multiple times - subsequent calls return the same promise.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Internal initialization logic.
+     */
+    private doInitialize;
+    /**
+     * Ensure the service is initialized before use.
+     * Tools should call this at the start of their execute methods.
+     * Safe to call multiple times - will await the same initialization promise.
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Set a callback to check if a path is in an approved directory.
+     * This allows PathValidator to consult ApprovalManager without a direct dependency.
+     *
+     * @param checker Function that returns true if path is in an approved directory
+     */
+    setDirectoryApprovalChecker(checker: (filePath: string) => boolean): void;
+    /**
+     * Update the working directory at runtime (e.g., when workspace changes).
+     * Rebuilds the PathValidator so allowed/blocked path roots are recalculated.
+     */
+    setWorkingDirectory(workingDirectory: string): void;
+    /**
+     * Check if a file path is within the configured allowed paths (config only).
+     * This is used by file tools to determine if directory approval is needed.
+     *
+     * @param filePath The file path to check (can be relative or absolute)
+     * @returns true if the path is within config-allowed paths, false otherwise
+     */
+    isPathWithinConfigAllowed(filePath: string): Promise<boolean>;
+    private validateReadPath;
+    private readNormalizedFile;
+    /**
+     * Read a file with validation and size limits
+     */
+    readFile(filePath: string, options?: ReadFileOptions): Promise<FileContent>;
+    /**
+     * Preview-only file read that bypasses config-allowed roots.
+     *
+     * This is intended for UI previews (diffs, create previews) shown BEFORE a user
+     * confirms directory access for the tool call. The returned content is UI-only
+     * and should not be forwarded to the LLM.
+     */
+    readFileForToolPreview(filePath: string, options?: ReadFileOptions): Promise<FileContent>;
+    /**
+     * Find files matching a glob pattern
+     */
+    globFiles(pattern: string, options?: GlobOptions): Promise<GlobResult>;
+    /**
+     * List contents of a directory (non-recursive)
+     */
+    listDirectory(dirPath: string, options?: ListDirectoryOptions): Promise<ListDirectoryResult>;
+    private mapWithConcurrency;
+    /**
+     * Create a directory
+     */
+    createDirectory(dirPath: string, options?: CreateDirectoryOptions): Promise<CreateDirectoryResult>;
+    /**
+     * Delete a file or directory
+     */
+    deletePath(targetPath: string, options?: DeletePathOptions): Promise<DeletePathResult>;
+    /**
+     * Rename or move a file or directory
+     */
+    renamePath(fromPath: string, toPath: string): Promise<RenamePathResult>;
+    /**
+     * Search for content in files (grep-like functionality)
+     */
+    searchContent(pattern: string, options?: GrepOptions): Promise<SearchResult>;
+    /**
+     * Write content to a file
+     */
+    writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<WriteResult>;
+    /**
+     * Edit a file by replacing text
+     */
+    editFile(filePath: string, operation: EditOperation, options?: EditFileOptions): Promise<EditResult>;
+    /**
+     * Create a backup of a file
+     */
+    private createBackup;
+    /**
+     * Clean up old backup files based on retention policy
+     */
+    cleanupOldBackups(): Promise<number>;
+    /**
+     * Get service configuration
+     */
+    getConfig(): Readonly<FileSystemConfig>;
+    /**
+     * Check if a path is allowed (async for non-blocking symlink resolution)
+     */
+    isPathAllowed(filePath: string): Promise<boolean>;
+}
+
+/**
+ * File Tool Types
+ *
+ * Types shared between file tools and factories.
+ */
+
+/**
+ * Getter for a lazily-initialized {@link FileSystemService}.
+ * Tool factories construct tools before runtime services are available, so tools
+ * resolve the service on-demand using {@link ToolExecutionContext}.
+ */
+type FileSystemServiceGetter = (context: ToolExecutionContext) => Promise<FileSystemService>;
+
+/**
+ * Path Validator
+ *
+ * Security-focused path validation for file system operations
+ */
+
+/**
+ * Callback type for checking if a path is in an approved directory.
+ * Used to consult ApprovalManager without creating a direct dependency.
+ */
+type DirectoryApprovalChecker = (filePath: string) => boolean;
+/**
+ * PathValidator - Validates file paths for security and policy compliance
+ *
+ * Security checks:
+ * 1. Path traversal detection (../, symbolic links)
+ * 2. Allowed paths enforcement (whitelist + approved directories)
+ * 3. Blocked paths detection (blacklist)
+ * 4. File extension restrictions
+ * 5. Absolute path normalization
+ *
+ * PathValidator can optionally consult an external approval checker (e.g., ApprovalManager)
+ * to determine if paths outside the config's allowed paths are accessible.
+ */
+declare class PathValidator {
+    private config;
+    private normalizedAllowedPaths;
+    private normalizedBlockedPaths;
+    private normalizedBlockedExtensions;
+    private logger;
+    private directoryApprovalChecker;
+    constructor(config: FileSystemConfig, logger: Logger);
+    /**
+     * Set a callback to check if a path is in an approved directory.
+     * This allows PathValidator to consult ApprovalManager without a direct dependency.
+     *
+     * @param checker Function that returns true if path is in an approved directory
+     */
+    setDirectoryApprovalChecker(checker: DirectoryApprovalChecker): void;
+    /**
+     * Validate a file path for security and policy compliance
+     */
+    validatePath(filePath: string): Promise<PathValidation>;
+    /**
+     * Validate a file path for preview purposes.
+     *
+     * This is identical to {@link validatePath} except it does NOT enforce config-allowed roots.
+     * It still enforces:
+     * - traversal protection
+     * - blocked paths (absolute blocked paths only; relative blocked paths are resolved against
+     *   config-allowed roots and may not match paths outside those roots)
+     * - blocked extensions
+     *
+     * Used for generating UI-only previews (e.g., diffs) before the user approves directory access.
+     */
+    validatePathForPreview(filePath: string): Promise<PathValidation>;
+    private validatePathInternal;
+    /**
+     * Check if path contains traversal attempts
+     */
+    private hasPathTraversal;
+    /**
+     * Check if path is within allowed paths (whitelist check)
+     * Also consults the directory approval checker if configured.
+     * Uses the sync version since the path is already normalized at this point.
+     */
+    private isPathAllowed;
+    /**
+     * Check if path matches blocked patterns (blacklist check)
+     */
+    private isPathBlocked;
+    /**
+     * Quick check if a path is allowed (for internal use)
+     * Note: This assumes the path is already normalized/canonicalized
+     */
+    isPathAllowedQuick(normalizedPath: string): boolean;
+    /**
+     * Synchronous path allowed check (for already-normalized paths)
+     * This is used internally when we already have a canonicalized path
+     */
+    private isPathAllowedSync;
+    /**
+     * Check if a file path is within the configured allowed paths (from config only).
+     * This method does NOT consult ApprovalManager - it only checks the static config paths.
+     *
+     * This is used by file tools to determine if a path needs directory approval.
+     * Paths within config-allowed directories don't need directory approval prompts.
+     *
+     * @param filePath The file path to check (can be relative or absolute)
+     * @returns true if the path is within config-allowed paths, false otherwise
+     */
+    isPathWithinAllowed(filePath: string): Promise<boolean>;
+    /**
+     * Check if path is within config-allowed paths only (no approval checker).
+     * Used for prompting decisions.
+     */
+    private isInConfigAllowedPaths;
+    /**
+     * Get normalized allowed paths
+     */
+    getAllowedPaths(): string[];
+    /**
+     * Get blocked paths
+     */
+    getBlockedPaths(): string[];
+}
+
+/**
+ * FileSystem Service Errors
+ *
+ * Error classes for file system operations
+ */
+
+/**
+ * Factory class for creating FileSystem-related errors
+ */
+declare class FileSystemError {
+    private constructor();
+    /**
+     * File not found error
+     */
+    static fileNotFound(path: string): DextoRuntimeError;
+    /**
+     * Directory not found error
+     */
+    static directoryNotFound(path: string): DextoRuntimeError;
+    /**
+     * Permission denied error
+     */
+    static permissionDenied(path: string, operation: string): DextoRuntimeError;
+    /**
+     * Path not allowed error
+     */
+    static pathNotAllowed(path: string, allowedPaths: string[]): DextoRuntimeError;
+    /**
+     * Path blocked error
+     */
+    static pathBlocked(path: string, reason: string): DextoRuntimeError;
+    /**
+     * Invalid path error
+     */
+    static invalidPath(path: string, reason: string): DextoRuntimeError;
+    /**
+     * Path traversal detected
+     */
+    static pathTraversal(path: string): DextoRuntimeError;
+    /**
+     * Invalid file extension error
+     */
+    static invalidExtension(path: string, blockedExtensions: string[]): DextoRuntimeError;
+    /**
+     * File too large error
+     */
+    static fileTooLarge(path: string, size: number, maxSize: number): DextoRuntimeError;
+    /**
+     * Too many results error
+     */
+    static tooManyResults(operation: string, count: number, maxResults: number): DextoRuntimeError;
+    /**
+     * Read operation failed
+     */
+    static readFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * List directory operation failed
+     */
+    static listFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Create directory operation failed
+     */
+    static createDirFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Delete operation failed
+     */
+    static deleteFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Rename operation failed
+     */
+    static renameFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Write operation failed
+     */
+    static writeFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Backup creation failed
+     */
+    static backupFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * Edit operation failed
+     */
+    static editFailed(path: string, cause: string): DextoRuntimeError;
+    /**
+     * String not unique error
+     */
+    static stringNotUnique(path: string, searchString: string, occurrences: number): DextoRuntimeError;
+    /**
+     * String not found error
+     */
+    static stringNotFound(path: string, searchString: string): DextoRuntimeError;
+    /**
+     * Glob operation failed
+     */
+    static globFailed(pattern: string, cause: string): DextoRuntimeError;
+    /**
+     * Search operation failed
+     */
+    static searchFailed(pattern: string, cause: string): DextoRuntimeError;
+    /**
+     * Invalid pattern error
+     */
+    static invalidPattern(pattern: string, cause: string): DextoRuntimeError;
+    /**
+     * Regex timeout error
+     */
+    static regexTimeout(pattern: string): DextoRuntimeError;
+    /**
+     * Invalid configuration error
+     */
+    static invalidConfig(reason: string): DextoRuntimeError;
+    /**
+     * Service not initialized error
+     */
+    static notInitialized(): DextoRuntimeError;
+}
+
+/**
+ * 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",
+    LIST_FAILED = "FILESYSTEM_LIST_FAILED",
+    WRITE_FAILED = "FILESYSTEM_WRITE_FAILED",
+    CREATE_DIR_FAILED = "FILESYSTEM_CREATE_DIR_FAILED",
+    DELETE_FAILED = "FILESYSTEM_DELETE_FAILED",
+    RENAME_FAILED = "FILESYSTEM_RENAME_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"
+}
+
+/**
+ * Read File Tool
+ *
+ * Internal tool for reading file contents with size limits and pagination
+ */
+
+declare const ReadFileInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    file_path: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    file_path: string;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+/**
+ * Create the read_file internal tool with directory approval support
+ */
+declare function createReadFileTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof ReadFileInputSchema>;
+
+/**
+ * Write File Tool
+ *
+ * Internal tool for writing content to files (requires approval)
+ */
+
+declare const WriteFileInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+    content: z.ZodString;
+    create_dirs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    encoding: z.ZodDefault<z.ZodOptional<z.ZodEnum<["utf-8", "ascii", "latin1", "utf16le"]>>>;
+}, "strict", z.ZodTypeAny, {
+    content: string;
+    encoding: "ascii" | "utf-8" | "utf16le" | "latin1";
+    file_path: string;
+    create_dirs: boolean;
+}, {
+    content: string;
+    file_path: string;
+    encoding?: "ascii" | "utf-8" | "utf16le" | "latin1" | undefined;
+    create_dirs?: boolean | undefined;
+}>;
+/**
+ * Create the write_file internal tool with directory approval support
+ */
+declare function createWriteFileTool(getFileSystemService: FileSystemServiceGetter): Tool<typeof WriteFileInputSchema>;
+
+/**
+ * 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>;
+
+/**
+ * Glob Files Tool
+ *
+ * Internal tool for finding files using glob patterns
+ */
+
+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(getFileSystemService: FileSystemServiceGetter): Tool<typeof GlobFilesInputSchema>;
+
+/**
+ * Grep Content Tool
+ *
+ * Internal tool for searching file contents using regex patterns
+ */
+
+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(getFileSystemService: FileSystemServiceGetter): Tool<typeof GrepContentInputSchema>;
+
+export { type BufferEncoding, type CreateDirectoryOptions, type CreateDirectoryResult, type DeletePathOptions, type DeletePathResult, type DirectoryEntry, type EditFileOptions, type EditOperation, type EditResult, type FileContent, type FileMetadata, type FileSystemConfig, FileSystemError, FileSystemErrorCode, FileSystemService, type FileSystemServiceGetter, type FileSystemToolsConfig, FileSystemToolsConfigSchema, type GlobOptions, type GlobResult, type GrepOptions, type ListDirectoryOptions, type ListDirectoryResult, type PathValidation, PathValidator, type ReadFileOptions, type RenamePathResult, type SearchMatch, type SearchResult, type WriteFileOptions, type WriteResult, createEditFileTool, createGlobFilesTool, createGrepContentTool, createReadFileTool, createWriteFileTool, fileSystemToolsFactory };