@strayl/agent 0.1.2 → 0.1.4

package/src/stdin-listener.ts

@@ -1,61 +0,0 @@
-import { createInterface } from "node:readline";
-
-export type StdinCommand =
-  | { type: "inject"; text: string; images?: Array<{ base64: string; contentType: string }> }
-  | { type: "cancel" }
-  | { type: "hitl-response"; id: string; decision: string; data?: unknown }
-  | { type: "rollback"; checkpoint_id?: string; iteration?: number }
-  | { type: "confirm-plan" };
-
-/**
- * Listens to stdin for JSON-per-line commands.
- * Non-blocking — drains queued commands when polled.
- */
-export class StdinListener {
-  private queue: StdinCommand[] = [];
-  private cancelled = false;
-  private rl: ReturnType<typeof createInterface> | null = null;
-
-  start(): void {
-    // Always listen — we receive commands both via pipe and PTY
-    this.rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
-
-    this.rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-
-      try {
-        const cmd = JSON.parse(trimmed);
-        if (cmd.type === "cancel") {
-          this.cancelled = true;
-        }
-        this.queue.push(cmd as StdinCommand);
-      } catch {
-        // Not valid JSON — ignore
-      }
-    });
-
-    this.rl.on("close", () => {
-      // stdin closed — don't treat as cancel.
-      // Only explicit {"type":"cancel"} cancels the agent.
-      // If parent dies, the agent will finish its current iteration
-      // and exit naturally (no more stdin commands).
-    });
-  }
-
-  /** Drain all queued commands since last call */
-  drain(): StdinCommand[] {
-    const cmds = this.queue;
-    this.queue = [];
-    return cmds;
-  }
-
-  isCancelled(): boolean {
-    return this.cancelled;
-  }
-
-  stop(): void {
-    this.rl?.close();
-    this.rl = null;
-  }
-}

package/src/subagents/definitions.ts

@@ -1,72 +0,0 @@
-export interface SubAgentDef {
-  name: string;
-  description: string;
-  systemPrompt: string;
-  allowedTools: string[];
-}
-
-export const CODE_EXPLORER: SubAgentDef = {
-  name: "code-explorer",
-  description: "Fast agent for exploring the project codebase. Read-only operations only.",
-  systemPrompt: `You are a code exploration assistant. Your job is to quickly find and analyze code in the project.
-
-You have access to: ls, read_file, grep, glob (read-only tools only).
-
-When exploring:
-1. Start with ls to understand project structure
-2. Use glob to find files matching patterns
-3. Use grep to search for specific code patterns
-4. Use read_file to examine file contents
-
-Output format:
-- **Files Found**: List relevant files discovered
-- **Key Code**: Important code snippets (with file paths and line numbers)
-- **Summary**: Brief analysis answering the original question`,
-  allowedTools: ["ls", "read_file", "grep", "glob"],
-};
-
-export const WEB_RESEARCHER: SubAgentDef = {
-  name: "web-researcher",
-  description: "Research technical questions on the web. Fetches docs and API references.",
-  systemPrompt: `You are a web research assistant. Your job is to find accurate technical information.
-
-You have access to: web_search, web_fetch
-
-Workflow:
-1. Use web_search to find relevant pages
-2. Use web_fetch to read the most promising results
-3. Prefer official documentation over blog posts
-4. Verify edge runtime compatibility when relevant (no Node.js APIs, no TCP, no native bindings)
-
-Output format:
-- **Answer**: Direct answer to the question
-- **Sources**: URLs consulted
-- **Code Example**: If applicable, working code snippet
-- **Edge Compatibility**: Any runtime restrictions noted`,
-  allowedTools: ["web_search", "web_fetch"],
-};
-
-export const GENERAL_PURPOSE: SubAgentDef = {
-  name: "general-purpose",
-  description: "Multi-step tasks combining file exploration and web research.",
-  systemPrompt: `You assist with multi-step tasks that may require both code exploration and web research.
-
-You have access to: ls, read_file, grep, glob, web_search, web_fetch
-
-Rules:
-- Always use relative paths
-- Don't modify files unless explicitly asked
-- Be thorough but concise
-
-Output format:
-- **What was found**: Key discoveries
-- **Relevant code**: File paths and snippets
-- **Recommendation**: Suggested approach or answer`,
-  allowedTools: ["ls", "read_file", "grep", "glob", "web_search", "web_fetch"],
-};
-
-export const SUBAGENT_DEFS: Record<string, SubAgentDef> = {
-  "code-explorer": CODE_EXPLORER,
-  "web-researcher": WEB_RESEARCHER,
-  "general-purpose": GENERAL_PURPOSE,
-};

package/src/subagents/manager.ts

@@ -1,161 +0,0 @@
-import type { Message } from "../types.js";
-import type { Emitter } from "../emitter.js";
-import { LLMClient } from "../llm/client.js";
-import { SUBAGENT_MODEL } from "../llm/models.js";
-import { ToolRegistry } from "../tools/registry.js";
-import { executeTool } from "../tools/executor.js";
-import { SUBAGENT_DEFS } from "./definitions.js";
-
-// Import builtin tools for sub-agent use
-import { readFileTool } from "../tools/builtin/read.js";
-import { lsTool } from "../tools/builtin/ls.js";
-import { grepTool } from "../tools/builtin/grep.js";
-import { globTool } from "../tools/builtin/glob.js";
-import { webSearchTool } from "../tools/external/web-search.js";
-import { webFetchTool } from "../tools/external/web-fetch.js";
-
-export interface SubAgentSpawnConfig {
-  agentName: string;
-  label: string;
-  prompt: string;
-  workDir: string;
-  env: Record<string, string>;
-}
-
-const AVAILABLE_TOOLS: Record<string, import("../types.js").ToolDefinition> = {
-  ls: lsTool,
-  read_file: readFileTool,
-  grep: grepTool,
-  glob: globTool,
-  web_search: webSearchTool,
-  web_fetch: webFetchTool,
-};
-
-export class SubAgentManager {
-  private running = new Map<string, Promise<string>>();
-  private emitter: Emitter;
-
-  constructor(emitter: Emitter) {
-    this.emitter = emitter;
-  }
-
-  spawn(config: SubAgentSpawnConfig): string {
-    const id = `sa_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-
-    this.emitter.emit({
-      type: "subagent-start",
-      id,
-      name: config.agentName,
-      label: config.label,
-    });
-
-    const promise = this.runSubAgentLoop(id, config);
-    this.running.set(id, promise);
-    return id;
-  }
-
-  async waitFor(id: string): Promise<string> {
-    const result = await this.running.get(id);
-    this.running.delete(id);
-    return result ?? "";
-  }
-
-  private async runSubAgentLoop(id: string, config: SubAgentSpawnConfig): Promise<string> {
-    const def = SUBAGENT_DEFS[config.agentName];
-    if (!def) return JSON.stringify({ error: `Unknown sub-agent: ${config.agentName}` });
-
-    const client = new LLMClient({
-      modelTier: SUBAGENT_MODEL,
-      env: config.env,
-    });
-
-    // Build registry with only allowed tools
-    const registry = new ToolRegistry();
-    for (const toolName of def.allowedTools) {
-      const tool = AVAILABLE_TOOLS[toolName];
-      if (tool) registry.register(tool);
-    }
-
-    const messages: Message[] = [
-      { role: "system", content: def.systemPrompt },
-      { role: "user", content: config.prompt },
-    ];
-
-    const tools = registry.toOpenAITools();
-    const maxIterations = 30;
-    let result = "";
-
-    for (let i = 0; i < maxIterations; i++) {
-      let text = "";
-      const toolCalls: import("../types.js").ToolCall[] = [];
-
-      for await (const chunk of client.stream(messages, tools)) {
-        switch (chunk.type) {
-          case "text":
-            text += chunk.text;
-            this.emitter.emit({ type: "subagent-delta", id, text: chunk.text });
-            break;
-          case "tool_call_complete":
-            toolCalls.push({
-              id: chunk.id,
-              type: "function",
-              function: { name: chunk.name, arguments: chunk.arguments },
-            });
-            break;
-        }
-      }
-
-      // Add assistant message
-      const assistantMsg: Message = { role: "assistant", content: text || null };
-      if (toolCalls.length > 0) assistantMsg.tool_calls = toolCalls;
-      messages.push(assistantMsg);
-
-      if (toolCalls.length === 0) {
-        result = text;
-        break;
-      }
-
-      // Execute tool calls
-      for (const tc of toolCalls) {
-        let parsedArgs: unknown;
-        try { parsedArgs = JSON.parse(tc.function.arguments); } catch { parsedArgs = {}; }
-
-        // Emit with _subagent tag so app can associate with this subagent
-        (this.emitter as { emit(e: Record<string, unknown>): void }).emit({
-          type: "tool-call-start",
-          id: tc.id,
-          name: tc.function.name,
-          args: parsedArgs,
-          _subagent: id,
-        });
-
-        const ctx = {
-          emitter: this.emitter,
-          workDir: config.workDir,
-          env: config.env,
-          sessionId: id,
-          toolCallId: tc.id,
-        };
-        const output = await executeTool(registry, tc, ctx, []);
-
-        (this.emitter as { emit(e: Record<string, unknown>): void }).emit({
-          type: "tool-result",
-          id: tc.id,
-          name: tc.function.name,
-          output,
-          _subagent: id,
-        });
-
-        messages.push({
-          role: "tool",
-          content: output,
-          tool_call_id: tc.id,
-          name: tc.function.name,
-        });
-      }
-    }
-
-    this.emitter.emit({ type: "subagent-result", id, output: result });
-    return result;
-  }
-}

package/src/todos/manager.ts

@@ -1,61 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, TodoItem } from "../types.js";
-import type { Emitter } from "../emitter.js";
-
-export class TodoManager {
-  private todos: TodoItem[] = [];
-  private emitter: Emitter;
-
-  constructor(emitter: Emitter) {
-    this.emitter = emitter;
-  }
-
-  write(todos: TodoItem[]): void {
-    this.todos = todos;
-    this.emitter.emit({ type: "todos-update", todos: this.todos });
-  }
-
-  read(): TodoItem[] {
-    return this.todos;
-  }
-
-  restore(todos: TodoItem[]): void {
-    this.todos = structuredClone(todos);
-    this.emitter.emit({ type: "todos-update", todos: this.todos });
-  }
-
-  createTools(): ToolDefinition[] {
-    return [
-      {
-        name: "write_todos",
-        description:
-          "Create or update the todo list. Pass the complete list each time. " +
-          "Set status to 'in_progress' when starting a step, 'completed' when done. " +
-          "Pass an empty array to clear all todos when the task is complete.",
-        parameters: z.object({
-          todos: z.array(
-            z.object({
-              content: z.string().describe("Description of the todo item"),
-              status: z
-                .enum(["pending", "in_progress", "completed"])
-                .describe("Current status of the todo"),
-            }),
-          ),
-        }),
-        execute: async (rawArgs: unknown): Promise<string> => {
-          const args = rawArgs as { todos: TodoItem[] };
-          this.write(args.todos);
-          return JSON.stringify({ success: true, count: args.todos.length });
-        },
-      },
-      {
-        name: "read_todos",
-        description: "Read the current todo list to check progress.",
-        parameters: z.object({}),
-        execute: async (): Promise<string> => {
-          return JSON.stringify({ todos: this.read() });
-        },
-      },
-    ];
-  }
-}

package/src/tools/builtin/delete.ts

@@ -1,29 +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 deleteFileTool: ToolDefinition = {
-  name: "delete_file",
-  description: "Delete a file or directory. Directories are deleted recursively.",
-  parameters: z.object({
-    path: z.string().describe("Relative path to the file or directory to delete"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { path: string };
-    const filePath = path.resolve(ctx.workDir, args.path);
-
-    // Safety: prevent deleting outside workDir
-    if (!filePath.startsWith(ctx.workDir)) {
-      return JSON.stringify({ error: "Cannot delete files outside the project directory" });
-    }
-
-    try {
-      await fs.rm(filePath, { recursive: true, force: true });
-      return JSON.stringify({ deleted: args.path });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return JSON.stringify({ error: msg });
-    }
-  },
-};

package/src/tools/builtin/edit.ts

@@ -1,74 +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 editFileTool: ToolDefinition = {
-  name: "edit_file",
-  description:
-    "Edit a file by replacing an exact string match with new content. " +
-    "The old_string must match exactly (including whitespace and indentation). " +
-    "If multiple occurrences exist, provide more surrounding context to make the match unique.",
-  parameters: z.object({
-    path: z.string().describe("Relative path to the file"),
-    old_string: z.string().describe("Exact string to find and replace"),
-    new_string: z.string().describe("String to replace old_string with"),
-    replace_all: z.boolean().optional().describe("Replace all occurrences instead of just the first"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as {
-      path: string;
-      old_string: string;
-      new_string: string;
-      replace_all?: boolean;
-    };
-    const filePath = path.resolve(ctx.workDir, args.path);
-
-    try {
-      const content = await fs.readFile(filePath, "utf-8");
-      const occurrences = content.split(args.old_string).length - 1;
-
-      if (occurrences === 0) {
-        return JSON.stringify({
-          error: "String not found in file. Verify the exact content including whitespace and indentation.",
-        });
-      }
-
-      if (occurrences > 1 && !args.replace_all) {
-        return JSON.stringify({
-          error: `Found ${occurrences} occurrences. Provide more surrounding context to make the match unique, or set replace_all: true.`,
-        });
-      }
-
-      let newContent: string;
-      if (args.replace_all) {
-        newContent = content.split(args.old_string).join(args.new_string);
-      } else {
-        const idx = content.indexOf(args.old_string);
-        newContent = content.slice(0, idx) + args.new_string + content.slice(idx + args.old_string.length);
-      }
-
-      await fs.writeFile(filePath, newContent, "utf-8");
-
-      const lines = newContent.split("\n").length;
-      const bytes = Buffer.byteLength(newContent, "utf-8");
-
-      ctx.emitter.emit({
-        type: "file-complete",
-        id: ctx.toolCallId,
-        path: args.path,
-        lines,
-        bytes,
-      });
-
-      return JSON.stringify({
-        path: args.path,
-        occurrences: args.replace_all ? occurrences : 1,
-      });
-    } 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 });
-    }
-  },
-};

package/src/tools/builtin/exec.ts

@@ -1,216 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import { openSync, closeSync } from "node:fs";
-import path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-
-// Track background processes: pid → log file path
-const bgProcesses = new Map<number, { logFile: string; command: string }>();
-
-export const execTool: ToolDefinition = {
-  name: "exec",
-  description:
-    "Execute a shell command in the project sandbox. Use for running build commands, installing packages, running scripts, etc. " +
-    "Returns stdout, stderr, and exit code. Use background: true for long-running processes like dev servers. " +
-    "Background processes write logs to a file — use get_logs to read them.",
-  parameters: z.object({
-    command: z.string().describe("Shell command to execute"),
-    cwd: z
-      .string()
-      .optional()
-      .describe("Subdirectory relative to project root to run command in (e.g. 'web-application')"),
-    background: z
-      .boolean()
-      .optional()
-      .describe("If true, run in background and return immediately with PID"),
-    timeout: z
-      .number()
-      .optional()
-      .describe("Timeout in seconds (default: 120, max: 600)"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as {
-      command: string;
-      cwd?: string;
-      background?: boolean;
-      timeout?: number;
-    };
-
-    let workDir = ctx.workDir;
-    if (args.cwd && args.cwd !== "." && args.cwd !== "./") {
-      workDir = path.resolve(ctx.workDir, args.cwd);
-    }
-
-    const timeoutMs = Math.min((args.timeout ?? 120) * 1000, 600_000);
-
-    if (args.background) {
-      return runBackground(args.command, workDir, ctx);
-    }
-
-    return runForeground(args.command, workDir, timeoutMs, ctx);
-  },
-};
-
-export const getLogsTool: ToolDefinition = {
-  name: "get_logs",
-  description:
-    "Read logs from a background process. Use after starting a command with background: true. " +
-    "Pass the PID returned by exec, or omit to list all background processes. " +
-    "Use tail: true to get only the last lines (useful for checking dev server status).",
-  parameters: z.object({
-    pid: z.number().optional().describe("PID of the background process"),
-    tail: z.number().optional().describe("Number of lines from the end (default: all)"),
-    list: z.boolean().optional().describe("If true, list all tracked background processes"),
-  }),
-  execute: async (rawArgs: unknown): Promise<string> => {
-    const args = rawArgs as { pid?: number; tail?: number; list?: boolean };
-
-    if (args.list || args.pid === undefined) {
-      const processes: Array<{ pid: number; command: string; running: boolean }> = [];
-      for (const [pid, info] of bgProcesses) {
-        processes.push({
-          pid,
-          command: info.command,
-          running: isProcessRunning(pid),
-        });
-      }
-      return JSON.stringify({ processes });
-    }
-
-    const info = bgProcesses.get(args.pid);
-    if (!info) {
-      return JSON.stringify({ error: `No tracked background process with PID ${args.pid}` });
-    }
-
-    try {
-      const content = await fs.readFile(info.logFile, "utf-8");
-      const running = isProcessRunning(args.pid);
-
-      if (args.tail) {
-        const lines = content.split("\n");
-        const tailed = lines.slice(-args.tail).join("\n");
-        return JSON.stringify({ pid: args.pid, running, logs: tailed, total_lines: lines.length });
-      }
-
-      // Truncate if too large
-      const maxLen = 50_000;
-      if (content.length > maxLen) {
-        const truncated = content.slice(-maxLen);
-        return JSON.stringify({
-          pid: args.pid,
-          running,
-          logs: truncated,
-          truncated: true,
-          note: `Showing last ${maxLen} chars. Use tail parameter for specific line count.`,
-        });
-      }
-
-      return JSON.stringify({ pid: args.pid, running, logs: content });
-    } catch {
-      return JSON.stringify({ pid: args.pid, running: isProcessRunning(args.pid), logs: "" });
-    }
-  },
-};
-
-async function runForeground(
-  command: string,
-  cwd: string,
-  timeoutMs: number,
-  ctx: ToolContext,
-): Promise<string> {
-  return new Promise((resolve) => {
-    const proc = spawn("bash", ["-c", command], {
-      cwd,
-      env: { ...process.env, ...ctx.env },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-
-    proc.stdout.on("data", (data: Buffer) => {
-      const text = data.toString();
-      stdout += text;
-      ctx.emitter.emit({ type: "exec-log", id: ctx.toolCallId, data: text });
-    });
-
-    proc.stderr.on("data", (data: Buffer) => {
-      const text = data.toString();
-      stderr += text;
-      ctx.emitter.emit({ type: "exec-log", id: ctx.toolCallId, data: text });
-    });
-
-    const timer = setTimeout(() => {
-      proc.kill("SIGTERM");
-      setTimeout(() => proc.kill("SIGKILL"), 5000);
-    }, timeoutMs);
-
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-
-      const maxLen = 50_000;
-      if (stdout.length > maxLen) {
-        stdout = stdout.slice(0, maxLen / 2) + "\n[... truncated ...]\n" + stdout.slice(-maxLen / 2);
-      }
-      if (stderr.length > maxLen) {
-        stderr = stderr.slice(0, maxLen / 2) + "\n[... truncated ...]\n" + stderr.slice(-maxLen / 2);
-      }
-
-      resolve(
-        JSON.stringify({
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-          exitCode: code ?? 1,
-        }),
-      );
-    });
-
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      resolve(JSON.stringify({ error: err.message, exitCode: 1 }));
-    });
-  });
-}
-
-async function runBackground(
-  command: string,
-  cwd: string,
-  ctx: ToolContext,
-): Promise<string> {
-  // Create log file for this background process
-  const logDir = path.join(ctx.workDir, ".strayl", "logs");
-  await fs.mkdir(logDir, { recursive: true });
-  const logFile = path.join(logDir, `bg_${Date.now()}.log`);
-
-  // Open log file for writing
-  const fd = openSync(logFile, "w");
-
-  const proc = spawn("bash", ["-c", command], {
-    cwd,
-    env: { ...process.env, ...ctx.env },
-    stdio: ["ignore", fd, fd], // stdout+stderr → log file
-    detached: true,
-  });
-
-  const pid = proc.pid!;
-  bgProcesses.set(pid, { logFile, command });
-  proc.unref();
-  closeSync(fd);
-
-  return JSON.stringify({
-    pid,
-    logFile: path.relative(ctx.workDir, logFile),
-    message: `Command started in background (PID ${pid}). Use get_logs with this PID to check output.`,
-    background: true,
-  });
-}
-
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0); // Signal 0 = check existence
-    return true;
-  } catch {
-    return false;
-  }
-}