goatcode-sh 0.0.1 → 0.1.3

package/src/tools/ast-grep/search/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { createAstGrepSearchTool } from "./handler";
+
+export const astGrepSearchPlugin = definePlugin({
+  name: "ast-grep-search",
+  version: "0.1.0",
+  tools: {
+    ast_grep_search: createAstGrepSearchTool(),
+  },
+});

package/src/tools/ast-grep/search/types.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+export const AST_GREP_CLI_LANGUAGES = [
+  "bash",
+  "c",
+  "cpp",
+  "csharp",
+  "css",
+  "elixir",
+  "go",
+  "haskell",
+  "html",
+  "java",
+  "javascript",
+  "json",
+  "kotlin",
+  "lua",
+  "nix",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "scala",
+  "solidity",
+  "swift",
+  "typescript",
+  "tsx",
+  "yaml",
+] as const;
+
+export const astGrepSearchArgsSchema = {
+  pattern: z
+    .string()
+    .describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
+  lang: z.enum(AST_GREP_CLI_LANGUAGES).describe("Target language"),
+  paths: z.array(z.string()).optional().describe("Paths to search (default: ['.'])"),
+  globs: z.array(z.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+  context: z.number().optional().describe("Context lines around match"),
+};
+
+export type AstGrepSearchArgs = z.infer<z.ZodObject<typeof astGrepSearchArgsSchema>>;
+export type AstGrepSearchOutput = string;

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

@@ -0,0 +1,185 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { BackgroundTask, BackgroundAgentManager } from "../../runtime";
+import type { OpenCodeContext } from "../../types/plugin";
+import { handleBackgroundOutput } from "./output/handler";
+import { handleBackgroundCancel } from "./cancel/handler";
+
+function makeTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
+  return {
+    id: "task-1",
+    status: "running",
+    prompt: "do something",
+    model: "claude-3",
+    createdAt: Date.now() - 5000,
+    startedAt: Date.now() - 4000,
+    ...overrides,
+  };
+}
+
+function makeManager(task: BackgroundTask | undefined): BackgroundAgentManager {
+  return {
+    get: mock((_id: string) => task),
+    getAll: mock(() => (task ? [task] : [])),
+    cancel: mock(async (_ctx: OpenCodeContext, _id: string) => {}),
+    launch: mock(async () => task!),
+    complete: mock(() => {}),
+    fail: mock(() => {}),
+  } as unknown as BackgroundAgentManager;
+}
+
+const mockCtx = {
+  client: {},
+  directory: "/tmp",
+  worktree: "/tmp",
+} as unknown as OpenCodeContext;
+
+describe("handleBackgroundOutput", () => {
+  describe("#given task not found", () => {
+    describe("#when called with unknown task_id", () => {
+      it("#then returns not found message", async () => {
+        const manager = makeManager(undefined);
+        const result = await handleBackgroundOutput(manager, { task_id: "missing" });
+        expect(result).toContain("Task not found: missing");
+      });
+    });
+  });
+
+  describe("#given a running task", () => {
+    describe("#when called without block", () => {
+      it("#then returns running status with elapsed time", async () => {
+        const task = makeTask({ status: "running", startedAt: Date.now() - 3000 });
+        const manager = makeManager(task);
+        const result = await handleBackgroundOutput(manager, { task_id: "task-1" });
+        expect(result).toContain("task-1");
+        expect(result).toContain("running");
+        expect(result).toContain("elapsed");
+      });
+    });
+  });
+
+  describe("#given a queued task", () => {
+    describe("#when called without block", () => {
+      it("#then returns queued status message", async () => {
+        const task = makeTask({ status: "queued", startedAt: undefined });
+        const manager = makeManager(task);
+        const result = await handleBackgroundOutput(manager, { task_id: "task-1" });
+        expect(result).toContain("queued");
+      });
+    });
+  });
+
+  describe("#given a completed task", () => {
+    describe("#when called", () => {
+      it("#then returns completed result", async () => {
+        const task = makeTask({ status: "completed", result: "the answer is 42" });
+        const manager = makeManager(task);
+        const result = await handleBackgroundOutput(manager, { task_id: "task-1" });
+        expect(result).toContain("completed");
+        expect(result).toContain("the answer is 42");
+      });
+    });
+  });
+
+  describe("#given a failed task", () => {
+    describe("#when called", () => {
+      it("#then returns failed error message", async () => {
+        const task = makeTask({ status: "failed", error: "out of memory" });
+        const manager = makeManager(task);
+        const result = await handleBackgroundOutput(manager, { task_id: "task-1" });
+        expect(result).toContain("failed");
+        expect(result).toContain("out of memory");
+      });
+    });
+  });
+
+  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-1" });
+        expect(result).toContain("cancelled");
+      });
+    });
+  });
+});
+
+describe("handleBackgroundCancel", () => {
+  describe("#given no task_id and all=false", () => {
+    describe("#when called with invalid args", () => {
+      it("#then returns error message", async () => {
+        const manager = makeManager(undefined);
+        const result = await handleBackgroundCancel(manager, mockCtx, {});
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("task_id");
+      });
+    });
+  });
+
+  describe("#given task not found", () => {
+    describe("#when called with unknown task_id", () => {
+      it("#then returns not found error", async () => {
+        const manager = makeManager(undefined);
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "ghost" });
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("ghost");
+      });
+    });
+  });
+
+  describe("#given a completed task", () => {
+    describe("#when cancel is called", () => {
+      it("#then returns cannot cancel error", async () => {
+        const task = makeTask({ status: "completed" });
+        const manager = makeManager(task);
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "task-1" });
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("completed");
+      });
+    });
+  });
+
+  describe("#given a running task", () => {
+    describe("#when cancel is called", () => {
+      it("#then cancels and returns success message", async () => {
+        const task = makeTask({ status: "running" });
+        const manager = makeManager(task);
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "task-1" });
+        expect(result).toContain("cancelled successfully");
+        expect(manager.cancel).toHaveBeenCalledWith(mockCtx, "task-1");
+      });
+    });
+  });
+
+  describe("#given multiple running tasks and all=true", () => {
+    describe("#when cancel all is called", () => {
+      it("#then cancels all and returns count", async () => {
+        const task1 = makeTask({ id: "task-1", status: "running" });
+        const task2 = makeTask({ id: "task-2", status: "queued" });
+        const manager = {
+          get: mock((_id: string) => task1),
+          getAll: mock(() => [task1, task2]),
+          cancel: mock(async () => {}),
+          launch: mock(async () => task1),
+          complete: mock(() => {}),
+          fail: mock(() => {}),
+        } as unknown as BackgroundAgentManager;
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { all: true });
+        expect(result).toContain("Cancelled 2");
+        expect(manager.cancel).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+
+  describe("#given no running tasks and all=true", () => {
+    describe("#when cancel all is called", () => {
+      it("#then returns no tasks message", async () => {
+        const task = makeTask({ status: "completed" });
+        const manager = makeManager(task);
+        const result = await handleBackgroundCancel(manager, mockCtx, { all: true });
+        expect(result).toContain("No running or queued");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,141 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { BackgroundTask, BackgroundAgentManager } from "../../../runtime";
+import type { OpenCodeContext } from "../../../types/plugin";
+import { handleBackgroundCancel } from "./handler";
+
+function makeTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
+  return {
+    id: "task-99",
+    status: "running",
+    prompt: "do work",
+    model: "claude-3",
+    createdAt: Date.now() - 5000,
+    startedAt: Date.now() - 4000,
+    ...overrides,
+  };
+}
+
+function makeManager(task: BackgroundTask | undefined): BackgroundAgentManager {
+  return {
+    get: mock((_id: string) => task),
+    getAll: mock(() => (task ? [task] : [])),
+    cancel: mock(async (_ctx: OpenCodeContext, _id: string) => {}),
+    launch: mock(async () => task!),
+    complete: mock(() => {}),
+    fail: mock(() => {}),
+  } as unknown as BackgroundAgentManager;
+}
+
+const mockCtx = {
+  client: {},
+  directory: "/tmp",
+  worktree: "/tmp",
+} as unknown as OpenCodeContext;
+
+describe("handleBackgroundCancel", () => {
+  describe("#given a specific running task", () => {
+    describe("#when cancel is called with task_id", () => {
+      it("#then cancels the task and returns success", async () => {
+        const task = makeTask({ id: "task-99", status: "running" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "task-99" });
+
+        expect(result).toContain("cancelled successfully");
+        expect(manager.cancel).toHaveBeenCalledWith(mockCtx, "task-99");
+      });
+    });
+  });
+
+  describe("#given all=true with multiple cancellable tasks", () => {
+    describe("#when cancel all is called", () => {
+      it("#then cancels all running/queued tasks", async () => {
+        const task1 = makeTask({ id: "task-a", status: "running" });
+        const task2 = makeTask({ id: "task-b", status: "queued" });
+        const task3 = makeTask({ id: "task-c", status: "completed" });
+        const manager = {
+          get: mock((_id: string) => task1),
+          getAll: mock(() => [task1, task2, task3]),
+          cancel: mock(async () => {}),
+          launch: mock(async () => task1),
+          complete: mock(() => {}),
+          fail: mock(() => {}),
+        } as unknown as BackgroundAgentManager;
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { all: true });
+
+        expect(result).toContain("Cancelled 2");
+        expect(manager.cancel).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+
+  describe("#given neither task_id nor all provided", () => {
+    describe("#when called with empty args", () => {
+      it("#then returns validation error", async () => {
+        const manager = makeManager(undefined);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, {});
+
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("task_id");
+      });
+    });
+  });
+
+  describe("#given a nonexistent task", () => {
+    describe("#when cancel is called with unknown task_id", () => {
+      it("#then returns task not found error", async () => {
+        const manager = makeManager(undefined);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "ghost-task" });
+
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("ghost-task");
+      });
+    });
+  });
+
+  describe("#given a completed task", () => {
+    describe("#when cancel is called on it", () => {
+      it("#then returns cannot cancel error with current status", async () => {
+        const task = makeTask({ id: "task-99", status: "completed" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "task-99" });
+
+        expect(result).toContain("[ERROR]");
+        expect(result).toContain("completed");
+        expect(manager.cancel).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given all=true with no cancellable tasks", () => {
+    describe("#when all tasks are already completed", () => {
+      it("#then returns no tasks message", async () => {
+        const task = makeTask({ status: "completed" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { all: true });
+
+        expect(result).toContain("No running or queued");
+        expect(manager.cancel).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given a queued task", () => {
+    describe("#when cancel is called", () => {
+      it("#then cancels the queued task successfully", async () => {
+        const task = makeTask({ id: "task-99", status: "queued" });
+        const manager = makeManager(task);
+
+        const result = await handleBackgroundCancel(manager, mockCtx, { task_id: "task-99" });
+
+        expect(result).toContain("cancelled successfully");
+        expect(manager.cancel).toHaveBeenCalledWith(mockCtx, "task-99");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,52 @@
+import type { OpenCodeContext } from "../../../types/plugin";
+import type { BackgroundAgentManager } from "../../../runtime";
+import { log } from "../../../shared/logger";
+import type { BackgroundCancelArgs } from "./types";
+
+export async function handleBackgroundCancel(
+  manager: BackgroundAgentManager,
+  ctx: OpenCodeContext,
+  args: BackgroundCancelArgs,
+): Promise<string> {
+  log("[background-cancel] called", { task_id: args.task_id, all: args.all });
+
+  const cancelAll = args.all === true;
+
+  if (!cancelAll && !args.task_id) {
+    return "[ERROR] Invalid arguments: provide a task_id or set all=true to cancel all running tasks.";
+  }
+
+  if (cancelAll) {
+    const tasks = manager.getAll();
+    const cancellable = tasks.filter((t) => t.status === "queued" || t.status === "running");
+
+    if (cancellable.length === 0) {
+      return "No running or queued background tasks to cancel.";
+    }
+
+    const cancelled: string[] = [];
+    for (const task of cancellable) {
+      await manager.cancel(ctx, task.id);
+      cancelled.push(task.id);
+    }
+
+    return `Cancelled ${cancelled.length} background task(s): ${cancelled.join(", ")}`;
+  }
+
+  const taskId = args.task_id;
+  if (!taskId) {
+    return "[ERROR] Invalid arguments: task_id is required when all is not true.";
+  }
+
+  const task = manager.get(taskId);
+  if (!task) {
+    return `[ERROR] Task not found: ${taskId}`;
+  }
+
+  if (task.status !== "queued" && task.status !== "running") {
+    return `[ERROR] Cannot cancel task ${taskId}: current status is "${task.status}". Only queued or running tasks can be cancelled.`;
+  }
+
+  await manager.cancel(ctx, task.id);
+  return `Task ${task.id} cancelled successfully.`;
+}

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

@@ -0,0 +1,30 @@
+import { tool } from "@opencode-ai/plugin";
+import type { OpenCodeContext } from "../../../types/plugin";
+import { getBackgroundAgent } from "../../../runtime";
+import { definePlugin } from "../../../plugin-api/define-plugin";
+import { handleBackgroundCancel } from "./handler";
+import type { BackgroundCancelArgs } from "./types";
+
+const backgroundCancelTool = tool({
+  description: "Cancel running background task(s). Use all=true to cancel ALL before final answer.",
+  args: {
+    task_id: tool.schema.string().optional().describe("Task ID to cancel (required if all=false)"),
+    all: tool.schema
+      .boolean()
+      .optional()
+      .describe("Cancel all running background tasks (default: false)"),
+  },
+  async execute(args: BackgroundCancelArgs, toolContext) {
+    const { manager } = getBackgroundAgent();
+    return handleBackgroundCancel(manager, toolContext as unknown as OpenCodeContext, args);
+  },
+});
+
+export default definePlugin({
+  name: "background-cancel",
+  version: "1.0.0",
+  dependencies: ["delegate-task"],
+  tools: {
+    background_cancel: backgroundCancelTool,
+  },
+});

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

@@ -0,0 +1,4 @@
+export interface BackgroundCancelArgs {
+  task_id?: string;
+  all?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export { default as backgroundOutputPlugin } from "./output/plugin";
+export { default as backgroundCancelPlugin } from "./cancel/plugin";

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");
+      });
+    });
+  });
+});