micode 0.7.0 → 0.7.2

package/src/tools/background-task/tools.ts

@@ -0,0 +1,145 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import type { BackgroundTaskManager } from "./manager";
+
+export function createBackgroundTaskTools(manager: BackgroundTaskManager) {
+  const background_task = tool({
+    description: `Launch a task to run in the background using a subagent.
+The task runs independently while you continue working.
+Use background_output to check progress or get results when complete.
+Useful for: parallel research, concurrent implementation, async reviews.`,
+    args: {
+      description: tool.schema.string().describe("Short description of the task (shown in status)"),
+      prompt: tool.schema.string().describe("Full prompt/instructions for the background agent"),
+      agent: tool.schema.string().describe("Agent to use (e.g., 'codebase-analyzer', 'implementer')"),
+    },
+    execute: async (args, ctx) => {
+      try {
+        const task = await manager.launch({
+          description: args.description,
+          prompt: args.prompt,
+          agent: args.agent,
+          parentSessionID: ctx.sessionID,
+          parentMessageID: ctx.messageID || "",
+        });
+
+        return `## Background Task Launched
+
+| Field | Value |
+|-------|-------|
+| Task ID | ${task.id} |
+| Agent | ${args.agent} |
+| Status | RUNNING |
+
+Use \`background_output\` with task_id="${task.id}" to check progress or get results.`;
+      } catch (error) {
+        return `Failed to launch background task: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+  });
+
+  const background_output = tool({
+    description: `Get status or results from a background task.
+Returns immediately with current status. Use background_list to poll for completion.`,
+    args: {
+      task_id: tool.schema.string().describe("ID of the task to check (e.g., 'bg_abc12345')"),
+    },
+    execute: async (args) => {
+      const { task_id } = args;
+
+      const task = manager.getTask(task_id);
+      if (!task) {
+        return `Task not found: ${task_id}`;
+      }
+
+      // Format status
+      let output = manager.formatTaskStatus(task);
+
+      // Include result if completed
+      if (task.status === "completed") {
+        const result = await manager.getTaskResult(task_id);
+        if (result) {
+          output += `\n### Result\n${result}\n`;
+        }
+      }
+
+      return output;
+    },
+  });
+
+  const background_cancel = tool({
+    description: `Cancel a running background task or all tasks.`,
+    args: {
+      task_id: tool.schema.string().optional().describe("ID of the task to cancel (omit to cancel all)"),
+      all: tool.schema.boolean().optional().describe("Cancel all running tasks (default: false)"),
+    },
+    execute: async (args) => {
+      const { task_id, all = false } = args;
+
+      if (all) {
+        const cancelled = await manager.cancelAll();
+        return `Cancelled ${cancelled} running task(s).`;
+      }
+
+      if (!task_id) {
+        return "Provide task_id or set all=true to cancel tasks.";
+      }
+
+      const success = await manager.cancel(task_id);
+      if (success) {
+        return `Task ${task_id} cancelled.`;
+      }
+
+      return `Could not cancel task ${task_id}. It may already be completed or not exist.`;
+    },
+  });
+
+  const background_list = tool({
+    description: `List all background tasks and their status.`,
+    args: {},
+    execute: async () => {
+      // Refresh status of running tasks before returning
+      await manager.refreshTaskStatus();
+      const tasks = manager.getAllTasks();
+
+      if (tasks.length === 0) {
+        return "No background tasks.";
+      }
+
+      const completed = tasks.filter((t) => t.status === "completed").length;
+      const errored = tasks.filter((t) => t.status === "error").length;
+      const running = tasks.filter((t) => t.status === "running").length;
+      const total = tasks.length;
+      const allDone = running === 0;
+
+      let output = "## Background Tasks\n\n";
+      output += `**Status: ${completed + errored}/${total} done${allDone ? " ✓ ALL COMPLETE" : ` (${running} still running)`}**\n\n`;
+      output += "| ID | Description | Agent | Status | Duration | Session |\n";
+      output += "|----|-------------|-------|--------|----------|---------|";
+
+      for (const task of tasks) {
+        const duration = task.completedAt
+          ? `${Math.round((task.completedAt.getTime() - task.startedAt.getTime()) / 1000)}s`
+          : `${Math.round((Date.now() - task.startedAt.getTime()) / 1000)}s`;
+
+        // Show session status for debugging
+        const sessionStatus = (task as { _sessionStatus?: string })._sessionStatus || "?";
+        const statusDisplay = task.status === "running" ? `${task.status} (${sessionStatus})` : task.status;
+
+        output += `| ${task.id} | ${task.description} | ${task.agent} | ${statusDisplay} | ${duration} | ${task.sessionID} |\n`;
+      }
+
+      if (allDone) {
+        output += "\n**→ All tasks complete. Proceed to collect results with background_output.**";
+      }
+
+      return output;
+    },
+  });
+
+  return {
+    background_task,
+    background_output,
+    background_cancel,
+    background_list,
+  };
+}

package/src/tools/background-task/types.ts

@@ -0,0 +1,68 @@
+export interface BackgroundTask {
+  id: string;
+  sessionID: string;
+  parentSessionID: string;
+  parentMessageID: string;
+  description: string;
+  prompt: string;
+  agent: string;
+  status: "running" | "completed" | "error" | "cancelled";
+  startedAt: Date;
+  completedAt?: Date;
+  result?: string;
+  error?: string;
+  progress?: {
+    toolCalls: number;
+    lastTool?: string;
+    lastUpdate: Date;
+  };
+}
+
+export interface BackgroundTaskInput {
+  description: string;
+  prompt: string;
+  agent: string;
+  parentSessionID: string;
+  parentMessageID: string;
+}
+
+// API Response Types - SDK wraps responses in { data: T } format
+export interface SessionCreateResponse {
+  data?: {
+    id?: string;
+  };
+}
+
+// SessionStatus from OpenCode SDK - status is a discriminated union with 'type' field
+export type SessionStatus =
+  | { type: "idle" }
+  | { type: "retry"; attempt: number; message: string; next: number }
+  | { type: "busy" };
+
+// session.status() returns { data: map of sessionID -> SessionStatus }
+export interface SessionStatusResponse {
+  data?: {
+    [sessionID: string]: SessionStatus;
+  };
+}
+
+export interface MessagePart {
+  type: string;
+  text?: string;
+}
+
+export interface MessageInfo {
+  role?: "user" | "assistant";
+  sessionID?: string;
+  type?: string;
+  name?: string;
+}
+
+export interface SessionMessage {
+  info?: MessageInfo;
+  parts?: MessagePart[];
+}
+
+export interface SessionMessagesResponse {
+  data?: SessionMessage[];
+}

package/src/tools/btca/index.ts

@@ -0,0 +1,82 @@
+import { spawn, which } from "bun";
+import { tool } from "@opencode-ai/plugin/tool";
+
+/**
+ * Check if btca CLI is available on the system.
+ * Returns installation instructions if not found.
+ */
+export async function checkBtcaAvailable(): Promise<{ available: boolean; message?: string }> {
+  const btcaPath = which("btca");
+  if (btcaPath) {
+    return { available: true };
+  }
+  return {
+    available: false,
+    message:
+      "btca CLI not found. Library source code search will not work.\n" +
+      "Install from: https://github.com/davis7dotsh/better-context\n" +
+      "  bun add -g btca",
+  };
+}
+
+const BTCA_TIMEOUT_MS = 120000; // 2 minutes for long clones
+
+async function runBtca(args: string[]): Promise<{ output: string; error?: string }> {
+  try {
+    const proc = spawn(["btca", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Create timeout promise
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error("btca command timed out after 2 minutes"));
+      }, BTCA_TIMEOUT_MS);
+    });
+
+    // Race between process completion and timeout
+    const [stdout, stderr, exitCode] = await Promise.race([
+      Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]),
+      timeoutPromise,
+    ]);
+
+    if (exitCode !== 0) {
+      const errorMsg = stderr.trim() || `Exit code ${exitCode}`;
+      return { output: "", error: errorMsg };
+    }
+
+    return { output: stdout.trim() };
+  } catch (e) {
+    const err = e as Error;
+    if (err.message?.includes("ENOENT")) {
+      return {
+        output: "",
+        error:
+          "btca CLI not found. Install from: https://github.com/davis7dotsh/better-context\n" + "  bun add -g btca",
+      };
+    }
+    return { output: "", error: err.message };
+  }
+}
+
+export const btca_ask = tool({
+  description:
+    "Ask questions about library/framework source code using btca. " +
+    "Clones repos locally and searches source code to answer questions. " +
+    "Use for understanding library internals, finding implementation details, or debugging.",
+  args: {
+    tech: tool.schema.string().describe("Resource name configured in btca (e.g., 'react', 'express')"),
+    question: tool.schema.string().describe("Question to ask about the library source code"),
+  },
+  execute: async (args) => {
+    const result = await runBtca(["ask", "-t", args.tech, "-q", args.question]);
+
+    if (result.error) {
+      return `Error: ${result.error}`;
+    }
+
+    return result.output || "No answer found";
+  },
+});

package/src/tools/look-at.ts

@@ -0,0 +1,210 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { readFileSync, statSync } from "node:fs";
+import { extname, basename } from "node:path";
+
+// File size threshold for triggering extraction (100KB)
+const LARGE_FILE_THRESHOLD = 100 * 1024;
+
+// Max lines to return without extraction
+const MAX_LINES_WITHOUT_EXTRACT = 200;
+
+// Supported file types for smart extraction
+const EXTRACTABLE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml",
+];
+
+function extractStructure(content: string, ext: string): string {
+  const lines = content.split("\n");
+
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+      return extractTypeScriptStructure(lines);
+    case ".py":
+      return extractPythonStructure(lines);
+    case ".go":
+      return extractGoStructure(lines);
+    case ".md":
+      return extractMarkdownStructure(lines);
+    case ".json":
+      return extractJsonStructure(content);
+    case ".yaml":
+    case ".yml":
+      return extractYamlStructure(lines);
+    default:
+      return extractGenericStructure(lines);
+  }
+}
+
+function extractTypeScriptStructure(lines: string[]): string {
+  const output: string[] = ["## Structure\n"];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Capture exports, classes, interfaces, types, functions
+    if (
+      trimmed.startsWith("export ") ||
+      trimmed.startsWith("class ") ||
+      trimmed.startsWith("interface ") ||
+      trimmed.startsWith("type ") ||
+      trimmed.startsWith("function ") ||
+      trimmed.startsWith("const ") ||
+      trimmed.startsWith("async function ")
+    ) {
+      // Get the signature (first line only for multi-line)
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+
+  return output.join("\n");
+}
+
+function extractPythonStructure(lines: string[]): string {
+  const output: string[] = ["## Structure\n"];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Capture classes, functions, decorators
+    if (
+      trimmed.startsWith("class ") ||
+      trimmed.startsWith("def ") ||
+      trimmed.startsWith("async def ") ||
+      trimmed.startsWith("@")
+    ) {
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+
+  return output.join("\n");
+}
+
+function extractGoStructure(lines: string[]): string {
+  const output: string[] = ["## Structure\n"];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Capture types, functions, methods
+    if (trimmed.startsWith("type ") || trimmed.startsWith("func ") || trimmed.startsWith("package ")) {
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
+      output.push(`Line ${i + 1}: ${signature}`);
+    }
+  }
+
+  return output.join("\n");
+}
+
+function extractMarkdownStructure(lines: string[]): string {
+  const output: string[] = ["## Outline\n"];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Capture headings
+    if (line.startsWith("#")) {
+      output.push(`Line ${i + 1}: ${line}`);
+    }
+  }
+
+  return output.join("\n");
+}
+
+function extractJsonStructure(content: string): string {
+  try {
+    const obj = JSON.parse(content);
+    const keys = Object.keys(obj);
+    return `## Top-level keys (${keys.length})\n\n${keys.slice(0, 50).join(", ")}${keys.length > 50 ? "..." : ""}`;
+  } catch {
+    return "## Invalid JSON";
+  }
+}
+
+function extractYamlStructure(lines: string[]): string {
+  const output: string[] = ["## Top-level keys\n"];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Top-level keys (no indentation)
+    if (line.match(/^[a-zA-Z_][a-zA-Z0-9_]*:/)) {
+      output.push(`Line ${i + 1}: ${line}`);
+    }
+  }
+
+  return output.join("\n");
+}
+
+function extractGenericStructure(lines: string[]): string {
+  // For unknown files, just show first/last lines and line count
+  const total = lines.length;
+  const preview = lines.slice(0, 10).join("\n");
+  const tail = lines.slice(-5).join("\n");
+
+  return `## File Preview (${total} lines)\n\n### First 10 lines:\n${preview}\n\n### Last 5 lines:\n${tail}`;
+}
+
+export const look_at = tool({
+  description: `Extract key information from a file to save context tokens.
+For large files, returns structure/outline instead of full content.
+Use when you need to understand a file without loading all content.
+Ideal for: large files, getting file structure, quick overview.`,
+  args: {
+    filePath: tool.schema.string().describe("Path to the file"),
+    extract: tool.schema
+      .string()
+      .optional()
+      .describe("What to extract: 'structure', 'imports', 'exports', 'all' (default: auto)"),
+  },
+  execute: async (args) => {
+    try {
+      const stats = statSync(args.filePath);
+      const ext = extname(args.filePath).toLowerCase();
+      const name = basename(args.filePath);
+
+      // Read file
+      const content = readFileSync(args.filePath, "utf-8");
+      const lines = content.split("\n");
+
+      // For small files, return full content
+      if (stats.size < LARGE_FILE_THRESHOLD && lines.length <= MAX_LINES_WITHOUT_EXTRACT) {
+        return `## ${name} (${lines.length} lines)\n\n${content}`;
+      }
+
+      // For large files, extract structure
+      let output = `## ${name}\n`;
+      output += `**Size**: ${Math.round(stats.size / 1024)}KB | **Lines**: ${lines.length}\n\n`;
+
+      if (EXTRACTABLE_EXTENSIONS.includes(ext)) {
+        output += extractStructure(content, ext);
+      } else {
+        output += extractGenericStructure(lines);
+      }
+
+      output += `\n\n---\n*Use Read tool with line offset/limit for specific sections*`;
+
+      return output;
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  },
+});

package/src/tools/pty/buffer.ts

@@ -0,0 +1,49 @@
+// src/tools/pty/buffer.ts
+import type { SearchMatch } from "./types";
+
+const parsed = parseInt(process.env.PTY_MAX_BUFFER_LINES || "50000", 10);
+const DEFAULT_MAX_LINES = isNaN(parsed) ? 50000 : parsed;
+
+export class RingBuffer {
+  private lines: string[] = [];
+  private maxLines: number;
+
+  constructor(maxLines: number = DEFAULT_MAX_LINES) {
+    this.maxLines = maxLines;
+  }
+
+  append(data: string): void {
+    const newLines = data.split("\n");
+    for (const line of newLines) {
+      this.lines.push(line);
+      if (this.lines.length > this.maxLines) {
+        this.lines.shift();
+      }
+    }
+  }
+
+  read(offset: number = 0, limit?: number): string[] {
+    const start = Math.max(0, offset);
+    const end = limit !== undefined ? start + limit : this.lines.length;
+    return this.lines.slice(start, end);
+  }
+
+  search(pattern: RegExp): SearchMatch[] {
+    const matches: SearchMatch[] = [];
+    for (let i = 0; i < this.lines.length; i++) {
+      const line = this.lines[i];
+      if (line !== undefined && pattern.test(line)) {
+        matches.push({ lineNumber: i + 1, text: line });
+      }
+    }
+    return matches;
+  }
+
+  get length(): number {
+    return this.lines.length;
+  }
+
+  clear(): void {
+    this.lines = [];
+  }
+}

package/src/tools/pty/index.ts

@@ -0,0 +1,34 @@
+// src/tools/pty/index.ts
+export { PTYManager } from "./manager";
+export { RingBuffer } from "./buffer";
+export { createPtySpawnTool } from "./tools/spawn";
+export { createPtyWriteTool } from "./tools/write";
+export { createPtyReadTool } from "./tools/read";
+export { createPtyListTool } from "./tools/list";
+export { createPtyKillTool } from "./tools/kill";
+export type {
+  PTYSession,
+  PTYSessionInfo,
+  PTYStatus,
+  SpawnOptions,
+  ReadResult,
+  SearchMatch,
+  SearchResult,
+} from "./types";
+
+import type { PTYManager } from "./manager";
+import { createPtySpawnTool } from "./tools/spawn";
+import { createPtyWriteTool } from "./tools/write";
+import { createPtyReadTool } from "./tools/read";
+import { createPtyListTool } from "./tools/list";
+import { createPtyKillTool } from "./tools/kill";
+
+export function createPtyTools(manager: PTYManager) {
+  return {
+    pty_spawn: createPtySpawnTool(manager),
+    pty_write: createPtyWriteTool(manager),
+    pty_read: createPtyReadTool(manager),
+    pty_list: createPtyListTool(manager),
+    pty_kill: createPtyKillTool(manager),
+  };
+}