goatcode-sh 0.0.1 → 0.1.2

package/src/tools/background-task/output/handler.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { BackgroundTask, BackgroundAgentManager } from "../../../runtime";
+import { handleBackgroundOutput } from "./handler";
+
+function makeTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
+  return {
+    id: "task-42",
+    status: "running",
+    prompt: "do work",
+    model: "claude-3",
+    createdAt: Date.now() - 10000,
+    startedAt: Date.now() - 9000,
+    ...overrides,
+  };
+}
+
+function makeManager(task: BackgroundTask | undefined): BackgroundAgentManager {
+  return {
+    get: mock((_id: string) => task),
+    getAll: mock(() => (task ? [task] : [])),
+    cancel: mock(async () => {}),
+    launch: mock(async () => task!),
+    complete: mock(() => {}),
+    fail: mock(() => {}),
+  } as unknown as BackgroundAgentManager;
+}
+
+describe("handleBackgroundOutput", () => {
+  describe("#given a nonexistent task", () => {
+    describe("#when called with unknown task_id", () => {
+      it("#then returns task not found message", async () => {
+        const manager = makeManager(undefined);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "no-such-task" });
+
+        expect(result).toContain("Task not found: no-such-task");
+      });
+    });
+  });
+
+  describe("#given a queued task", () => {
+    describe("#when called without block", () => {
+      it("#then returns queued status info", async () => {
+        const task = makeTask({ status: "queued", startedAt: undefined });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "task-42" });
+
+        expect(result).toContain("queued");
+        expect(result).toContain("task-42");
+      });
+    });
+  });
+
+  describe("#given a completed task", () => {
+    describe("#when called", () => {
+      it("#then returns the completed result", async () => {
+        const task = makeTask({ status: "completed", result: "final answer: 42" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "task-42" });
+
+        expect(result).toContain("completed");
+        expect(result).toContain("final answer: 42");
+      });
+    });
+  });
+
+  describe("#given a failed task", () => {
+    describe("#when called", () => {
+      it("#then returns the error details", async () => {
+        const task = makeTask({ status: "failed", error: "rate limit exceeded" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "task-42" });
+
+        expect(result).toContain("failed");
+        expect(result).toContain("rate limit exceeded");
+      });
+    });
+  });
+
+  describe("#given a cancelled task", () => {
+    describe("#when called", () => {
+      it("#then returns cancelled message", async () => {
+        const task = makeTask({ status: "cancelled" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "task-42" });
+
+        expect(result).toContain("cancelled");
+      });
+    });
+  });
+
+  describe("#given a running task with no startedAt", () => {
+    describe("#when called without block", () => {
+      it("#then returns running status with unknown elapsed", async () => {
+        const task = makeTask({ status: "running", startedAt: undefined });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundOutput(manager, { task_id: "task-42" });
+
+        expect(result).toContain("running");
+        expect(result).toContain("unknown");
+      });
+    });
+  });
+
+  describe("#given timeout capping", () => {
+    describe("#when timeout exceeds 600000ms", () => {
+      it("#then caps at 600000ms and still returns a result", async () => {
+        let callCount = 0;
+        const task = makeTask({ status: "running" });
+
+        const manager = {
+          get: mock((_id: string) => {
+            callCount++;
+            if (callCount >= 2) {
+              return makeTask({ status: "completed", result: "done" });
+            }
+            return task;
+          }),
+          getAll: mock(() => [task]),
+          cancel: mock(async () => {}),
+          launch: mock(async () => task),
+          complete: mock(() => {}),
+          fail: mock(() => {}),
+        } as unknown as BackgroundAgentManager;
+
+        const result = await handleBackgroundOutput(manager, {
+          task_id: "task-42",
+          block: true,
+          timeout: 999_999_999,
+        });
+
+        expect(result).toContain("completed");
+        expect(result).toContain("done");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,93 @@
+import type { BackgroundAgentManager, BackgroundTask } from "../../../runtime";
+import { log } from "../../../shared/logger";
+import type { BackgroundOutputArgs } from "./types";
+
+function formatElapsed(startedAt: number): string {
+  const elapsedMs = Date.now() - startedAt;
+  const seconds = Math.floor(elapsedMs / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+function formatRunningStatus(task: BackgroundTask): string {
+  const elapsed = task.startedAt ? formatElapsed(task.startedAt) : "unknown";
+  return `Task ${task.id} is ${task.status} (elapsed: ${elapsed}). Check back later or use block=true to wait.`;
+}
+
+function formatCompletedResult(task: BackgroundTask): string {
+  const result = task.result ?? "(no output)";
+  return `Task ${task.id} completed.\n\n${result}`;
+}
+
+function formatFailedStatus(task: BackgroundTask): string {
+  const error = task.error ?? "(no error details)";
+  return `Task ${task.id} failed: ${error}`;
+}
+
+function formatCancelledStatus(task: BackgroundTask): string {
+  return `Task ${task.id} was cancelled.`;
+}
+
+function formatTaskOutput(task: BackgroundTask): string {
+  switch (task.status) {
+    case "completed":
+      return formatCompletedResult(task);
+    case "failed":
+      return formatFailedStatus(task);
+    case "cancelled":
+      return formatCancelledStatus(task);
+    case "queued":
+      return `Task ${task.id} is queued and waiting to start.`;
+    case "running":
+      return formatRunningStatus(task);
+  }
+}
+
+async function waitForCompletion(
+  manager: BackgroundAgentManager,
+  taskId: string,
+  timeoutMs: number,
+): Promise<BackgroundTask | undefined> {
+  const deadline = Date.now() + timeoutMs;
+  const pollIntervalMs = 1000;
+
+  while (Date.now() < deadline) {
+    await new Promise<void>((resolve) => setTimeout(resolve, pollIntervalMs));
+    const current = manager.get(taskId);
+    if (!current) return undefined;
+    if (current.status !== "queued" && current.status !== "running") return current;
+  }
+
+  return manager.get(taskId);
+}
+
+export async function handleBackgroundOutput(
+  manager: BackgroundAgentManager,
+  args: BackgroundOutputArgs,
+): Promise<string> {
+  log("[background-output] called", { task_id: args.task_id, block: args.block });
+
+  const task = manager.get(args.task_id);
+  if (!task) {
+    return `Task not found: ${args.task_id}`;
+  }
+
+  const isActive = task.status === "queued" || task.status === "running";
+
+  if (args.block === true && isActive) {
+    const timeoutMs = Math.min(args.timeout ?? 60_000, 600_000);
+    const resolved = await waitForCompletion(manager, args.task_id, timeoutMs);
+    if (!resolved) {
+      return `Task ${args.task_id} was deleted while waiting.`;
+    }
+    const output = formatTaskOutput(resolved);
+    if (resolved.status === "queued" || resolved.status === "running") {
+      return `${output}\n\n> Timed out waiting after ${timeoutMs}ms. Task is still running.`;
+    }
+    return output;
+  }
+
+  return formatTaskOutput(task);
+}

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

@@ -0,0 +1,60 @@
+import { tool } from "@opencode-ai/plugin";
+import { getBackgroundAgent } from "../../../runtime";
+import { definePlugin } from "../../../plugin-api/define-plugin";
+import { handleBackgroundOutput } from "./handler";
+import type { BackgroundOutputArgs } from "./types";
+
+const backgroundOutputTool = tool({
+  description:
+    "Get output from background task. Use full_session=true to fetch session messages with filters. System notifies on completion, so block=true rarely needed. - Timeout values are in milliseconds (ms), NOT seconds.",
+  args: {
+    task_id: tool.schema.string().describe("Task ID to get output from"),
+    block: tool.schema
+      .boolean()
+      .optional()
+      .describe(
+        "Wait for completion (default: false). System notifies when done, so blocking is rarely needed.",
+      ),
+    timeout: tool.schema
+      .number()
+      .optional()
+      .describe("Max wait time in ms (default: 60000, max: 600000)"),
+    full_session: tool.schema
+      .boolean()
+      .optional()
+      .describe("Return full session messages with filters (default: false)"),
+    include_thinking: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include thinking/reasoning parts in full_session output (default: false)"),
+    message_limit: tool.schema
+      .number()
+      .optional()
+      .describe("Max messages to return (capped at 100)"),
+    since_message_id: tool.schema
+      .string()
+      .optional()
+      .describe("Return messages after this message ID (exclusive)"),
+    include_tool_results: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include tool results in full_session output (default: false)"),
+    thinking_max_chars: tool.schema
+      .number()
+      .optional()
+      .describe("Max characters for thinking content (default: 2000)"),
+  },
+  async execute(args: BackgroundOutputArgs) {
+    const { manager } = getBackgroundAgent();
+    return handleBackgroundOutput(manager, args);
+  },
+});
+
+export default definePlugin({
+  name: "background-output",
+  version: "1.0.0",
+  dependencies: ["delegate-task"],
+  tools: {
+    background_output: backgroundOutputTool,
+  },
+});

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

@@ -0,0 +1,11 @@
+export interface BackgroundOutputArgs {
+  task_id: string;
+  block?: boolean;
+  timeout?: number;
+  full_session?: boolean;
+  include_thinking?: boolean;
+  message_limit?: number;
+  since_message_id?: string;
+  include_tool_results?: boolean;
+  thinking_max_chars?: number;
+}

package/src/tools/bridge.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "bun:test";
+import { buildToolHook } from "./bridge";
+import type { PluginToolContribution } from "../types/tool";
+
+function makeToolContribution(): PluginToolContribution {
+  return { execute: async () => "ok" } as unknown as PluginToolContribution;
+}
+
+describe("buildToolHook", () => {
+  describe("#given a tools record with one entry", () => {
+    describe("#when buildToolHook is called", () => {
+      it("#then it returns the tools record", () => {
+        const tools: Record<string, PluginToolContribution> = {
+          testTool: makeToolContribution(),
+        };
+
+        const result = buildToolHook(tools);
+
+        expect(result).toEqual(tools);
+      });
+    });
+  });
+
+  describe("#given an empty tools record", () => {
+    describe("#when buildToolHook is called", () => {
+      it("#then it returns undefined", () => {
+        const tools: Record<string, PluginToolContribution> = {};
+
+        const result = buildToolHook(tools);
+
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given a tools record with multiple entries", () => {
+    describe("#when buildToolHook is called", () => {
+      it("#then all entries are present in the result", () => {
+        const tools: Record<string, PluginToolContribution> = {
+          tool1: makeToolContribution(),
+          tool2: makeToolContribution(),
+          tool3: makeToolContribution(),
+        };
+
+        const result = buildToolHook(tools);
+
+        expect(result).toEqual(tools);
+        expect(Object.keys(result!)).toHaveLength(3);
+        expect(result).toHaveProperty("tool1");
+        expect(result).toHaveProperty("tool2");
+        expect(result).toHaveProperty("tool3");
+      });
+    });
+  });
+});

package/src/tools/bridge.ts

@@ -0,0 +1,13 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { PluginToolContribution } from "../types/tool";
+
+/**
+ * Convert the aggregated tools record into the SDK tool hook shape.
+ * Returns undefined if no tools are registered.
+ */
+export function buildToolHook(tools: Record<string, PluginToolContribution>): Hooks["tool"] {
+  if (Object.keys(tools).length === 0) {
+    return undefined;
+  }
+  return tools;
+}

package/src/tools/builtin-tools.ts

@@ -0,0 +1,54 @@
+import type { PluginDefinition } from "../types/plugin";
+import { grepPlugin } from "./grep";
+import { globPlugin } from "./glob";
+import { hashlineEditPlugin } from "./hashline-edit";
+import { lookAtPlugin } from "./look-at";
+import { skillPlugin } from "./skill";
+// skill_mcp is intentionally excluded — it requires ctx.client MCP integration
+// that is not yet available in the tool execute context. Re-enable once implemented.
+// import { skillMcpPlugin } from "./skill-mcp"
+import { delegateTaskPlugin } from "./delegate-task";
+import {
+  lspGotoDefinitionPlugin,
+  lspFindReferencesPlugin,
+  lspSymbolsPlugin,
+  lspDiagnosticsPlugin,
+  lspPrepareRenamePlugin,
+  lspRenamePlugin,
+} from "./lsp";
+import { astGrepSearchPlugin, astGrepReplacePlugin } from "./ast-grep";
+import { backgroundOutputPlugin, backgroundCancelPlugin } from "./background-task";
+import {
+  sessionListPlugin,
+  sessionReadPlugin,
+  sessionSearchPlugin,
+  sessionInfoPlugin,
+} from "./session-manager";
+import { taskCreatePlugin, taskListPlugin, taskGetPlugin, taskUpdatePlugin } from "./task";
+
+export const BUILTIN_TOOL_PLUGINS: PluginDefinition[] = [
+  grepPlugin,
+  globPlugin,
+  hashlineEditPlugin,
+  lookAtPlugin,
+  skillPlugin,
+  delegateTaskPlugin,
+  lspGotoDefinitionPlugin,
+  lspFindReferencesPlugin,
+  lspSymbolsPlugin,
+  lspDiagnosticsPlugin,
+  lspPrepareRenamePlugin,
+  lspRenamePlugin,
+  astGrepSearchPlugin,
+  astGrepReplacePlugin,
+  backgroundOutputPlugin,
+  backgroundCancelPlugin,
+  sessionListPlugin,
+  sessionReadPlugin,
+  sessionSearchPlugin,
+  sessionInfoPlugin,
+  taskCreatePlugin,
+  taskListPlugin,
+  taskGetPlugin,
+  taskUpdatePlugin,
+];

package/src/tools/code-search.test.ts

@@ -0,0 +1,203 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { astGrepSearchPlugin } from "./ast-grep/search/plugin";
+import { createAstGrepSearchTool } from "./ast-grep/search/handler";
+import { astGrepReplacePlugin } from "./ast-grep/replace/plugin";
+import { createAstGrepReplaceTool } from "./ast-grep/replace/handler";
+import { grepPlugin } from "./grep/plugin";
+import { createGrepTool } from "./grep/handler";
+import { globPlugin } from "./glob/plugin";
+import { createGlobTool } from "./glob/handler";
+
+type ToolContext = Parameters<ToolDefinition["execute"]>[1];
+
+function createToolContext(directory: string): ToolContext {
+  return {
+    sessionID: "session-1",
+    messageID: "message-1",
+    agent: "agent-1",
+    directory,
+    worktree: directory,
+    abort: new AbortController().signal,
+    metadata: () => {},
+    ask: async () => {},
+  };
+}
+
+describe("code search tool micro-plugins", () => {
+  describe("#given ast-grep plugins", () => {
+    describe("#when inspecting exposed tool names", () => {
+      it("#then they expose ast_grep_search and ast_grep_replace", () => {
+        expect(astGrepSearchPlugin.tools).toHaveProperty("ast_grep_search");
+        expect(astGrepReplacePlugin.tools).toHaveProperty("ast_grep_replace");
+      });
+    });
+
+    describe("#when ast_grep_search executes with mocked shell runner", () => {
+      it("#then it runs sg scan and returns runner output", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async () => ({
+          exitCode: 0,
+          stdout: "src/main.ts:1:console.log(message)",
+          stderr: "",
+        }));
+        runner.mockImplementation(async (command: string[]) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "src/main.ts:1:console.log(message)",
+            stderr: "",
+          };
+        });
+        const tool = createAstGrepSearchTool(runner);
+
+        const output = await tool.execute(
+          {
+            pattern: "console.log($MSG)",
+            lang: "typescript",
+            paths: ["src"],
+            globs: ["*.ts"],
+            context: 1,
+          },
+          createToolContext("/repo"),
+        );
+
+        expect(runner).toHaveBeenCalledTimes(1);
+        expect(capturedCommand).toEqual([
+          "sg",
+          "scan",
+          "--pattern",
+          "console.log($MSG)",
+          "--lang",
+          "typescript",
+          "--glob",
+          "*.ts",
+          "--context",
+          "1",
+          "/repo/src",
+        ]);
+        expect(output).toContain("src/main.ts");
+      });
+    });
+
+    describe("#when ast_grep_replace executes with dryRun false", () => {
+      it("#then it includes --update-all and returns replacement output", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async () => ({
+          exitCode: 0,
+          stdout: "updated src/main.ts",
+          stderr: "",
+        }));
+        runner.mockImplementation(async (command: string[]) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "updated src/main.ts",
+            stderr: "",
+          };
+        });
+        const tool = createAstGrepReplaceTool(runner);
+
+        const output = await tool.execute(
+          {
+            pattern: "console.log($MSG)",
+            rewrite: "log.info($MSG)",
+            lang: "typescript",
+            paths: ["src"],
+            globs: ["*.ts"],
+            dryRun: false,
+          },
+          createToolContext("/repo"),
+        );
+
+        expect(capturedCommand).toContain("--update-all");
+        expect(output).toBe("updated src/main.ts");
+      });
+    });
+  });
+
+  describe("#given grep plugin", () => {
+    describe("#when inspecting exposed tool names", () => {
+      it("#then it exposes grep", () => {
+        expect(grepPlugin.tools).toHaveProperty("grep");
+      });
+    });
+
+    describe("#when grep executes with output_mode content and head_limit", () => {
+      it("#then it formats the grep command and truncates result lines", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async () => ({
+          exitCode: 0,
+          stdout: "src/a.ts:1:first\nsrc/b.ts:2:second\nsrc/c.ts:3:third",
+          stderr: "",
+        }));
+        runner.mockImplementation(async (command: string[]) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "src/a.ts:1:first\nsrc/b.ts:2:second\nsrc/c.ts:3:third",
+            stderr: "",
+          };
+        });
+        const tool = createGrepTool(runner);
+
+        const output = await tool.execute(
+          {
+            pattern: "log.*Error",
+            path: "src",
+            include: "*.ts",
+            output_mode: "content",
+            head_limit: 2,
+          },
+          createToolContext("/repo"),
+        );
+
+        expect(capturedCommand).toContain("--line-number");
+        expect(capturedCommand).toContain("--include=*.ts");
+        expect(output).toBe("src/a.ts:1:first\nsrc/b.ts:2:second");
+      });
+    });
+  });
+
+  describe("#given glob plugin", () => {
+    let tempDirectory = "";
+
+    beforeEach(async () => {
+      tempDirectory = await mkdtemp(join(tmpdir(), "goatcode-glob-test-"));
+      await writeFile(join(tempDirectory, "older.ts"), "export const older = true");
+      await writeFile(join(tempDirectory, "newer.ts"), "export const newer = true");
+
+      const now = Date.now() / 1000;
+      await utimes(join(tempDirectory, "older.ts"), now - 10, now - 10);
+      await utimes(join(tempDirectory, "newer.ts"), now, now);
+    });
+
+    afterEach(async () => {
+      await rm(tempDirectory, { recursive: true, force: true });
+    });
+
+    describe("#when inspecting exposed tool names", () => {
+      it("#then it exposes glob", () => {
+        expect(globPlugin.tools).toHaveProperty("glob");
+      });
+    });
+
+    describe("#when glob executes with a mocked scanner", () => {
+      it("#then it returns files sorted by modified time", async () => {
+        const scanner = mock(async () => ["older.ts", "newer.ts"]);
+        const tool = createGlobTool(scanner);
+
+        const output = await tool.execute({ pattern: "*.ts" }, createToolContext(tempDirectory));
+
+        expect(scanner).toHaveBeenCalledTimes(1);
+        const lines = output.split("\n");
+        expect(lines[0]).toBe(join(tempDirectory, "newer.ts"));
+        expect(lines[1]).toBe(join(tempDirectory, "older.ts"));
+      });
+    });
+  });
+});

package/src/tools/delegate-task/category-resolver.ts

@@ -0,0 +1,18 @@
+import type { CategoryConfig } from "../../types/category";
+import { CategoryResolver, type CategoryOverrides } from "../../runtime";
+
+const resolver = new CategoryResolver();
+
+export function resolveCategory(
+  name: string,
+  configOverrides?: CategoryOverrides,
+): CategoryConfig | undefined {
+  return resolver.resolve(name, configOverrides);
+}
+
+export function resolveCategoryWithDefaults(
+  name: string,
+  configOverrides?: CategoryOverrides,
+): CategoryConfig | undefined {
+  return resolver.resolve(name, configOverrides);
+}