@fastino-ai/pioneer-cli 0.1.0 → 0.2.1

package/src/tools/bash.ts

@@ -0,0 +1,184 @@
+/**
+ * Bash execution tool - Execute shell commands safely
+ */
+
+import { spawn } from "child_process";
+import type { Tool, ToolResult, ToolParameter } from "../agent/types.js";
+
+export interface BashOptions {
+  cwd?: string;
+  timeout?: number;
+  env?: Record<string, string>;
+  maxOutput?: number;
+}
+
+export function createBashTool(options: BashOptions = {}): Tool {
+  const { cwd = process.cwd(), timeout = 60000, maxOutput = 100000 } = options;
+
+  return {
+    name: "bash",
+    description: "Execute a bash command. Use this to run shell commands, install packages, manage files, etc.",
+    parameters: [
+      {
+        name: "command",
+        type: "string",
+        description: "The bash command to execute",
+        required: true,
+      },
+      {
+        name: "workdir",
+        type: "string",
+        description: "Working directory for the command (optional, defaults to current directory)",
+        required: false,
+      },
+    ],
+
+    async execute(args: Record<string, unknown>): Promise<ToolResult> {
+      const command = args.command as string;
+      const workdir = (args.workdir as string) || cwd;
+
+      if (!command || typeof command !== "string") {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: "Command is required and must be a string",
+        };
+      }
+
+      return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+
+        const proc = spawn("bash", ["-c", command], {
+          cwd: workdir,
+          env: { ...process.env, ...options.env },
+          stdio: ["pipe", "pipe", "pipe"],
+        });
+
+        const timer = setTimeout(() => {
+          timedOut = true;
+          proc.kill("SIGTERM");
+          setTimeout(() => proc.kill("SIGKILL"), 5000);
+        }, timeout);
+
+        proc.stdout.on("data", (data: Buffer) => {
+          const chunk = data.toString();
+          if (stdout.length + chunk.length <= maxOutput) {
+            stdout += chunk;
+          } else if (stdout.length < maxOutput) {
+            stdout += chunk.slice(0, maxOutput - stdout.length);
+            stdout += "\n... (output truncated)";
+          }
+        });
+
+        proc.stderr.on("data", (data: Buffer) => {
+          const chunk = data.toString();
+          if (stderr.length + chunk.length <= maxOutput) {
+            stderr += chunk;
+          } else if (stderr.length < maxOutput) {
+            stderr += chunk.slice(0, maxOutput - stderr.length);
+            stderr += "\n... (output truncated)";
+          }
+        });
+
+        proc.on("close", (code) => {
+          clearTimeout(timer);
+
+          let output = "";
+          if (stdout) output += stdout;
+          if (stderr) output += (output ? "\n" : "") + stderr;
+          if (timedOut) output += `\n(Command timed out after ${timeout / 1000}s)`;
+
+          resolve({
+            toolCallId: "",
+            output: output || "(no output)",
+            success: !timedOut && code === 0,
+            error: timedOut
+              ? `Command timed out after ${timeout / 1000}s`
+              : code !== 0
+              ? `Command exited with code ${code}`
+              : undefined,
+          });
+        });
+
+        proc.on("error", (err) => {
+          clearTimeout(timer);
+          resolve({
+            toolCallId: "",
+            output: "",
+            success: false,
+            error: `Failed to execute command: ${err.message}`,
+          });
+        });
+      });
+    },
+  };
+}
+
+// Streaming version for real-time output
+export async function* executeBashStream(
+  command: string,
+  options: BashOptions = {}
+): AsyncGenerator<{ type: "stdout" | "stderr" | "exit"; data: string | number }> {
+  const { cwd = process.cwd(), timeout = 60000 } = options;
+
+  const proc = spawn("bash", ["-c", command], {
+    cwd,
+    env: { ...process.env, ...options.env },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGTERM");
+    setTimeout(() => proc.kill("SIGKILL"), 5000);
+  }, timeout);
+
+  const stdoutQueue: string[] = [];
+  const stderrQueue: string[] = [];
+  let exited = false;
+  let exitCode: number | null = null;
+
+  proc.stdout.on("data", (data: Buffer) => {
+    stdoutQueue.push(data.toString());
+  });
+
+  proc.stderr.on("data", (data: Buffer) => {
+    stderrQueue.push(data.toString());
+  });
+
+  const exitPromise = new Promise<number | null>((resolve) => {
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      exited = true;
+      exitCode = timedOut ? -1 : code;
+      resolve(exitCode);
+    });
+
+    proc.on("error", () => {
+      clearTimeout(timer);
+      exited = true;
+      exitCode = -1;
+      resolve(-1);
+    });
+  });
+
+  // Yield output as it comes
+  while (!exited || stdoutQueue.length > 0 || stderrQueue.length > 0) {
+    while (stdoutQueue.length > 0) {
+      yield { type: "stdout", data: stdoutQueue.shift()! };
+    }
+    while (stderrQueue.length > 0) {
+      yield { type: "stderr", data: stderrQueue.shift()! };
+    }
+    if (!exited) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+
+  yield { type: "exit", data: exitCode ?? -1 };
+}
+

package/src/tools/filesystem.ts

@@ -0,0 +1,444 @@
+/**
+ * Filesystem tools - Read/write files, list directories, search
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import type { Tool, ToolResult, ToolParameter } from "../agent/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

@@ -0,0 +1,29 @@
+/**
+ * Tools module exports
+ */
+
+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";
+
+export { createModalRunTool, createModalDeployTool, createModalTools, isModalAvailable } from "./modal.js";
+export type { ModalConfig } from "./modal.js";
+
+export { createWandbLogTool, createWandbQueryTool, createWandbTools, isWandbAvailable } from "./wandb.js";
+export type { WandbConfig } from "./wandb.js";
+
+export { createTrainingTool, createFineTuningTool, createTrainingTools } from "./training.js";
+export type { TrainingConfig } from "./training.js";
+