goatcode-sh 0.0.1 → 0.1.2

package/src/tools/task/get/handler.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { taskGetTool } from "./handler";
+import { resetTaskStore, taskStore, generateTaskId } from "../storage";
+import type { Task } from "../types";
+
+const mockContext = {
+  sessionID: "ses_test",
+  messageID: "msg_test",
+  agent: "test-agent",
+  directory: "/tmp",
+  worktree: "/tmp",
+  abort: new AbortController().signal,
+  metadata: () => {},
+  ask: async () => {},
+} satisfies Parameters<ToolDefinition["execute"]>[1];
+
+function addTask(overrides: Partial<Task> = {}): Task {
+  const now = Date.now();
+  const task: Task = {
+    id: generateTaskId(),
+    subject: "Default task",
+    status: "pending",
+    priority: "medium",
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+  taskStore.set(task.id, task);
+  return task;
+}
+
+describe("taskGetTool", () => {
+  beforeEach(() => {
+    resetTaskStore();
+  });
+
+  describe("#given a task exists in the store", () => {
+    describe("#when called with its id", () => {
+      it("#then returns the full task details", async () => {
+        const task = addTask({
+          subject: "My task",
+          content: "Details here",
+          priority: "high",
+        });
+        const result = await taskGetTool.execute({ id: task.id }, mockContext);
+        expect(result).toContain(`id: ${task.id}`);
+        expect(result).toContain("subject: My task");
+        expect(result).toContain("content: Details here");
+        expect(result).toContain("priority: high");
+        expect(result).toContain("createdAt:");
+        expect(result).toContain("updatedAt:");
+      });
+    });
+  });
+
+  describe("#given a task does not exist", () => {
+    describe("#when called with a non-existent id", () => {
+      it("#then returns an error message", async () => {
+        const result = await taskGetTool.execute({ id: "task-does-not-exist" }, mockContext);
+        expect(result).toContain("Error: task not found");
+      });
+    });
+  });
+
+  describe("#given a task with optional content omitted", () => {
+    describe("#when retrieved", () => {
+      it("#then the output does not include a content line", async () => {
+        const task = addTask({ subject: "No content task" });
+        const result = await taskGetTool.execute({ id: task.id }, mockContext);
+        expect(result).toContain("subject: No content task");
+        expect(result).not.toContain("content:");
+      });
+    });
+  });
+});

package/src/tools/task/get/handler.ts

@@ -0,0 +1,35 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { taskStore } from "../storage";
+import { TaskGetInputSchema } from "../types";
+import { formatTask } from "../format-task";
+
+const argsSchema = z.object({
+  id: z.string(),
+});
+
+export const taskGetTool: ToolDefinition = buildTool({
+  description:
+    "Get a task by ID. Returns full task details including subject, status, priority, content, and timestamps. Returns an error message if the task is not found.",
+  args: argsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args) => {
+    try {
+      const parsed = TaskGetInputSchema.parse(args);
+      const task = taskStore.get(parsed.id);
+
+      if (!task) {
+        log("task_get: task not found", { id: parsed.id });
+        return `Error: task not found: ${parsed.id}`;
+      }
+
+      log("task_get: retrieved task", { id: task.id });
+      return formatTask(task);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log("task_get: error", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/task/get/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { taskGetTool } from "./handler";
+
+export const taskGetPlugin = definePlugin({
+  name: "task-get",
+  version: "0.1.0",
+  tools: {
+    task_get: taskGetTool,
+  },
+});

package/src/tools/task/index.ts

@@ -0,0 +1,4 @@
+export { taskCreatePlugin } from "./create/plugin";
+export { taskListPlugin } from "./list/plugin";
+export { taskGetPlugin } from "./get/plugin";
+export { taskUpdatePlugin } from "./update/plugin";

package/src/tools/task/list/handler.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { taskListTool } from "./handler";
+import { resetTaskStore, taskStore, generateTaskId } from "../storage";
+import type { Task } from "../types";
+
+const mockContext = {
+  sessionID: "ses_test",
+  messageID: "msg_test",
+  agent: "test-agent",
+  directory: "/tmp",
+  worktree: "/tmp",
+  abort: new AbortController().signal,
+  metadata: () => {},
+  ask: async () => {},
+} satisfies Parameters<ToolDefinition["execute"]>[1];
+
+function addTask(overrides: Partial<Task> = {}): Task {
+  const now = Date.now();
+  const task: Task = {
+    id: generateTaskId(),
+    subject: "Default task",
+    status: "pending",
+    priority: "medium",
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+  taskStore.set(task.id, task);
+  return task;
+}
+
+describe("taskListTool", () => {
+  beforeEach(() => {
+    resetTaskStore();
+  });
+
+  describe("#given no tasks exist", () => {
+    describe("#when called", () => {
+      it("#then returns no tasks found message", async () => {
+        const result = await taskListTool.execute({}, mockContext);
+        expect(result).toBe("No tasks found.");
+      });
+    });
+  });
+
+  describe("#given tasks exist with different statuses", () => {
+    describe("#when filtering by status", () => {
+      it("#then returns only tasks matching that status", async () => {
+        addTask({ subject: "Pending task", status: "pending" });
+        addTask({ subject: "Completed task", status: "completed" });
+        const result = await taskListTool.execute({ status: "pending" }, mockContext);
+        expect(result).toContain("Pending task");
+        expect(result).not.toContain("Completed task");
+      });
+    });
+  });
+
+  describe("#given tasks exist with different priorities", () => {
+    describe("#when filtering by priority", () => {
+      it("#then returns only tasks matching that priority", async () => {
+        addTask({ subject: "High prio", priority: "high" });
+        addTask({ subject: "Low prio", priority: "low" });
+        const result = await taskListTool.execute({ priority: "high" }, mockContext);
+        expect(result).toContain("High prio");
+        expect(result).not.toContain("Low prio");
+      });
+    });
+  });
+});

package/src/tools/task/list/handler.ts

@@ -0,0 +1,48 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { taskStore } from "../storage";
+import { TaskListInputSchema } from "../types";
+import type { Task } from "../types";
+
+const argsSchema = z.object({
+  status: z.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
+  priority: z.enum(["high", "medium", "low"]).optional(),
+});
+
+function formatTaskLine(task: Task): string {
+  const content = task.content ? ` | ${task.content}` : "";
+  return `[${task.id}] ${task.subject} (${task.status}, ${task.priority})${content}`;
+}
+
+export const taskListTool: ToolDefinition = buildTool({
+  description:
+    "List tasks. Accepts optional status filter (pending/in_progress/completed/cancelled) and optional priority filter (high/medium/low). Returns a formatted list of matching tasks.",
+  args: argsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args) => {
+    try {
+      const parsed = TaskListInputSchema.parse(args);
+      let tasks = Array.from(taskStore.values());
+
+      if (parsed.status !== undefined) {
+        tasks = tasks.filter((t) => t.status === parsed.status);
+      }
+      if (parsed.priority !== undefined) {
+        tasks = tasks.filter((t) => t.priority === parsed.priority);
+      }
+
+      if (tasks.length === 0) {
+        return "No tasks found.";
+      }
+
+      const lines = tasks.map(formatTaskLine);
+      log("task_list: listed tasks", { count: tasks.length });
+      return lines.join("\n");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log("task_list: error", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/task/list/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { taskListTool } from "./handler";
+
+export const taskListPlugin = definePlugin({
+  name: "task-list",
+  version: "0.1.0",
+  tools: {
+    task_list: taskListTool,
+  },
+});

package/src/tools/task/storage.ts

@@ -0,0 +1,14 @@
+import type { Task } from "./types";
+
+/** In-memory task store shared across tool calls within a session. */
+export const taskStore: Map<string, Task> = new Map();
+
+/** Reset the store — used in tests to ensure isolation. */
+export function resetTaskStore(): void {
+  taskStore.clear();
+}
+
+/** Generate a unique task ID. */
+export function generateTaskId(): string {
+  return `task-${crypto.randomUUID()}`;
+}

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

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { taskCreateTool } from "./create/handler";
+import { taskListTool } from "./list/handler";
+import { taskGetTool } from "./get/handler";
+import { taskUpdateTool } from "./update/handler";
+import { resetTaskStore } from "./storage";
+
+const mockContext = {
+  sessionID: "session-1",
+  messageID: "message-1",
+  agent: "agent-1",
+  directory: "/tmp",
+  worktree: "/tmp",
+  abort: new AbortController().signal,
+  metadata: () => {},
+  ask: async () => {},
+} satisfies Parameters<ToolDefinition["execute"]>[1];
+
+function extractId(output: string): string {
+  const match = output.match(/^id: (.+)$/m);
+  if (!match) throw new Error(`Could not extract id from: ${output}`);
+  return match[1];
+}
+
+describe("task tools", () => {
+  beforeEach(() => {
+    resetTaskStore();
+  });
+
+  describe("#given no tasks exist", () => {
+    describe("#when task_list is called", () => {
+      it("#then it returns no tasks found message", async () => {
+        const result = await taskListTool.execute({}, mockContext);
+        expect(result).toBe("No tasks found.");
+      });
+    });
+
+    describe("#when task_get is called with a non-existent id", () => {
+      it("#then it returns an error message", async () => {
+        const result = await taskGetTool.execute({ id: "task-does-not-exist" }, mockContext);
+        expect(result).toContain("Error: task not found");
+      });
+    });
+  });
+
+  describe("#given a task is created", () => {
+    describe("#when task_create is called with subject only", () => {
+      it("#then it returns the created task with default status and priority", async () => {
+        const result = await taskCreateTool.execute({ subject: "Fix the bug" }, mockContext);
+        expect(result).toContain("subject: Fix the bug");
+        expect(result).toContain("status: pending");
+        expect(result).toContain("priority: medium");
+        expect(result).toMatch(/^id: task-/m);
+      });
+    });
+
+    describe("#when task_create is called with all fields", () => {
+      it("#then it returns the created task with all specified fields", async () => {
+        const result = await taskCreateTool.execute(
+          {
+            subject: "Deploy service",
+            content: "Deploy to prod",
+            priority: "high",
+            status: "in_progress",
+          },
+          mockContext,
+        );
+        expect(result).toContain("subject: Deploy service");
+        expect(result).toContain("content: Deploy to prod");
+        expect(result).toContain("priority: high");
+        expect(result).toContain("status: in_progress");
+      });
+    });
+  });
+
+  describe("#given a task exists in the store", () => {
+    describe("#when task_list is called without filters", () => {
+      it("#then it returns the task in the list", async () => {
+        await taskCreateTool.execute({ subject: "Write tests" }, mockContext);
+        const result = await taskListTool.execute({}, mockContext);
+        expect(result).toContain("Write tests");
+      });
+    });
+
+    describe("#when task_list is called with a matching status filter", () => {
+      it("#then it returns only tasks with that status", async () => {
+        await taskCreateTool.execute({ subject: "Task A", status: "pending" }, mockContext);
+        await taskCreateTool.execute({ subject: "Task B", status: "completed" }, mockContext);
+        const result = await taskListTool.execute({ status: "pending" }, mockContext);
+        expect(result).toContain("Task A");
+        expect(result).not.toContain("Task B");
+      });
+    });
+
+    describe("#when task_list is called with a matching priority filter", () => {
+      it("#then it returns only tasks with that priority", async () => {
+        await taskCreateTool.execute({ subject: "High prio", priority: "high" }, mockContext);
+        await taskCreateTool.execute({ subject: "Low prio", priority: "low" }, mockContext);
+        const result = await taskListTool.execute({ priority: "high" }, mockContext);
+        expect(result).toContain("High prio");
+        expect(result).not.toContain("Low prio");
+      });
+    });
+
+    describe("#when task_get is called with the task id", () => {
+      it("#then it returns the full task details", async () => {
+        const created = await taskCreateTool.execute(
+          { subject: "Review PR", content: "Check the diff", priority: "low" },
+          mockContext,
+        );
+        const id = extractId(created);
+        const result = await taskGetTool.execute({ id }, mockContext);
+        expect(result).toContain(`id: ${id}`);
+        expect(result).toContain("subject: Review PR");
+        expect(result).toContain("content: Check the diff");
+        expect(result).toContain("priority: low");
+      });
+    });
+  });
+
+  describe("#given the full CRUD lifecycle", () => {
+    describe("#when create -> list -> update -> get is performed", () => {
+      it("#then the task reflects all changes at each step", async () => {
+        const created = await taskCreateTool.execute(
+          { subject: "Implement feature", priority: "medium" },
+          mockContext,
+        );
+        expect(created).toContain("status: pending");
+        const id = extractId(created);
+
+        const listed = await taskListTool.execute({}, mockContext);
+        expect(listed).toContain("Implement feature");
+
+        const updated = await taskUpdateTool.execute({ id, status: "completed" }, mockContext);
+        expect(updated).toContain("status: completed");
+
+        const fetched = await taskGetTool.execute({ id }, mockContext);
+        expect(fetched).toContain("status: completed");
+        expect(fetched).toContain("subject: Implement feature");
+      });
+    });
+  });
+
+  describe("#given a task update with unknown id", () => {
+    describe("#when task_update is called", () => {
+      it("#then it returns an error message", async () => {
+        const result = await taskUpdateTool.execute(
+          { id: "task-unknown", status: "completed" },
+          mockContext,
+        );
+        expect(result).toContain("Error: task not found");
+      });
+    });
+  });
+
+  describe("#given task_create is called without subject", () => {
+    describe("#when subject is missing", () => {
+      it("#then it returns a validation error", async () => {
+        const result = await taskCreateTool.execute({}, mockContext);
+        expect(result).toContain("Error:");
+      });
+    });
+  });
+});

package/src/tools/task/types.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const TaskStatusSchema = z.enum(["pending", "in_progress", "completed", "cancelled"]);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+export const TaskPrioritySchema = z.enum(["high", "medium", "low"]);
+export type TaskPriority = z.infer<typeof TaskPrioritySchema>;
+
+export const TaskSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  status: TaskStatusSchema,
+  priority: TaskPrioritySchema,
+  content: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Task = z.infer<typeof TaskSchema>;
+
+export const TaskCreateInputSchema = z.object({
+  subject: z.string(),
+  content: z.string().optional(),
+  priority: TaskPrioritySchema.default("medium"),
+  status: TaskStatusSchema.default("pending"),
+});
+
+export type TaskCreateInput = z.infer<typeof TaskCreateInputSchema>;
+
+export const TaskListInputSchema = z.object({
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+});
+
+export type TaskListInput = z.infer<typeof TaskListInputSchema>;
+
+export const TaskGetInputSchema = z.object({
+  id: z.string(),
+});
+
+export type TaskGetInput = z.infer<typeof TaskGetInputSchema>;
+
+export const TaskUpdateInputSchema = z.object({
+  id: z.string(),
+  subject: z.string().optional(),
+  content: z.string().optional(),
+  status: TaskStatusSchema.optional(),
+  priority: TaskPrioritySchema.optional(),
+});
+
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;

package/src/tools/task/update/handler.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { taskUpdateTool } from "./handler";
+import { resetTaskStore, taskStore, generateTaskId } from "../storage";
+import type { Task } from "../types";
+
+const mockContext = {
+  sessionID: "ses_test",
+  messageID: "msg_test",
+  agent: "test-agent",
+  directory: "/tmp",
+  worktree: "/tmp",
+  abort: new AbortController().signal,
+  metadata: () => {},
+  ask: async () => {},
+} satisfies Parameters<ToolDefinition["execute"]>[1];
+
+function addTask(overrides: Partial<Task> = {}): Task {
+  const now = Date.now();
+  const task: Task = {
+    id: generateTaskId(),
+    subject: "Default task",
+    status: "pending",
+    priority: "medium",
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+  taskStore.set(task.id, task);
+  return task;
+}
+
+describe("taskUpdateTool", () => {
+  beforeEach(() => {
+    resetTaskStore();
+  });
+
+  describe("#given a task exists", () => {
+    describe("#when updating its status", () => {
+      it("#then returns the task with the new status", async () => {
+        const task = addTask({ subject: "Update me" });
+        const result = await taskUpdateTool.execute(
+          { id: task.id, status: "completed" },
+          mockContext,
+        );
+        expect(result).toContain("status: completed");
+        expect(result).toContain("subject: Update me");
+      });
+    });
+
+    describe("#when updating multiple fields", () => {
+      it("#then all fields are updated", async () => {
+        const task = addTask({ subject: "Original" });
+        const result = await taskUpdateTool.execute(
+          { id: task.id, subject: "Updated", priority: "high", content: "New content" },
+          mockContext,
+        );
+        expect(result).toContain("subject: Updated");
+        expect(result).toContain("priority: high");
+        expect(result).toContain("content: New content");
+      });
+    });
+
+    describe("#when updating a task", () => {
+      it("#then the updatedAt timestamp advances", async () => {
+        const earlyTime = Date.now() - 100000;
+        const task = addTask({ subject: "Timestamp test", updatedAt: earlyTime });
+        await taskUpdateTool.execute({ id: task.id, status: "in_progress" }, mockContext);
+        const updatedTask = taskStore.get(task.id);
+        expect(updatedTask!.updatedAt).toBeGreaterThan(earlyTime);
+      });
+    });
+  });
+
+  describe("#given a task does not exist", () => {
+    describe("#when update is attempted", () => {
+      it("#then returns an error message", async () => {
+        const result = await taskUpdateTool.execute(
+          { id: "task-unknown", status: "completed" },
+          mockContext,
+        );
+        expect(result).toContain("Error: task not found");
+      });
+    });
+  });
+});

package/src/tools/task/update/handler.ts

@@ -0,0 +1,54 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { taskStore } from "../storage";
+import { TaskUpdateInputSchema } from "../types";
+import { formatTask } from "../format-task";
+
+const argsSchema = z.object({
+  id: z.string(),
+  subject: z.string().optional(),
+  content: z.string().optional(),
+  status: z.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
+  priority: z.enum(["high", "medium", "low"]).optional(),
+});
+
+export const taskUpdateTool: ToolDefinition = buildTool({
+  description:
+    "Update an existing task by ID. Accepts optional subject, content, status (pending/in_progress/completed/cancelled), and priority (high/medium/low). Returns the updated task, or an error if not found.",
+  args: argsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args) => {
+    try {
+      const parsed = TaskUpdateInputSchema.parse(args);
+      const task = taskStore.get(parsed.id);
+
+      if (!task) {
+        log("task_update: task not found", { id: parsed.id });
+        return `Error: task not found: ${parsed.id}`;
+      }
+
+      if (parsed.subject !== undefined) {
+        task.subject = parsed.subject;
+      }
+      if (parsed.content !== undefined) {
+        task.content = parsed.content;
+      }
+      if (parsed.status !== undefined) {
+        task.status = parsed.status;
+      }
+      if (parsed.priority !== undefined) {
+        task.priority = parsed.priority;
+      }
+      task.updatedAt = Date.now();
+
+      taskStore.set(task.id, task);
+      log("task_update: updated task", { id: task.id });
+      return formatTask(task);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log("task_update: error", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/task/update/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { taskUpdateTool } from "./handler";
+
+export const taskUpdatePlugin = definePlugin({
+  name: "task-update",
+  version: "0.1.0",
+  tools: {
+    task_update: taskUpdateTool,
+  },
+});

package/src/tools/tool-builder.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { buildTool } from "./tool-builder";
+
+const mockContext = {
+  sessionID: "session-1",
+  messageID: "message-1",
+  agent: "agent-1",
+  directory: "/tmp",
+  worktree: "/tmp",
+  abort: new AbortController().signal,
+  metadata: () => {},
+  ask: async () => {},
+} satisfies Parameters<ToolDefinition["execute"]>[1];
+
+describe("buildTool", () => {
+  describe("#given a valid tool input", () => {
+    describe("#when buildTool is called", () => {
+      it("#then it returns a tool with description, args, and callable execute", async () => {
+        const result = buildTool({
+          description: "Searches for a query string",
+          args: {},
+          execute: async ({ query }: { query: string }) => `result:${query}`,
+        });
+
+        expect(result.description).toBe("Searches for a query string");
+        expect(result.args).toEqual({});
+        await expect(result.execute({ query: "alpha" }, mockContext)).resolves.toBe("result:alpha");
+      });
+    });
+  });
+});