goatcode-sh 0.0.1 → 0.1.2

package/src/tools/delegate-task/constants.ts

@@ -0,0 +1,43 @@
+import type { CategoryConfig } from "./types";
+
+export const DEFAULT_CATEGORIES: Record<string, CategoryConfig> = {
+  "visual-engineering": {
+    model: "gemini-3.1-pro",
+    variant: "high",
+    description: "Frontend, UI/UX, design, styling, animation",
+  },
+  ultrabrain: {
+    model: "gpt-5.4",
+    variant: "xhigh",
+    description: "Hard logic, architecture decisions, complex reasoning",
+  },
+  deep: {
+    model: "gpt-5.3-codex",
+    variant: "medium",
+    description: "Goal-oriented autonomous problem-solving, deep research",
+  },
+  artistry: {
+    model: "gemini-3.1-pro",
+    variant: "high",
+    description: "Creative approaches, unconventional solutions",
+  },
+  quick: {
+    model: "gpt-5.4-mini",
+    description: "Trivial tasks, single file changes, typo fixes",
+  },
+  "unspecified-low": {
+    model: "claude-sonnet-4-6",
+    description: "Moderate effort tasks that don't fit other categories",
+  },
+  "unspecified-high": {
+    model: "claude-opus-4-6",
+    variant: "max",
+    description: "High effort tasks that don't fit other categories",
+  },
+  writing: {
+    model: "gemini-3.1-flash-lite",
+    description: "Documentation, prose, technical writing",
+  },
+};
+
+export const CATEGORY_NAMES = Object.keys(DEFAULT_CATEGORIES);

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

@@ -0,0 +1,245 @@
+import { describe, it, expect, mock } from "bun:test";
+import { resolveCategory } from "./category-resolver";
+import { DEFAULT_CATEGORIES, CATEGORY_NAMES } from "./constants";
+import type { BackgroundTask, BackgroundAgentManager } from "../../runtime";
+import { createTaskTool } from "./handler";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+function makeMockManager() {
+  const launched: Array<{ id: string; prompt: string; model: string }> = [];
+  return {
+    launched,
+    launch: mock(async (_ctx: unknown, input: { id: string; prompt: string; model: string }) => {
+      launched.push(input);
+      return {
+        id: input.id,
+        status: "queued" as BackgroundTask["status"],
+        prompt: input.prompt,
+        model: input.model,
+        createdAt: Date.now(),
+      };
+    }),
+    get: mock(() => undefined),
+    getAll: mock(() => []),
+    complete: mock(() => {}),
+    fail: mock(() => {}),
+    cancel: mock(async () => {}),
+  };
+}
+
+function makeMockToolContext(overrides: Partial<Parameters<ToolDefinition["execute"]>[1]> = {}) {
+  return {
+    sessionID: "test-session",
+    messageID: "test-message",
+    agent: "test-agent",
+    directory: "/tmp/test",
+    worktree: "/tmp/test",
+    abort: new AbortController().signal,
+    metadata: () => {},
+    ask: async () => {},
+    client: makeMockClient(),
+    ...overrides,
+  } as unknown as Parameters<ToolDefinition["execute"]>[1];
+}
+
+function makeMockClient() {
+  return {
+    session: {
+      create: mock(async () => ({
+        data: { id: "sync-session-123" },
+        error: undefined,
+      })),
+      promptAsync: mock(async () => ({
+        data: {},
+        error: undefined,
+      })),
+      status: mock(async () => ({
+        data: {
+          "sync-session-123": { type: "idle" },
+        },
+      })),
+      messages: mock(async () => ({
+        data: [
+          { role: "user", content: "test prompt" },
+          { role: "assistant", content: "task result here" },
+        ],
+      })),
+      delete: mock(async () => ({})),
+    },
+  };
+}
+
+describe("resolveCategory", () => {
+  describe("#given the resolveCategory function", () => {
+    describe("#when resolving all 8 default categories", () => {
+      it("#then each resolves to a valid config", () => {
+        const expected = [
+          "visual-engineering",
+          "ultrabrain",
+          "deep",
+          "artistry",
+          "quick",
+          "unspecified-low",
+          "unspecified-high",
+          "writing",
+        ];
+
+        for (const name of expected) {
+          const config = resolveCategory(name);
+          expect(config).toBeDefined();
+          expect(config?.model).toBeTypeOf("string");
+          expect((config?.model ?? "").length).toBeGreaterThan(0);
+        }
+      });
+    });
+
+    describe("#when resolving visual-engineering", () => {
+      it("#then returns gemini-3.1-pro with high variant", () => {
+        const config = resolveCategory("visual-engineering");
+        expect(config?.model).toBe("gemini-3.1-pro");
+        expect(config?.variant).toBe("high");
+        expect(config?.description).toBe("Frontend, UI/UX, design, styling, animation");
+      });
+    });
+
+    describe("#when resolving ultrabrain", () => {
+      it("#then returns gpt-5.4 with xhigh variant", () => {
+        const config = resolveCategory("ultrabrain");
+        expect(config?.model).toBe("gpt-5.4");
+        expect(config?.variant).toBe("xhigh");
+      });
+    });
+
+    describe("#when resolving an unknown category", () => {
+      it("#then returns undefined", () => {
+        const config = resolveCategory("nonexistent-category");
+        expect(config).toBeUndefined();
+      });
+    });
+
+    describe("#when listing categories", () => {
+      it("#then returns all 8 category names", () => {
+        expect(CATEGORY_NAMES).toHaveLength(8);
+        expect(CATEGORY_NAMES).toContain("visual-engineering");
+        expect(CATEGORY_NAMES).toContain("ultrabrain");
+        expect(CATEGORY_NAMES).toContain("deep");
+        expect(CATEGORY_NAMES).toContain("artistry");
+        expect(CATEGORY_NAMES).toContain("quick");
+        expect(CATEGORY_NAMES).toContain("unspecified-low");
+        expect(CATEGORY_NAMES).toContain("unspecified-high");
+        expect(CATEGORY_NAMES).toContain("writing");
+      });
+    });
+  });
+});
+
+describe("DEFAULT_CATEGORIES", () => {
+  describe("#given the constant map", () => {
+    describe("#when checking category count", () => {
+      it("#then has exactly 8 entries", () => {
+        expect(Object.keys(DEFAULT_CATEGORIES)).toHaveLength(8);
+      });
+    });
+
+    describe("#when checking each category has a model", () => {
+      it("#then every entry has a non-empty model string", () => {
+        for (const [, config] of Object.entries(DEFAULT_CATEGORIES)) {
+          expect(config.model.length).toBeGreaterThan(0);
+        }
+      });
+    });
+  });
+});
+
+describe("CATEGORY_NAMES", () => {
+  describe("#given the names array", () => {
+    it("#then matches the keys of DEFAULT_CATEGORIES", () => {
+      expect(CATEGORY_NAMES).toEqual(Object.keys(DEFAULT_CATEGORIES));
+    });
+  });
+});
+
+describe("createTaskTool", () => {
+  describe("#given a task tool with mock manager", () => {
+    const manager = makeMockManager();
+    const tool = createTaskTool(() => manager as unknown as BackgroundAgentManager);
+
+    describe("#when executing with an unknown category", () => {
+      it("#then returns an error listing available categories", async () => {
+        const ctx = makeMockToolContext();
+        const result = await tool.execute(
+          {
+            category: "bogus",
+            description: "test task",
+            prompt: "do something",
+            run_in_background: false,
+          },
+          ctx,
+        );
+        expect(result).toContain("Unknown category");
+        expect(result).toContain("bogus");
+        expect(result).toContain("visual-engineering");
+      });
+    });
+
+    describe("#when executing background task with valid category", () => {
+      it("#then launches via manager and returns task id", async () => {
+        const bgManager = makeMockManager();
+        const bgTool = createTaskTool(() => bgManager as unknown as BackgroundAgentManager);
+        const ctx = makeMockToolContext();
+
+        const result = await bgTool.execute(
+          {
+            category: "quick",
+            description: "fix typo",
+            prompt: "fix the typo in readme",
+            run_in_background: true,
+          },
+          ctx,
+        );
+
+        expect(result).toContain("Background task launched");
+        expect(result).toContain("quick");
+        expect(result).toContain("gpt-5.4-mini");
+        expect(bgManager.launch).toHaveBeenCalledTimes(1);
+        expect(bgManager.launched[0].model).toBe("gpt-5.4-mini");
+      });
+    });
+
+    describe("#when executing sync task with valid category", () => {
+      it("#then creates session and returns result", async () => {
+        const syncManager = makeMockManager();
+        const syncTool = createTaskTool(() => syncManager as unknown as BackgroundAgentManager);
+        const ctx = makeMockToolContext();
+
+        const result = await syncTool.execute(
+          {
+            category: "unspecified-low",
+            description: "moderate task",
+            prompt: "implement the feature",
+            run_in_background: false,
+          },
+          ctx,
+        );
+
+        expect(result).toBe("task result here");
+      });
+    });
+  });
+
+  describe("#given the tool definition", () => {
+    const manager = makeMockManager();
+    const tool = createTaskTool(() => manager as unknown as BackgroundAgentManager);
+
+    describe("#when checking tool metadata", () => {
+      it("#then has a description mentioning categories", () => {
+        expect(tool.description).toContain("category-based agent");
+        expect(tool.description).toContain("visual-engineering");
+      });
+
+      it("#then has args defined", () => {
+        expect(tool.args).toBeDefined();
+      });
+    });
+  });
+});

package/src/tools/delegate-task/executor.ts

@@ -0,0 +1,157 @@
+import type { OpenCodeContext } from "../../types/plugin";
+import type { BackgroundAgentManager } from "../../runtime";
+import type { TaskInput, CategoryConfig } from "./types";
+import { log } from "../../shared/logger";
+import { parseModelId } from "../../shared/model-normalization";
+import { qualifyModel } from "../../shared/provider-registry";
+
+export interface ExecutorDeps {
+  manager: BackgroundAgentManager;
+  client: OpenCodeContext["client"];
+  directory: string;
+}
+
+export async function executeBackground(
+  input: TaskInput,
+  config: CategoryConfig,
+  deps: ExecutorDeps,
+): Promise<string> {
+  if (input.session_id) {
+    return "Error: 'session_id' is not supported for background tasks. Use run_in_background=false to resume a session.";
+  }
+
+  const { manager, client, directory } = deps;
+  const taskId = `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+  log("[delegate-task] Launching background task", {
+    taskId,
+    category: input.category,
+    model: config.model,
+  });
+
+  const ctx: OpenCodeContext = { client, directory } as OpenCodeContext;
+  const task = await manager.launch(ctx, {
+    id: taskId,
+    prompt: input.prompt,
+    model: config.model,
+  });
+
+  return formatBackgroundResult(task.id, input, config);
+}
+
+function formatBackgroundResult(taskId: string, input: TaskInput, config: CategoryConfig): string {
+  return [
+    "Background task launched.",
+    "",
+    `Task ID: ${taskId}`,
+    `Category: ${input.category}`,
+    `Model: ${config.model}${config.variant ? ` (variant: ${config.variant})` : ""}`,
+    `Description: ${input.description}`,
+    "",
+    `Use \`background_output\` with task_id="${taskId}" to check status.`,
+  ].join("\n");
+}
+
+export async function executeSync(
+  input: TaskInput,
+  config: CategoryConfig,
+  deps: ExecutorDeps,
+): Promise<string> {
+  const { client, directory } = deps;
+
+  log("[delegate-task] Executing sync task", {
+    category: input.category,
+    model: config.model,
+  });
+
+  let sessionId: string;
+
+  if (input.session_id) {
+    sessionId = input.session_id;
+    log("[delegate-task] Resuming existing session", { sessionId });
+  } else {
+    const createResult = await client.session.create({
+      body: { title: `task:${input.category}:${input.description.slice(0, 50)}` },
+      query: { directory },
+    });
+
+    if (createResult.error) {
+      const errorMsg = `Failed to create session: ${String(createResult.error)}`;
+      log("[delegate-task] Session creation failed", { error: errorMsg });
+      return errorMsg;
+    }
+
+    sessionId = createResult.data.id;
+  }
+  const parsed = parseModelId(qualifyModel(config.model));
+
+  const promptResult = await client.session.promptAsync({
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text: input.prompt }],
+      ...(parsed && { model: { providerID: parsed.provider, modelID: parsed.modelId } }),
+    },
+  });
+
+  if (promptResult.error) {
+    const errorMsg = `Failed to send prompt: ${String(promptResult.error)}`;
+    log("[delegate-task] Prompt send failed", { error: errorMsg, sessionId });
+    return errorMsg;
+  }
+
+  return await pollForResult(client, directory, sessionId);
+}
+
+const POLL_INTERVAL_MS = 2_000;
+const MAX_POLL_DURATION_MS = 5 * 60 * 1_000;
+
+async function pollForResult(
+  client: OpenCodeContext["client"],
+  directory: string,
+  sessionId: string,
+): Promise<string> {
+  const start = Date.now();
+
+  while (Date.now() - start < MAX_POLL_DURATION_MS) {
+    const statusResult = await client.session.status({
+      query: { directory },
+    });
+
+    const sessionStatus = statusResult.data?.[sessionId]?.type;
+    // undefined means session not yet visible in status map — keep polling
+    if (sessionStatus === undefined) {
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      continue;
+    }
+    if (sessionStatus === "idle") {
+      return await fetchLastAssistantMessage(client, sessionId);
+    }
+    // any status other than active running states is terminal
+    if (sessionStatus !== "busy" && sessionStatus !== "retry") {
+      return await fetchLastAssistantMessage(client, sessionId);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+
+  return `Task timed out after ${MAX_POLL_DURATION_MS / 1_000}s. Session: ${sessionId}`;
+}
+
+type SessionMessage = {
+  role?: string;
+  content?: string;
+};
+
+async function fetchLastAssistantMessage(
+  client: OpenCodeContext["client"],
+  sessionId: string,
+): Promise<string> {
+  const messagesResult = await client.session.messages({
+    path: { id: sessionId },
+  });
+
+  const messages = (messagesResult.data ?? []) as SessionMessage[];
+  const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+
+  return lastAssistant?.content ?? "Task completed but no response was returned.";
+}

package/src/tools/delegate-task/handler.ts

@@ -0,0 +1,74 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { BackgroundAgentManager } from "../../runtime";
+import type { TaskInput, CategoryConfig } from "./types";
+import type { ExecutorDeps } from "./executor";
+import { z } from "zod";
+
+import { buildTool } from "../tool-builder";
+import { getClientFromToolContext } from "../lsp/client";
+import { resolveCategory } from "./category-resolver";
+import { executeBackground, executeSync } from "./executor";
+import { CATEGORY_NAMES } from "./constants";
+import { log } from "../../shared/logger";
+
+const categoryListForDescription = CATEGORY_NAMES.map((name) => `"${name}"`).join(", ");
+
+const taskArgsSchema = z.object({
+  category: z.string().describe(`Category to route to. One of: ${categoryListForDescription}`),
+  description: z.string().describe("Short 3-5 word task description"),
+  prompt: z.string().describe("Full prompt/instructions for the delegated agent"),
+  load_skills: z.array(z.string()).optional().describe("Skill names to inject"),
+  run_in_background: z
+    .boolean()
+    .describe("true: async (returns task_id), false: sync (waits for result)"),
+  session_id: z.string().optional().describe("Resume an existing session"),
+});
+
+export function createTaskTool(getManager: () => BackgroundAgentManager): ToolDefinition {
+  return buildTool({
+    description: [
+      "Delegate a task to a category-based agent.",
+      `Available categories: ${categoryListForDescription}.`,
+      "Set run_in_background=true for async execution (returns task_id), false for sync.",
+    ].join(" "),
+    args: taskArgsSchema.shape as unknown as ToolDefinition["args"],
+    execute: async (rawArgs, toolContext) => {
+      const args = taskArgsSchema.parse(rawArgs);
+      const input: TaskInput = {
+        category: args.category,
+        description: args.description,
+        prompt: args.prompt,
+        load_skills: args.load_skills,
+        run_in_background: args.run_in_background,
+        session_id: args.session_id,
+      };
+
+      const config = resolveCategory(input.category) as CategoryConfig | undefined;
+      if (!config) {
+        const available = CATEGORY_NAMES.join(", ");
+        log("[delegate-task] Unknown category", { category: input.category });
+        return `Unknown category: "${input.category}". Available: ${available}`;
+      }
+
+      const client = getClientFromToolContext(toolContext);
+      const manager = getManager();
+      const deps: ExecutorDeps = {
+        manager,
+        client,
+        directory: toolContext.directory,
+      };
+
+      log("[delegate-task] Routing task", {
+        category: input.category,
+        model: config.model,
+        background: input.run_in_background,
+      });
+
+      if (input.run_in_background) {
+        return executeBackground(input, config, deps);
+      }
+
+      return executeSync(input, config, deps);
+    },
+  });
+}

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

@@ -0,0 +1,7 @@
+export type { TaskInput, CategoryConfig } from "./types";
+export type { ExecutorDeps } from "./executor";
+export { DEFAULT_CATEGORIES, CATEGORY_NAMES } from "./constants";
+export { resolveCategory, resolveCategoryWithDefaults } from "./category-resolver";
+export { createTaskTool } from "./handler";
+export { executeBackground, executeSync } from "./executor";
+export { default as delegateTaskPlugin } from "./plugin";

package/src/tools/delegate-task/plugin.ts

@@ -0,0 +1,21 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { getBackgroundAgent, initBackgroundAgent, resetBackgroundAgent } from "../../runtime";
+import { createTaskTool } from "./handler";
+
+function getManagerOrThrow() {
+  return getBackgroundAgent().manager;
+}
+
+export default definePlugin({
+  name: "delegate-task",
+  version: "1.0.0",
+  setup() {
+    initBackgroundAgent();
+  },
+  teardown() {
+    resetBackgroundAgent();
+  },
+  tools: {
+    task: createTaskTool(getManagerOrThrow),
+  },
+});

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

@@ -0,0 +1,19 @@
+export interface TaskInput {
+  category: string;
+  description: string;
+  prompt: string;
+  load_skills?: string[];
+  run_in_background: boolean;
+  session_id?: string;
+}
+
+export interface CategoryConfig {
+  model: string;
+  variant?: string;
+  description?: string;
+}
+
+export interface CategoryResolver {
+  resolve(categoryName: string): CategoryConfig | undefined;
+  list(): string[];
+}

package/src/tools/glob/handler.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, beforeEach, describe, it, expect, mock } from "bun:test";
+import { mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createGlobTool } from "./handler";
+import { createMockToolContext } from "../../test-utils";
+
+describe("globTool", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "goatcode-glob-handler-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("#given files matching a pattern", () => {
+    describe("#when scanner returns matches", () => {
+      it("#then returns files sorted by modification time (newest first)", async () => {
+        await writeFile(join(tempDir, "old.ts"), "export const old = true");
+        await writeFile(join(tempDir, "new.ts"), "export const newer = true");
+        const now = Date.now() / 1000;
+        await utimes(join(tempDir, "old.ts"), now - 10, now - 10);
+        await utimes(join(tempDir, "new.ts"), now, now);
+
+        const scanner = mock(async () => ["old.ts", "new.ts"]);
+        const tool = createGlobTool(scanner);
+        const ctx = createMockToolContext({ directory: tempDir });
+
+        const result = await tool.execute({ pattern: "*.ts" }, ctx);
+
+        expect(scanner).toHaveBeenCalledTimes(1);
+        const lines = String(result).split("\n");
+        expect(lines[0]).toBe(join(tempDir, "new.ts"));
+        expect(lines[1]).toBe(join(tempDir, "old.ts"));
+      });
+    });
+  });
+
+  describe("#given more files than the maximum limit", () => {
+    describe("#when scanner returns over 100 files", () => {
+      it("#then returns at most 100 files", async () => {
+        const totalFiles = 105;
+        const fileNames: string[] = [];
+        for (let i = 0; i < totalFiles; i++) {
+          const name = `file-${i.toString().padStart(3, "0")}.ts`;
+          fileNames.push(name);
+          await writeFile(join(tempDir, name), "");
+        }
+
+        const scanner = mock(async () => fileNames);
+        const tool = createGlobTool(scanner);
+        const ctx = createMockToolContext({ directory: tempDir });
+
+        const result = await tool.execute({ pattern: "*.ts" }, ctx);
+
+        const lines = String(result)
+          .split("\n")
+          .filter((l) => l.length > 0);
+        expect(lines.length).toBe(100);
+      });
+    });
+  });
+
+  describe("#given a pattern matching no files", () => {
+    describe("#when scanner returns empty array", () => {
+      it("#then returns no files found message", async () => {
+        const scanner = mock(async () => []);
+        const tool = createGlobTool(scanner);
+        const ctx = createMockToolContext({ directory: tempDir });
+
+        const result = await tool.execute({ pattern: "*.xyz" }, ctx);
+
+        expect(result).toBe("No files found");
+      });
+    });
+  });
+});