@fastino-ai/pioneer-cli 0.2.9 → 0.2.11

package/src/tools/filesystem.ts

@@ -1,444 +0,0 @@
-/**
- * Filesystem tools - Read/write files, list directories, search
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import type { Tool, ToolResult, ToolParameter } from "./types.js";
-
-export interface FilesystemOptions {
-  basePath?: string;
-  allowedPaths?: string[];
-  maxFileSize?: number; // bytes
-}
-
-function isPathAllowed(filePath: string, options: FilesystemOptions): boolean {
-  if (!options.allowedPaths || options.allowedPaths.length === 0) {
-    return true;
-  }
-
-  const resolved = path.resolve(filePath);
-  return options.allowedPaths.some((allowed) => resolved.startsWith(path.resolve(allowed)));
-}
-
-export function createReadFileTool(options: FilesystemOptions = {}): Tool {
-  const { maxFileSize = 1024 * 1024 } = options; // 1MB default
-
-  return {
-    name: "read_file",
-    description: "Read the contents of a file. Returns the file content as text.",
-    parameters: [
-      {
-        name: "path",
-        type: "string",
-        description: "Path to the file to read",
-        required: true,
-      },
-      {
-        name: "start_line",
-        type: "number",
-        description: "Starting line number (1-based, optional)",
-        required: false,
-      },
-      {
-        name: "end_line",
-        type: "number",
-        description: "Ending line number (1-based, inclusive, optional)",
-        required: false,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const filePath = args.path as string;
-      const startLine = args.start_line as number | undefined;
-      const endLine = args.end_line as number | undefined;
-
-      if (!filePath) {
-        return { toolCallId: "", output: "", success: false, error: "Path is required" };
-      }
-
-      if (!isPathAllowed(filePath, options)) {
-        return { toolCallId: "", output: "", success: false, error: "Path not allowed" };
-      }
-
-      try {
-        const stats = fs.statSync(filePath);
-        if (stats.size > maxFileSize) {
-          return {
-            toolCallId: "",
-            output: "",
-            success: false,
-            error: `File too large (${stats.size} bytes). Max: ${maxFileSize} bytes`,
-          };
-        }
-
-        let content = fs.readFileSync(filePath, "utf-8");
-
-        if (startLine !== undefined || endLine !== undefined) {
-          const lines = content.split("\n");
-          const start = Math.max(1, startLine || 1) - 1;
-          const end = endLine ? Math.min(lines.length, endLine) : lines.length;
-          content = lines.slice(start, end).join("\n");
-        }
-
-        return { toolCallId: "", output: content, success: true };
-      } catch (err) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        };
-      }
-    },
-  };
-}
-
-export function createWriteFileTool(options: FilesystemOptions = {}): Tool {
-  return {
-    name: "write_file",
-    description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does.",
-    parameters: [
-      {
-        name: "path",
-        type: "string",
-        description: "Path to the file to write",
-        required: true,
-      },
-      {
-        name: "content",
-        type: "string",
-        description: "Content to write to the file",
-        required: true,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const filePath = args.path as string;
-      const content = args.content as string;
-
-      if (!filePath) {
-        return { toolCallId: "", output: "", success: false, error: "Path is required" };
-      }
-
-      if (content === undefined) {
-        return { toolCallId: "", output: "", success: false, error: "Content is required" };
-      }
-
-      if (!isPathAllowed(filePath, options)) {
-        return { toolCallId: "", output: "", success: false, error: "Path not allowed" };
-      }
-
-      try {
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-
-        fs.writeFileSync(filePath, content, "utf-8");
-        return {
-          toolCallId: "",
-          output: `Successfully wrote ${content.length} characters to ${filePath}`,
-          success: true,
-        };
-      } catch (err) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        };
-      }
-    },
-  };
-}
-
-export function createListDirTool(options: FilesystemOptions = {}): Tool {
-  return {
-    name: "list_directory",
-    description: "List files and directories in a given path.",
-    parameters: [
-      {
-        name: "path",
-        type: "string",
-        description: "Path to the directory to list",
-        required: true,
-      },
-      {
-        name: "recursive",
-        type: "boolean",
-        description: "Whether to list recursively (default: false)",
-        required: false,
-      },
-      {
-        name: "max_depth",
-        type: "number",
-        description: "Maximum depth for recursive listing (default: 3)",
-        required: false,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const dirPath = args.path as string;
-      const recursive = args.recursive as boolean || false;
-      const maxDepth = (args.max_depth as number) || 3;
-
-      if (!dirPath) {
-        return { toolCallId: "", output: "", success: false, error: "Path is required" };
-      }
-
-      if (!isPathAllowed(dirPath, options)) {
-        return { toolCallId: "", output: "", success: false, error: "Path not allowed" };
-      }
-
-      try {
-        const entries = listDir(dirPath, recursive, maxDepth, 0);
-        return { toolCallId: "", output: entries.join("\n"), success: true };
-      } catch (err) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        };
-      }
-    },
-  };
-}
-
-function listDir(dirPath: string, recursive: boolean, maxDepth: number, currentDepth: number): string[] {
-  const results: string[] = [];
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    const prefix = "  ".repeat(currentDepth);
-
-    if (entry.isDirectory()) {
-      results.push(`${prefix}${entry.name}/`);
-      if (recursive && currentDepth < maxDepth) {
-        try {
-          results.push(...listDir(fullPath, recursive, maxDepth, currentDepth + 1));
-        } catch {
-          // Skip inaccessible directories
-        }
-      }
-    } else {
-      results.push(`${prefix}${entry.name}`);
-    }
-  }
-
-  return results;
-}
-
-export function createSearchFilesTool(options: FilesystemOptions = {}): Tool {
-  return {
-    name: "search_files",
-    description: "Search for files by name pattern or content using grep.",
-    parameters: [
-      {
-        name: "path",
-        type: "string",
-        description: "Directory to search in",
-        required: true,
-      },
-      {
-        name: "pattern",
-        type: "string",
-        description: "Search pattern (regex for content, glob for filename)",
-        required: true,
-      },
-      {
-        name: "type",
-        type: "string",
-        description: "Search type: 'content' (grep) or 'filename' (find)",
-        required: false,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const searchPath = args.path as string;
-      const pattern = args.pattern as string;
-      const type = (args.type as string) || "content";
-
-      if (!searchPath || !pattern) {
-        return { toolCallId: "", output: "", success: false, error: "Path and pattern are required" };
-      }
-
-      if (!isPathAllowed(searchPath, options)) {
-        return { toolCallId: "", output: "", success: false, error: "Path not allowed" };
-      }
-
-      try {
-        if (type === "filename") {
-          const results = searchByFilename(searchPath, pattern);
-          return { toolCallId: "", output: results.join("\n") || "No matches found", success: true };
-        } else {
-          const results = searchByContent(searchPath, pattern);
-          return { toolCallId: "", output: results.join("\n") || "No matches found", success: true };
-        }
-      } catch (err) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        };
-      }
-    },
-  };
-}
-
-function searchByFilename(dirPath: string, pattern: string, results: string[] = []): string[] {
-  try {
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    const regex = new RegExp(pattern.replace(/\*/g, ".*").replace(/\?/g, "."));
-
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-
-      if (regex.test(entry.name)) {
-        results.push(fullPath);
-      }
-
-      if (entry.isDirectory()) {
-        try {
-          searchByFilename(fullPath, pattern, results);
-        } catch {
-          // Skip inaccessible directories
-        }
-      }
-    }
-  } catch {
-    // Skip inaccessible directories
-  }
-
-  return results;
-}
-
-function searchByContent(dirPath: string, pattern: string, results: string[] = []): string[] {
-  try {
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    const regex = new RegExp(pattern, "gm");
-
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-
-      if (entry.isDirectory()) {
-        try {
-          searchByContent(fullPath, pattern, results);
-        } catch {
-          // Skip inaccessible directories
-        }
-      } else {
-        try {
-          const content = fs.readFileSync(fullPath, "utf-8");
-          const matches = content.match(regex);
-          if (matches) {
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-              if (regex.test(lines[i])) {
-                results.push(`${fullPath}:${i + 1}: ${lines[i].trim()}`);
-              }
-              // Reset regex state
-              regex.lastIndex = 0;
-            }
-          }
-        } catch {
-          // Skip binary or inaccessible files
-        }
-      }
-    }
-  } catch {
-    // Skip inaccessible directories
-  }
-
-  return results.slice(0, 100); // Limit results
-}
-
-export function createEditFileTool(options: FilesystemOptions = {}): Tool {
-  return {
-    name: "edit_file",
-    description: "Edit a file by replacing specific text. Use this for targeted edits.",
-    parameters: [
-      {
-        name: "path",
-        type: "string",
-        description: "Path to the file to edit",
-        required: true,
-      },
-      {
-        name: "old_text",
-        type: "string",
-        description: "The exact text to replace (must match exactly)",
-        required: true,
-      },
-      {
-        name: "new_text",
-        type: "string",
-        description: "The new text to insert",
-        required: true,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const filePath = args.path as string;
-      const oldText = args.old_text as string;
-      const newText = args.new_text as string;
-
-      if (!filePath || oldText === undefined || newText === undefined) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: "Path, old_text, and new_text are required",
-        };
-      }
-
-      if (!isPathAllowed(filePath, options)) {
-        return { toolCallId: "", output: "", success: false, error: "Path not allowed" };
-      }
-
-      try {
-        let content = fs.readFileSync(filePath, "utf-8");
-        
-        if (!content.includes(oldText)) {
-          return {
-            toolCallId: "",
-            output: "",
-            success: false,
-            error: "old_text not found in file. Make sure it matches exactly.",
-          };
-        }
-
-        content = content.replace(oldText, newText);
-        fs.writeFileSync(filePath, content, "utf-8");
-
-        return {
-          toolCallId: "",
-          output: `Successfully edited ${filePath}`,
-          success: true,
-        };
-      } catch (err) {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        };
-      }
-    },
-  };
-}
-
-// Export all filesystem tools
-export function createFilesystemTools(options: FilesystemOptions = {}): Tool[] {
-  return [
-    createReadFileTool(options),
-    createWriteFileTool(options),
-    createListDirTool(options),
-    createSearchFilesTool(options),
-    createEditFileTool(options),
-  ];
-}
-

package/src/tools/index.ts

@@ -1,22 +0,0 @@
-/**
- * Tools module exports
- */
-
-export type { Tool, ToolResult, ToolParameter } from "./types.js";
-
-export { createBashTool, executeBashStream } from "./bash.js";
-export type { BashOptions } from "./bash.js";
-
-export {
-  createReadFileTool,
-  createWriteFileTool,
-  createListDirTool,
-  createSearchFilesTool,
-  createEditFileTool,
-  createFilesystemTools,
-} from "./filesystem.js";
-export type { FilesystemOptions } from "./filesystem.js";
-
-export { Sandbox, createSandboxTool, isDockerAvailable } from "./sandbox.js";
-export type { SandboxOptions, SandboxResult } from "./sandbox.js";
-