opencode-task 0.1.1 → 0.1.4

package/dist/index.js

@@ -12329,22 +12329,593 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// utils.ts
+import { appendFile } from "node:fs/promises";
+var AGENT_CONFIGS = {
+  Explore: {
+    description: "Fast agent specialized for exploring codebases. Use when you need to quickly find files by patterns, search code for keywords, or answer questions about the codebase.",
+    prompt: "You are an exploration specialist. Search thoroughly using Glob, Grep, and Read. Report findings concisely. Do not modify any files.",
+    tools: [
+      "Glob",
+      "Grep",
+      "Read",
+      "Bash",
+      "LSP",
+      "WebFetch",
+      "WebSearch",
+      "AskUserQuestion"
+    ]
+  },
+  Plan: {
+    description: "Software architect agent for designing implementation plans. Use when you need to plan implementation strategy. Returns step-by-step plans, identifies critical files, considers architectural trade-offs.",
+    prompt: "You are a software architect. Analyze requirements, explore the codebase thoroughly, and design clear implementation plans with specific steps. Do not modify any files.",
+    tools: [
+      "Glob",
+      "Grep",
+      "Read",
+      "Bash",
+      "LSP",
+      "WebFetch",
+      "WebSearch",
+      "AskUserQuestion"
+    ]
+  },
+  "general-purpose": {
+    description: "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. Use for heavy lifting when simpler agents are insufficient.",
+    prompt: "You are a general-purpose assistant. Complete the assigned task thoroughly and report results.",
+    tools: null
+  },
+  "claude-code-guide": {
+    description: "Expert on Claude Code CLI features, hooks, slash commands, MCP servers, settings, IDE integrations. Also covers Claude Agent SDK and Claude API usage.",
+    prompt: "You are a Claude Code expert. Answer questions about Claude Code features, Agent SDK, and API usage accurately. Search documentation and web resources as needed.",
+    tools: ["Glob", "Grep", "Read", "WebFetch", "WebSearch"]
+  },
+  "web-search": {
+    description: "Web researcher for external information not in the codebase. Use for: library docs, API references, error lookups, technology research, best practices. Do NOT use for codebase questions (use Explore) or Claude Code questions (use claude-code-guide).",
+    prompt: `Research specialist. Find accurate information, cite sources, flag uncertainty.
+
+TOOLS:
+- WebSearch: Broad queries, discover sources
+- WebFetch: Extract content from specific URLs
+- Read/Grep/Glob: Check local files for context before searching
+- Bash: Use curl, gh, or CLI tools for direct API access
+- AskUserQuestion: Clarify ambiguous requests BEFORE searching
+
+PROCEDURE:
+1. Parse request: factual lookup | how-to | comparison | troubleshooting
+2. Search: Start specific, broaden if <3 relevant results
+3. Verify: Single authoritative source for facts. Cross-reference for disputed topics.
+4. Synthesize: Answer directly, then evidence.
+
+FAILURE HANDLING:
+- Limit to 5 source pages unless requested otherwise
+- If page inaccessible (paywall/JS-only), note and try alternatives
+- After 3 failed query reformulations, report partial findings and unknowns
+
+STOP CONDITIONS:
+- Factual: Official source found → done
+- How-to: Working solution with docs link → done
+- Troubleshooting: Root cause found OR 3 searches no progress → report gaps
+
+QUALITY:
+- Reject sources >2yr old for fast-moving topics
+- Priority: official docs > GitHub issues > Stack Overflow > blogs
+- On conflict, report both positions with provenance
+
+OUTPUT:
+[Direct answer or "Unable to determine"]
+[Evidence with inline [source](url) citations]
+[Confidence: HIGH (multiple authoritative) | MEDIUM (single authoritative) | LOW (conflicting/unofficial)]`,
+    tools: [
+      "WebSearch",
+      "WebFetch",
+      "Bash",
+      "Grep",
+      "Glob",
+      "Read",
+      "AskUserQuestion"
+    ],
+    model: "sonnet"
+  }
+};
+
+class Semaphore {
+  maxConcurrent;
+  permits;
+  waiting = [];
+  acquired = 0;
+  draining = false;
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent;
+    this.permits = maxConcurrent;
+  }
+  async acquire() {
+    if (this.draining)
+      throw new Error("Semaphore is draining");
+    if (this.permits > 0) {
+      this.permits--;
+      this.acquired++;
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.waiting.push({ resolve, reject });
+    });
+  }
+  release() {
+    this.acquired--;
+    const next = this.waiting.shift();
+    if (next) {
+      this.acquired++;
+      next.resolve();
+    } else {
+      this.permits++;
+    }
+  }
+  drain() {
+    this.draining = true;
+    for (const waiter of this.waiting) {
+      waiter.reject(new Error("Semaphore drained"));
+    }
+    this.waiting = [];
+  }
+  get activeCount() {
+    return this.acquired;
+  }
+  get waitingCount() {
+    return this.waiting.length;
+  }
+}
+function createTask(id, command, cwd, timeout, sessionID, metadata) {
+  let resolveCompletion;
+  const completionPromise = new Promise((r) => {
+    resolveCompletion = r;
+  });
+  return {
+    id,
+    sessionID,
+    command,
+    cwd,
+    status: "pending",
+    stdout: `/tmp/${id}-stdout`,
+    stderr: `/tmp/${id}-stderr`,
+    metadata,
+    createdAt: Date.now(),
+    timeout,
+    abortController: new AbortController,
+    completionPromise,
+    resolveCompletion
+  };
+}
+function matchMetadata(taskMeta, filter) {
+  if (!taskMeta)
+    return false;
+  for (const [key, value] of Object.entries(filter)) {
+    if (taskMeta[key] !== value)
+      return false;
+  }
+  return true;
+}
+
+class TaskHistory {
+  capacity;
+  buffer;
+  head = 0;
+  count = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  push(entry) {
+    this.buffer[this.head] = entry;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity)
+      this.count++;
+  }
+  entries(statusFilter, metadataFilter) {
+    const result = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0;i < this.count; i++) {
+      const idx = (start + i) % this.capacity;
+      const entry = this.buffer[idx];
+      if (!entry)
+        continue;
+      if (statusFilter && entry.status !== statusFilter)
+        continue;
+      if (metadataFilter && !matchMetadata(entry.metadata, metadataFilter))
+        continue;
+      result.push({ ...entry });
+    }
+    return result;
+  }
+  get length() {
+    return this.count;
+  }
+  clear() {
+    this.buffer = new Array(this.capacity);
+    this.head = 0;
+    this.count = 0;
+  }
+}
+
+class TaskRegistry {
+  tasks = new Map;
+  semaphore;
+  nextId = 0;
+  evictionTimers = new Map;
+  accepting = true;
+  options;
+  client;
+  taskHistory;
+  constructor(options = {}) {
+    this.options = {
+      maxConcurrent: options.maxConcurrent ?? 50,
+      taskTTL: options.taskTTL ?? 30000,
+      maxOutputSize: options.maxOutputSize ?? 5 * 1024 * 1024,
+      maxHistory: options.maxHistory ?? 200
+    };
+    this.client = options.client;
+    this.semaphore = new Semaphore(this.options.maxConcurrent);
+    this.taskHistory = new TaskHistory(this.options.maxHistory);
+  }
+  async spawn(command, options = {}) {
+    if (!this.accepting) {
+      throw new Error("Registry is shutting down");
+    }
+    const id = `task-${this.nextId++}`;
+    const cwd = options.cwd ?? process.cwd();
+    const task = createTask(id, command, cwd, options.timeout, options.sessionID, options.metadata);
+    this.tasks.set(id, task);
+    this.executeTask(task);
+    return id;
+  }
+  async executeTask(task) {
+    try {
+      await this.semaphore.acquire();
+    } catch (e) {
+      task.status = "cancelled";
+      task.error = String(e);
+      task.resolveCompletion();
+      return;
+    }
+    try {
+      task.status = "running";
+      task.startedAt = Date.now();
+      const timeoutId = task.timeout ? setTimeout(() => task.abortController.abort(), task.timeout) : null;
+      try {
+        const proc = Bun.spawn(["sh", "-c", task.command], {
+          cwd: task.cwd,
+          stdout: Bun.file(task.stdout),
+          stderr: Bun.file(task.stderr)
+        });
+        task.proc = proc;
+        task.abortController.signal.addEventListener("abort", () => {
+          proc.kill();
+        });
+        const exitCode = await proc.exited;
+        task.exitCode = exitCode;
+        if (task.abortController.signal.aborted) {
+          task.status = "cancelled";
+        } else {
+          task.status = exitCode === 0 ? "completed" : "failed";
+        }
+      } catch (error45) {
+        const errorMsg = `
+[Task execution error: ${String(error45)}]
+`;
+        await appendFile(task.stderr, errorMsg);
+        if (task.abortController.signal.aborted) {
+          task.status = "cancelled";
+        } else {
+          task.status = "failed";
+          task.error = String(error45);
+        }
+      } finally {
+        if (timeoutId)
+          clearTimeout(timeoutId);
+        task.completedAt = Date.now();
+      }
+    } finally {
+      this.semaphore.release();
+      task.resolveCompletion();
+      this.scheduleEviction(task.id);
+      this.notifyCompletion(task);
+    }
+  }
+  notifyCompletion(task) {
+    if (!this.client || !task.sessionID)
+      return;
+    this.client.session.promptAsync({
+      path: { id: task.sessionID },
+      body: {
+        parts: [
+          {
+            type: "text",
+            text: `<task-notification>
+<task-id>${task.id}</task-id>
+<status>${task.status}</status>
+<exit-code>${task.exitCode ?? "N/A"}</exit-code>
+<stdout-path>${task.stdout}</stdout-path>
+<stderr-path>${task.stderr}</stderr-path>
+</task-notification>`
+          }
+        ]
+      }
+    });
+  }
+  scheduleEviction(id) {
+    const existing = this.evictionTimers.get(id);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(() => {
+      const task = this.tasks.get(id);
+      if (task) {
+        this.taskHistory.push({
+          id: task.id,
+          command: task.command.slice(0, 200),
+          status: task.status,
+          exitCode: task.exitCode,
+          metadata: task.metadata,
+          stdout: task.stdout,
+          stderr: task.stderr,
+          createdAt: task.createdAt,
+          startedAt: task.startedAt,
+          completedAt: task.completedAt
+        });
+      }
+      this.tasks.delete(id);
+      this.evictionTimers.delete(id);
+    }, this.options.taskTTL);
+    this.evictionTimers.set(id, timer);
+  }
+  get(id) {
+    const task = this.tasks.get(id);
+    if (task?.completedAt) {
+      this.scheduleEviction(id);
+    }
+    return task;
+  }
+  async wait(id, timeoutMs = 30000) {
+    const task = this.tasks.get(id);
+    if (!task)
+      throw new Error(`Task ${id} not found`);
+    if (task.status !== "pending" && task.status !== "running") {
+      return task;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Task ${id} wait timed out`)), timeoutMs);
+    });
+    await Promise.race([task.completionPromise, timeoutPromise]);
+    return task;
+  }
+  stop(id, signal) {
+    const task = this.tasks.get(id);
+    if (!task)
+      return false;
+    if (task.status === "running" && task.proc) {
+      if (signal === "SIGKILL") {
+        task.proc.kill(9);
+      } else {
+        task.proc.kill();
+      }
+      task.abortController.abort();
+      return true;
+    }
+    if (task.status === "pending") {
+      task.abortController.abort();
+      task.status = "cancelled";
+      task.resolveCompletion();
+      return true;
+    }
+    return false;
+  }
+  list(statusFilter, metadataFilter) {
+    let tasks = Array.from(this.tasks.values());
+    if (statusFilter && statusFilter !== "all") {
+      tasks = tasks.filter((t) => t.status === statusFilter);
+    }
+    if (metadataFilter) {
+      tasks = tasks.filter((t) => matchMetadata(t.metadata, metadataFilter));
+    }
+    return tasks;
+  }
+  async shutdown(gracePeriodMs = 3000) {
+    this.accepting = false;
+    this.semaphore.drain();
+    for (const timer of this.evictionTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.evictionTimers.clear();
+    const runningTasks = [];
+    for (const task of this.tasks.values()) {
+      if (task.status === "running" && task.proc) {
+        task.proc.kill();
+        task.abortController.abort();
+        runningTasks.push(task);
+      }
+    }
+    if (runningTasks.length === 0)
+      return;
+    const graceDeadline = Date.now() + gracePeriodMs;
+    for (const task of runningTasks) {
+      const remaining = graceDeadline - Date.now();
+      if (remaining > 0) {
+        try {
+          await Promise.race([
+            task.completionPromise,
+            new Promise((r) => setTimeout(r, remaining))
+          ]);
+        } catch {}
+      }
+      if (task.status === "running" && task.proc) {
+        task.proc.kill(9);
+      }
+    }
+  }
+  get size() {
+    return this.tasks.size;
+  }
+  get activeCount() {
+    return this.semaphore.activeCount;
+  }
+  get waitingCount() {
+    return this.semaphore.waitingCount;
+  }
+  history(statusFilter, metadataFilter) {
+    return this.taskHistory.entries(statusFilter, metadataFilter);
+  }
+  clear() {
+    for (const timer of this.evictionTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.evictionTimers.clear();
+    this.tasks.clear();
+    this.taskHistory.clear();
+  }
+}
+
 // index.ts
-var CustomToolPlugin = async () => {
+var CustomToolPlugin = async (input) => {
+  const registry2 = new TaskRegistry({
+    maxConcurrent: 50,
+    client: input.client
+  });
   return {
     tool: {
-      DemoTool: tool({
-        description: "A demo tool",
+      Task: tool({
+        description: `Spawn background task.
+
+Returns:
+- taskId: unique identifier
+- stdout/stderr: file paths (LIVE - readable during execution, not just after)
+
+You will receive a notification when it completes.`,
         args: {
-          input: tool.schema.string().describe("Input to process")
+          command: tool.schema.string().describe("Shell command to execute"),
+          cwd: tool.schema.string().optional().describe("Working directory"),
+          timeout: tool.schema.number().optional().describe("Timeout in milliseconds"),
+          metadata: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Key-value metadata tags for filtering")
+        },
+        async execute(args, context) {
+          const id = await registry2.spawn(args.command, {
+            cwd: args.cwd,
+            timeout: args.timeout,
+            sessionID: context.sessionID,
+            metadata: args.metadata
+          });
+          const task = registry2.get(id);
+          return JSON.stringify({
+            taskId: id,
+            stdout: task?.stdout,
+            stderr: task?.stderr,
+            message: `Task ${id} spawned. You will receive a notification when complete.`
+          });
+        }
+      }),
+      TaskStop: tool({
+        description: "Stop/cancel a running background task",
+        args: {
+          taskId: tool.schema.string().describe("Task ID to stop"),
+          signal: tool.schema.enum(["SIGTERM", "SIGKILL"]).optional().describe("Signal to send (default SIGTERM)")
         },
         async execute(args) {
-          return `Processed: ${args.input}`;
+          const stopped = registry2.stop(args.taskId, args.signal);
+          return JSON.stringify({ success: stopped, taskId: args.taskId });
+        }
+      }),
+      TaskList: tool({
+        description: "List background tasks with status, output paths, and metadata. Supports filtering by status and metadata. Use includeHistory to see evicted tasks.",
+        args: {
+          status: tool.schema.enum([
+            "all",
+            "running",
+            "completed",
+            "failed",
+            "pending",
+            "cancelled"
+          ]).optional().describe("Filter by status"),
+          metadata: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Filter by metadata key-value pairs (all must match)"),
+          includeHistory: tool.schema.boolean().optional().describe("Include evicted tasks from history buffer (default false)")
+        },
+        async execute(args) {
+          const tasks = registry2.list(args.status, args.metadata);
+          const result = {
+            count: tasks.length,
+            tasks: tasks.map((t) => ({
+              id: t.id,
+              status: t.status,
+              command: t.command.slice(0, 100),
+              stdout: t.stdout,
+              stderr: t.stderr,
+              metadata: t.metadata,
+              createdAt: t.createdAt,
+              duration: t.completedAt && t.startedAt ? t.completedAt - t.startedAt : undefined
+            }))
+          };
+          if (args.includeHistory) {
+            const history = registry2.history(args.status, args.metadata);
+            result.history = history;
+            result.historyCount = history.length;
+          }
+          return JSON.stringify(result);
+        }
+      }),
+      AgentTask: tool({
+        description: "Spawn a Claude agent to work on a subtask in the background. Available agents: Explore (codebase search), Plan (architecture design), general-purpose (complex multi-step tasks), claude-code-guide (Claude Code/SDK questions), web-search (research external information). You will receive a notification when complete.",
+        args: {
+          agent: tool.schema.enum([
+            "Explore",
+            "Plan",
+            "general-purpose",
+            "claude-code-guide",
+            "web-search"
+          ]).describe("Agent type to spawn"),
+          prompt: tool.schema.string().describe("Task prompt for the agent"),
+          cwd: tool.schema.string().optional().describe("Working directory"),
+          timeout: tool.schema.number().optional().describe("Timeout in milliseconds")
+        },
+        async execute(args, context) {
+          const agentType = args.agent;
+          const config2 = AGENT_CONFIGS[agentType];
+          const agentDef = {
+            [agentType]: {
+              description: config2.description,
+              prompt: config2.prompt
+            }
+          };
+          const cmdParts = [
+            "claude",
+            "--verbose",
+            "--strict-mcp-config",
+            "--mcp-config",
+            '{"mcpServers":{}}',
+            "--allow-dangerously-skip-permissions",
+            "--agents",
+            JSON.stringify(agentDef),
+            "--agent",
+            agentType
+          ];
+          if (config2.tools !== null) {
+            cmdParts.push("--tools", config2.tools.join(","));
+          }
+          cmdParts.push("--output-format", "stream-json", "--print", "-p", args.prompt);
+          const command = cmdParts.map((p) => p.includes(" ") || p.includes('"') ? `'${p}'` : p).join(" ");
+          const id = await registry2.spawn(command, {
+            cwd: args.cwd,
+            timeout: args.timeout,
+            sessionID: context.sessionID
+          });
+          return JSON.stringify({
+            taskId: id,
+            agent: agentType,
+            message: `Agent ${agentType} spawned as ${id}. You will receive a notification when complete.`
+          });
         }
       })
     }
   };
 };
+var opencode_task_default = CustomToolPlugin;
 export {
+  opencode_task_default as default,
   CustomToolPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-task",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.js",
   "files": ["dist"],
@@ -17,6 +17,7 @@
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
     "@opencode-ai/plugin": "latest",
+    "@types/bun": "latest",
     "typescript": "^5.0.0"
   }
 }