@strayl/agent 0.1.2 → 0.1.4

package/src/tools/builtin/glob.ts

@@ -1,104 +0,0 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-const MAX_RESULTS = 100;
-
-export const globTool: ToolDefinition = {
-  name: "glob",
-  description:
-    "Find files matching a glob pattern. Uses ripgrep (rg --files) if available, falls back to find. " +
-    "Returns matching file paths sorted by name.",
-  parameters: z.object({
-    pattern: z.string().describe("Glob pattern to match (e.g. '**/*.ts', 'src/**/*.tsx')"),
-    path: z.string().optional().describe("Relative path to search in (default: project root)"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { pattern: string; path?: string };
-    const searchPath = path.resolve(ctx.workDir, args.path ?? ".");
-
-    return new Promise((resolve) => {
-      // Try ripgrep first
-      const proc = spawn("rg", ["--files", "--glob", args.pattern, searchPath], {
-        cwd: ctx.workDir,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-
-      let output = "";
-      let fallback = false;
-
-      proc.stdout.on("data", (data: Buffer) => {
-        output += data.toString();
-      });
-
-      proc.on("error", () => {
-        fallback = true;
-      });
-
-      proc.on("close", (code) => {
-        if (fallback || (code !== 0 && output.trim() === "")) {
-          // Fallback to find
-          runFind(args.pattern, searchPath, ctx.workDir).then(resolve);
-          return;
-        }
-
-        const files = output
-          .trim()
-          .split("\n")
-          .filter(Boolean)
-          .map(f => path.relative(ctx.workDir, f))
-          .sort()
-          .slice(0, MAX_RESULTS);
-
-        resolve(
-          JSON.stringify({
-            files,
-            count: files.length,
-            ...(files.length >= MAX_RESULTS ? { truncated: true } : {}),
-          }),
-        );
-      });
-    });
-  },
-};
-
-function runFind(pattern: string, searchPath: string, workDir: string): Promise<string> {
-  return new Promise((resolve) => {
-    // Convert glob to find -name pattern (simplified)
-    const namePattern = pattern.includes("/")
-      ? pattern.split("/").pop()!
-      : pattern;
-
-    const proc = spawn("find", [searchPath, "-name", namePattern, "-type", "f"], {
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let output = "";
-    proc.stdout.on("data", (data: Buffer) => {
-      output += data.toString();
-    });
-
-    proc.on("close", () => {
-      const files = output
-        .trim()
-        .split("\n")
-        .filter(Boolean)
-        .map(f => path.relative(workDir, f))
-        .sort()
-        .slice(0, MAX_RESULTS);
-
-      resolve(
-        JSON.stringify({
-          files,
-          count: files.length,
-          ...(files.length >= MAX_RESULTS ? { truncated: true } : {}),
-        }),
-      );
-    });
-
-    proc.on("error", () => {
-      resolve(JSON.stringify({ error: "Neither rg nor find available", files: [] }));
-    });
-  });
-}

package/src/tools/builtin/grep.ts

@@ -1,115 +0,0 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-const MAX_MATCHES = 50;
-
-export const grepTool: ToolDefinition = {
-  name: "grep",
-  description:
-    "Search for a pattern in files. Uses ripgrep (rg) if available, falls back to grep. " +
-    "Returns matching lines with file paths, line numbers, and surrounding context.",
-  parameters: z.object({
-    pattern: z.string().describe("Regex pattern to search for"),
-    path: z.string().optional().describe("Relative path to search in (default: project root)"),
-    glob: z.string().optional().describe("File pattern to filter (e.g. '*.ts', '*.{js,jsx}')"),
-    ignoreCase: z.boolean().optional().describe("Case insensitive search"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as {
-      pattern: string;
-      path?: string;
-      glob?: string;
-      ignoreCase?: boolean;
-    };
-
-    const searchPath = path.resolve(ctx.workDir, args.path ?? ".");
-
-    // Try ripgrep first, fall back to grep
-    const rgAvailable = await commandExists("rg");
-
-    const cmdArgs: string[] = rgAvailable
-      ? buildRgArgs(args, searchPath)
-      : buildGrepArgs(args, searchPath);
-
-    const cmd = rgAvailable ? "rg" : "grep";
-
-    return new Promise((resolve) => {
-      const proc = spawn(cmd, cmdArgs, {
-        cwd: ctx.workDir,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-
-      let output = "";
-      let lineCount = 0;
-
-      proc.stdout.on("data", (data: Buffer) => {
-        const text = data.toString();
-        const lines = text.split("\n");
-        for (const line of lines) {
-          if (lineCount >= MAX_MATCHES * 3) break; // ~3 lines per match with context
-          output += line + "\n";
-          lineCount++;
-        }
-      });
-
-      proc.stderr.on("data", () => {
-        // ignore stderr
-      });
-
-      proc.on("close", (code) => {
-        if (code === 1 && output.trim() === "") {
-          resolve(JSON.stringify({ matches: 0, output: "No matches found." }));
-          return;
-        }
-
-        const trimmed = output.trim();
-        const matchCount = trimmed.split("\n").filter(l => l.length > 0).length;
-        const truncated = matchCount >= MAX_MATCHES * 3;
-
-        resolve(
-          JSON.stringify({
-            matches: Math.min(matchCount, MAX_MATCHES),
-            output: trimmed,
-            ...(truncated ? { truncated: true, note: `Output limited to ~${MAX_MATCHES} matches` } : {}),
-          }),
-        );
-      });
-
-      proc.on("error", () => {
-        resolve(JSON.stringify({ error: `${cmd} not available` }));
-      });
-    });
-  },
-};
-
-function buildRgArgs(
-  args: { pattern: string; glob?: string; ignoreCase?: boolean },
-  searchPath: string,
-): string[] {
-  const rgArgs = ["-n", "-C", "2", "--max-count", String(MAX_MATCHES)];
-  if (args.ignoreCase) rgArgs.push("-i");
-  if (args.glob) rgArgs.push("--glob", args.glob);
-  rgArgs.push(args.pattern, searchPath);
-  return rgArgs;
-}
-
-function buildGrepArgs(
-  args: { pattern: string; glob?: string; ignoreCase?: boolean },
-  searchPath: string,
-): string[] {
-  const grepArgs = ["-rn"];
-  if (args.ignoreCase) grepArgs.push("-i");
-  if (args.glob) grepArgs.push("--include", args.glob);
-  grepArgs.push(args.pattern, searchPath);
-  return grepArgs;
-}
-
-function commandExists(cmd: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const proc = spawn("which", [cmd], { stdio: "ignore" });
-    proc.on("close", (code) => resolve(code === 0));
-    proc.on("error", () => resolve(false));
-  });
-}

package/src/tools/builtin/ls.ts

@@ -1,54 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-export const lsTool: ToolDefinition = {
-  name: "ls",
-  description:
-    "List files and directories at a given path. Returns names, types, sizes, and modification times. " +
-    "Directories are listed first, then files, both sorted alphabetically.",
-  parameters: z.object({
-    path: z.string().optional().describe("Relative path to list (default: project root)"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { path?: string };
-    const dirPath = path.resolve(ctx.workDir, args.path ?? ".");
-
-    try {
-      const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-      const results: Array<{ name: string; type: string; size?: number; modified?: string }> = [];
-
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry.name);
-        const item: { name: string; type: string; size?: number; modified?: string } = {
-          name: entry.name,
-          type: entry.isDirectory() ? "dir" : "file",
-        };
-
-        try {
-          const stat = await fs.stat(entryPath);
-          if (!entry.isDirectory()) item.size = stat.size;
-          item.modified = stat.mtime.toISOString();
-        } catch {
-          // stat may fail for broken symlinks
-        }
-
-        results.push(item);
-      }
-
-      // Sort: dirs first, then alphabetical
-      results.sort((a, b) => {
-        if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
-        return a.name.localeCompare(b.name);
-      });
-
-      return JSON.stringify(results);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (msg.includes("ENOENT")) return JSON.stringify({ error: `Directory not found: ${args.path ?? "."}` });
-      return JSON.stringify({ error: msg });
-    }
-  },
-};

package/src/tools/builtin/move.ts

@@ -1,31 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-export const moveFileTool: ToolDefinition = {
-  name: "move_file",
-  description: "Move or rename a file or directory.",
-  parameters: z.object({
-    source: z.string().describe("Relative path of the source file/directory"),
-    destination: z.string().describe("Relative path of the destination"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { source: string; destination: string };
-    const srcPath = path.resolve(ctx.workDir, args.source);
-    const destPath = path.resolve(ctx.workDir, args.destination);
-
-    if (!srcPath.startsWith(ctx.workDir) || !destPath.startsWith(ctx.workDir)) {
-      return JSON.stringify({ error: "Cannot move files outside the project directory" });
-    }
-
-    try {
-      await fs.mkdir(path.dirname(destPath), { recursive: true });
-      await fs.rename(srcPath, destPath);
-      return JSON.stringify({ moved: { from: args.source, to: args.destination } });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return JSON.stringify({ error: msg });
-    }
-  },
-};

package/src/tools/builtin/read.ts

@@ -1,69 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-const MAX_FILE_SIZE = 500 * 1024; // 500KB
-
-export const readFileTool: ToolDefinition = {
-  name: "read_file",
-  description:
-    "Read a file from the project. Returns content with line numbers. " +
-    "Use offset and limit to read specific sections of large files.",
-  parameters: z.object({
-    path: z.string().describe("Relative path to the file"),
-    offset: z.number().optional().describe("Line number to start reading from (1-based)"),
-    limit: z.number().optional().describe("Number of lines to read"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { path: string; offset?: number; limit?: number };
-    const filePath = path.resolve(ctx.workDir, args.path);
-
-    try {
-      const stat = await fs.stat(filePath);
-
-      // Binary file detection
-      if (stat.size > MAX_FILE_SIZE) {
-        const sample = Buffer.alloc(512);
-        const fh = await fs.open(filePath, "r");
-        await fh.read(sample, 0, 512, 0);
-        await fh.close();
-
-        if (isBinary(sample)) {
-          return JSON.stringify({ error: `Binary file, ${stat.size} bytes` });
-        }
-      }
-
-      const raw = await fs.readFile(filePath, "utf-8");
-      const lines = raw.split("\n");
-
-      const offset = Math.max(1, args.offset ?? 1);
-      const limit = args.limit ?? lines.length;
-      const selected = lines.slice(offset - 1, offset - 1 + limit);
-
-      const numbered = selected
-        .map((line, i) => {
-          const lineNum = String(offset + i).padStart(4, " ");
-          return `${lineNum}| ${line}`;
-        })
-        .join("\n");
-
-      return numbered || "(empty file)";
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (msg.includes("ENOENT")) return JSON.stringify({ error: `File not found: ${args.path}` });
-      return JSON.stringify({ error: msg });
-    }
-  },
-};
-
-function isBinary(buffer: Buffer): boolean {
-  for (let i = 0; i < buffer.length; i++) {
-    const byte = buffer[i];
-    // Null byte or control characters (except common ones)
-    if (byte === 0) return true;
-    if (byte < 8) return true;
-    if (byte === 14 || byte === 15) return true;
-  }
-  return false;
-}

package/src/tools/builtin/write.ts

@@ -1,42 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-export const writeFileTool: ToolDefinition = {
-  name: "write_file",
-  description:
-    "Write content to a file. Creates parent directories if needed. " +
-    "Overwrites existing files. Use for creating new files or complete rewrites.",
-  parameters: z.object({
-    path: z.string().describe("Relative path to the file"),
-    content: z.string().describe("Full content to write to the file"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { path: string; content: string };
-    const filePath = path.resolve(ctx.workDir, args.path);
-
-    try {
-      // Create parent directories
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-
-      await fs.writeFile(filePath, args.content, "utf-8");
-
-      const lines = args.content.split("\n").length;
-      const bytes = Buffer.byteLength(args.content, "utf-8");
-
-      ctx.emitter.emit({
-        type: "file-complete",
-        id: ctx.toolCallId,
-        path: args.path,
-        lines,
-        bytes,
-      });
-
-      return JSON.stringify({ path: args.path, linesWritten: lines, bytesWritten: bytes });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return JSON.stringify({ error: msg });
-    }
-  },
-};

package/src/tools/executor.ts

@@ -1,51 +0,0 @@
-import type { ToolCall, ToolContext, Middleware } from "../types.js";
-import type { ToolRegistry } from "./registry.js";
-
-export async function executeTool(
-  registry: ToolRegistry,
-  toolCall: ToolCall,
-  ctx: ToolContext,
-  middleware: Middleware[],
-): Promise<string> {
-  const def = registry.get(toolCall.function.name);
-  if (!def) {
-    return JSON.stringify({ error: `Unknown tool: ${toolCall.function.name}` });
-  }
-
-  let args: unknown;
-  try {
-    args = JSON.parse(toolCall.function.arguments);
-  } catch {
-    return JSON.stringify({ error: `Invalid JSON arguments for tool ${toolCall.function.name}` });
-  }
-
-  const parsed = def.parameters.safeParse(args);
-  if (!parsed.success) {
-    return JSON.stringify({
-      error: `Validation error: ${parsed.error.message}. Fix your arguments and retry.`,
-    });
-  }
-
-  // Pass raw args (not parsed.data) to execute — HITL merges extra fields
-  // like "answer", "feedback", "value" that aren't in the Zod schema.
-  // Zod validation ensures the LLM-provided fields are correct,
-  // but the execute function needs access to HITL-injected fields too.
-  const execute = () => def.execute(args, ctx);
-
-  // Apply middleware wrapToolCall chain (innermost first)
-  let fn = execute;
-  for (const mw of [...middleware].reverse()) {
-    if (mw.wrapToolCall) {
-      const prevFn = fn;
-      const wrappedMw = mw;
-      fn = () => wrappedMw.wrapToolCall!(toolCall, prevFn);
-    }
-  }
-
-  try {
-    return await fn();
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return JSON.stringify({ error: `Tool execution error: ${msg}. Fix and retry.` });
-  }
-}