goatcode-sh 0.0.1 → 0.1.3

package/src/config/schema.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { CONFIG_DEFAULTS } from "./defaults";
+
+export const AgentOverrideConfigSchema = z.object({
+  model: z.string().optional(),
+  variant: z.string().optional(),
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  prompt_append: z.string().optional(),
+  denied_tools: z.array(z.string()).optional(),
+  disable: z.boolean().optional(),
+  fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+export const CategoryConfigSchema = z.object({
+  model: z.string().optional(),
+  variant: z.string().optional(),
+  description: z.string().optional(),
+  prompt_append: z.string().optional(),
+});
+
+export const AgentOverridesSchema = z.object({
+  orchestrator: AgentOverrideConfigSchema.optional(),
+  "deep-worker": AgentOverrideConfigSchema.optional(),
+  planner: AgentOverrideConfigSchema.optional(),
+  advisor: AgentOverrideConfigSchema.optional(),
+  researcher: AgentOverrideConfigSchema.optional(),
+  explorer: AgentOverrideConfigSchema.optional(),
+  worker: AgentOverrideConfigSchema.optional(),
+});
+
+export const CategoryOverridesSchema = z.object({
+  "visual-engineering": CategoryConfigSchema.optional(),
+  ultrabrain: CategoryConfigSchema.optional(),
+  deep: CategoryConfigSchema.optional(),
+  artistry: CategoryConfigSchema.optional(),
+  quick: CategoryConfigSchema.optional(),
+  "unspecified-low": CategoryConfigSchema.optional(),
+  "unspecified-high": CategoryConfigSchema.optional(),
+  writing: CategoryConfigSchema.optional(),
+});
+
+export const GoatCodeConfigSchema = z.object({
+  agents: AgentOverridesSchema.optional(),
+  categories: CategoryOverridesSchema.optional(),
+  default_temperature: z.number().min(0).max(2).default(CONFIG_DEFAULTS.default_temperature),
+  default_provider: z.string().optional(),
+  provider_priority: z.array(z.string()).default(CONFIG_DEFAULTS.provider_priority),
+  disabled_agents: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_agents),
+  disabled_hooks: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_hooks),
+  disabled_tools: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_tools),
+  disabled_skills: z.array(z.string()).default(CONFIG_DEFAULTS.disabled_skills),
+  auto_update: z.boolean().default(CONFIG_DEFAULTS.auto_update),
+  plugins: z.array(z.string()).optional(),
+});
+
+export type GoatCodeConfigInput = z.input<typeof GoatCodeConfigSchema>;

package/src/config/validator.ts

@@ -0,0 +1,24 @@
+import type { GoatCodeConfig } from "../types/config";
+import { log } from "../shared/logger";
+import { GoatCodeConfigSchema } from "./schema";
+
+export type ValidationResult =
+  | {
+      success: true;
+      config: GoatCodeConfig;
+    }
+  | {
+      success: false;
+      errors: string[];
+    };
+
+export function validateConfig(raw: unknown): ValidationResult {
+  const result = GoatCodeConfigSchema.safeParse(raw);
+  if (result.success) {
+    return { success: true, config: result.data };
+  }
+
+  const errors = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+  log("[config/validator] Validation failed", { errors });
+  return { success: false, errors };
+}

package/src/features/auto-update/auto-update.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from "bun:test";
+import { checkForUpdate } from "./update-checker";
+
+describe("#auto-update-checker", () => {
+  describe("#when checking for updates", () => {
+    it("#then returns updateAvailable=true when latest version is newer", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.2.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(true);
+      expect(result.latest).toBe("0.2.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then returns updateAvailable=false when versions are the same", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.1.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then returns updateAvailable=false when current version is newer", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "0.1.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.2.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.2.0");
+    });
+
+    it("#then handles fetch errors gracefully", async () => {
+      const mockFetch = async () => {
+        throw new Error("Network error");
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then handles failed HTTP responses", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: false,
+          status: 404,
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+      expect(result.current).toBe("0.1.0");
+    });
+
+    it("#then compares semantic versions correctly", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({ version: "1.0.0" }),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.9.9", mockFetch);
+
+      expect(result.updateAvailable).toBe(true);
+    });
+
+    it("#then handles missing version in response", async () => {
+      const mockFetch = async () => {
+        return {
+          ok: true,
+          json: async () => ({}),
+        } as Response;
+      };
+
+      const result = await checkForUpdate("0.1.0", mockFetch);
+
+      expect(result.updateAvailable).toBe(false);
+      expect(result.latest).toBe("0.1.0");
+    });
+  });
+});

package/src/features/auto-update/index.ts

@@ -0,0 +1,4 @@
+export { checkForUpdate } from "./update-checker";
+export type { UpdateCheckResult } from "./update-checker";
+
+export { createAutoUpdatePlugin } from "./plugin";

package/src/features/auto-update/plugin.ts

@@ -0,0 +1,45 @@
+import type { PluginDefinition } from "../../types/plugin";
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { log } from "../../shared/logger";
+import { checkForUpdate } from "./update-checker";
+import packageJson from "../../../package.json";
+
+function isSessionCreatedEvent(value: unknown): value is { type: string; properties?: unknown } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "type" in value &&
+    typeof (value as { type: unknown }).type === "string"
+  );
+}
+
+export function createAutoUpdatePlugin(): PluginDefinition {
+  let hasChecked = false;
+
+  return definePlugin({
+    name: "auto-update",
+    version: "1.0.0",
+    hooks: {
+      event: async (input: unknown) => {
+        if (!isSessionCreatedEvent(input) || input.type !== "session.created") return;
+        if (hasChecked) return;
+
+        hasChecked = true;
+
+        try {
+          const currentVersion = packageJson.version;
+          const result = await checkForUpdate(currentVersion);
+
+          if (result.updateAvailable) {
+            log("[auto-update] Update available", {
+              current: result.current,
+              latest: result.latest,
+            });
+          }
+        } catch (error) {
+          log("[auto-update] Hook execution failed", { error });
+        }
+      },
+    },
+  });
+}

package/src/features/auto-update/update-checker.ts

@@ -0,0 +1,66 @@
+import { log } from "../../shared/logger";
+
+export interface UpdateCheckResult {
+  updateAvailable: boolean;
+  latest: string;
+  current: string;
+  error: boolean;
+}
+
+export async function checkForUpdate(
+  currentVersion: string,
+  fetchFn: typeof fetch = globalThis.fetch,
+): Promise<UpdateCheckResult> {
+  try {
+    const response = await fetchFn("https://registry.npmjs.org/goatcode-sh/latest");
+    if (!response.ok) {
+      log("[auto-update-checker] Failed to fetch npm registry", { status: response.status });
+      return {
+        updateAvailable: false,
+        latest: currentVersion,
+        current: currentVersion,
+        error: true,
+      };
+    }
+
+    const data = (await response.json()) as { version?: string };
+    const latestVersion = data.version ?? currentVersion;
+
+    const updateAvailable = isNewerVersion(latestVersion, currentVersion);
+
+    return {
+      updateAvailable,
+      latest: latestVersion,
+      current: currentVersion,
+      error: false,
+    };
+  } catch (error) {
+    log("[auto-update-checker] Error checking for update", { error });
+    return {
+      updateAvailable: false,
+      latest: currentVersion,
+      current: currentVersion,
+      error: true,
+    };
+  }
+}
+
+function isNewerVersion(latest: string, current: string): boolean {
+  const parseVersion = (v: string) =>
+    v
+      .split("-")[0]
+      .split(".")
+      .map((p) => parseInt(p, 10));
+  const latestParts = parseVersion(latest);
+  const currentParts = parseVersion(current);
+
+  for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+    const latestPart = latestParts[i] ?? 0;
+    const currentPart = currentParts[i] ?? 0;
+
+    if (latestPart > currentPart) return true;
+    if (latestPart < currentPart) return false;
+  }
+
+  return false;
+}

package/src/features/background-agent/concurrency.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+
+import { ConcurrencyManager } from "./concurrency";
+
+describe("ConcurrencyManager", () => {
+  test("#given limit=2 #when two tasks acquire #then running count is 2", async () => {
+    //#given
+    const manager = new ConcurrencyManager(2);
+
+    //#when
+    await manager.acquire("model:a");
+    await manager.acquire("model:a");
+
+    //#then
+    expect(manager.getCount("model:a")).toBe(2);
+  });
+
+  test("#given limit=2 and two running #when third acquires #then it queues without immediate resolution", async () => {
+    //#given
+    const manager = new ConcurrencyManager(2);
+    await manager.acquire("model:a");
+    await manager.acquire("model:a");
+    let resolved = false;
+
+    //#when
+    const thirdAcquire = manager.acquire("model:a").then(() => {
+      resolved = true;
+    });
+    await Promise.resolve();
+
+    //#then
+    expect(manager.getQueueLength("model:a")).toBe(1);
+    expect(resolved).toBeFalse();
+
+    manager.release("model:a");
+    await thirdAcquire;
+    manager.release("model:a");
+    manager.release("model:a");
+  });
+
+  test("#given limit=2 and queue exists #when one releases #then queued task resolves", async () => {
+    //#given
+    const manager = new ConcurrencyManager(2);
+    await manager.acquire("model:a");
+    await manager.acquire("model:a");
+    let resolved = false;
+    const thirdAcquire = manager.acquire("model:a").then(() => {
+      resolved = true;
+    });
+    await Promise.resolve();
+    expect(resolved).toBeFalse();
+
+    //#when
+    manager.release("model:a");
+    await thirdAcquire;
+
+    //#then
+    expect(resolved).toBeTrue();
+    expect(manager.getQueueLength("model:a")).toBe(0);
+    expect(manager.getCount("model:a")).toBe(2);
+
+    manager.release("model:a");
+    manager.release("model:a");
+  });
+});

package/src/features/background-agent/concurrency.ts

@@ -0,0 +1,44 @@
+export class ConcurrencyManager {
+  private readonly limit: number;
+  private counts = new Map<string, number>();
+  private queues = new Map<string, Array<() => void>>();
+
+  constructor(limit = 5) {
+    this.limit = limit;
+  }
+
+  async acquire(key: string): Promise<void> {
+    const current = this.counts.get(key) ?? 0;
+    if (current < this.limit) {
+      this.counts.set(key, current + 1);
+      return;
+    }
+
+    return new Promise<void>((resolve) => {
+      const queue = this.queues.get(key) ?? [];
+      queue.push(resolve);
+      this.queues.set(key, queue);
+    });
+  }
+
+  release(key: string): void {
+    const queue = this.queues.get(key) ?? [];
+    if (queue.length > 0) {
+      const next = queue.shift();
+      this.queues.set(key, queue);
+      next?.();
+      return;
+    }
+
+    const current = this.counts.get(key) ?? 0;
+    this.counts.set(key, Math.max(0, current - 1));
+  }
+
+  getCount(key: string): number {
+    return this.counts.get(key) ?? 0;
+  }
+
+  getQueueLength(key: string): number {
+    return (this.queues.get(key) ?? []).length;
+  }
+}

package/src/features/background-agent/index.ts

@@ -0,0 +1,12 @@
+export type { BackgroundTask, BackgroundTaskStatus, LaunchInput } from "./types";
+export { ConcurrencyManager } from "./concurrency";
+export {
+  POLLING_INTERVAL_MS,
+  STABILITY_REQUIRED_POLLS,
+  createPollState,
+  checkStability,
+  pollUntilStable,
+} from "./poller";
+export { spawnBackgroundSession } from "./spawner";
+export { BackgroundAgentManager } from "./manager";
+export { initBackgroundAgent, getBackgroundAgent, resetBackgroundAgent } from "./singleton";

package/src/features/background-agent/manager.ts

@@ -0,0 +1,214 @@
+import type { OpenCodeContext } from "../../types/plugin";
+
+import { log } from "../../shared/logger";
+import { resetMessageCursor } from "../session-state/session-cursor";
+import { deleteSessionTools } from "../session-state/session-tools-store";
+
+import { ConcurrencyManager } from "./concurrency";
+import { pollUntilStable } from "./poller";
+import { spawnBackgroundSession } from "./spawner";
+import type { BackgroundTask, LaunchInput } from "./types";
+
+const TASK_TTL_MS = 5 * 60 * 1_000;
+
+type SessionMessage = {
+  role?: string;
+  content?: string;
+};
+
+function isTerminalStatus(status: BackgroundTask["status"]): boolean {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+export class BackgroundAgentManager {
+  private readonly tasks = new Map<string, BackgroundTask>();
+  private readonly concurrency: ConcurrencyManager;
+  private readonly abortControllers = new Map<string, AbortController>();
+
+  constructor(concurrencyLimit = 5) {
+    this.concurrency = new ConcurrencyManager(concurrencyLimit);
+  }
+
+  async launch(ctx: OpenCodeContext, input: LaunchInput): Promise<BackgroundTask> {
+    const task: BackgroundTask = {
+      id: input.id,
+      status: "queued",
+      prompt: input.prompt,
+      model: input.model,
+      createdAt: Date.now(),
+    };
+
+    this.tasks.set(input.id, task);
+    log("[manager] Task queued", { id: input.id });
+
+    void this.runLifecycle(ctx, task, input);
+    return task;
+  }
+
+  private async runLifecycle(
+    ctx: OpenCodeContext,
+    task: BackgroundTask,
+    input: LaunchInput,
+  ): Promise<void> {
+    try {
+      await this.concurrency.acquire(task.model);
+
+      if (task.status === "cancelled") {
+        this.concurrency.release(task.model);
+        return;
+      }
+
+      task.status = "running";
+      task.startedAt = Date.now();
+      log("[manager] Task started", { id: task.id });
+
+      const { sessionId } = await spawnBackgroundSession(ctx, input);
+      task.sessionId = sessionId;
+
+      // cancel() may have mutated status concurrently while spawn was in-flight
+      if ((task as BackgroundTask).status === "cancelled") {
+        try {
+          await ctx.client.session.delete({ path: { id: sessionId } });
+        } catch (error) {
+          log("[manager] Failed to delete session after late cancel", { id: task.id, error });
+        }
+        return;
+      }
+
+      const controller = new AbortController();
+      this.abortControllers.set(task.id, controller);
+
+      const finalSnapshot = await pollUntilStable(
+        async () => {
+          const [messagesResult, statusResult] = await Promise.all([
+            ctx.client.session.messages({ path: { id: sessionId } }),
+            ctx.client.session.status({ query: { directory: ctx.directory } }),
+          ]);
+
+          const messages = (messagesResult.data ?? []) as SessionMessage[];
+          const statusType = statusResult.data?.[sessionId]?.type;
+          const isIdle = statusType === "idle";
+          const lastAssistantMessage = [...messages]
+            .reverse()
+            .find((message) => message.role === "assistant");
+
+          return {
+            messageCount: messages.length,
+            isIdle,
+            result: lastAssistantMessage?.content,
+          };
+        },
+        120,
+        controller.signal,
+      );
+
+      this.abortControllers.delete(task.id);
+
+      this.complete(task.id, finalSnapshot.result ?? "");
+    } catch (error) {
+      const isCancelledTask = task.status === "cancelled";
+      const isCancelledError = error instanceof Error && error.message === "Polling cancelled";
+      if (isCancelledTask || isCancelledError) {
+        if (!isCancelledTask) {
+          task.status = "cancelled";
+          task.completedAt = Date.now();
+          this.concurrency.release(task.model);
+          this.cleanupSession(task.sessionId);
+          this.evictStaleTasks();
+        }
+        return;
+      }
+      this.fail(task.id, error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  dispose(): void {
+    for (const [id, controller] of this.abortControllers) {
+      controller.abort();
+      log("[manager] Aborted pending task on dispose", { id });
+    }
+    this.abortControllers.clear();
+  }
+
+  complete(id: string, result: string): void {
+    const task = this.tasks.get(id);
+    if (!task || isTerminalStatus(task.status)) return;
+
+    task.status = "completed";
+    task.result = result;
+    task.completedAt = Date.now();
+    this.abortControllers.delete(id);
+    this.concurrency.release(task.model);
+    this.cleanupSession(task.sessionId);
+    this.evictStaleTasks();
+    log("[manager] Task completed", { id });
+  }
+
+  fail(id: string, error: string): void {
+    const task = this.tasks.get(id);
+    if (!task || isTerminalStatus(task.status)) return;
+
+    task.status = "failed";
+    task.error = error;
+    task.completedAt = Date.now();
+    this.abortControllers.delete(id);
+    this.concurrency.release(task.model);
+    this.cleanupSession(task.sessionId);
+    this.evictStaleTasks();
+    log("[manager] Task failed", { id, error });
+  }
+
+  async cancel(ctx: OpenCodeContext, id: string): Promise<void> {
+    const task = this.tasks.get(id);
+    if (!task || isTerminalStatus(task.status)) return;
+
+    const wasRunning = task.status === "running";
+    task.status = "cancelled";
+    task.completedAt = Date.now();
+
+    this.abortControllers.get(id)?.abort();
+    this.abortControllers.delete(id);
+
+    if (wasRunning) {
+      this.concurrency.release(task.model);
+      if (task.sessionId) {
+        try {
+          await ctx.client.session.delete({ path: { id: task.sessionId } });
+        } catch (error) {
+          log("[manager] Failed to delete cancelled session", { id, error });
+        }
+      }
+    }
+
+    this.cleanupSession(task.sessionId);
+    this.evictStaleTasks();
+    log("[manager] Task cancelled", { id });
+  }
+
+  private cleanupSession(sessionId: string | undefined): void {
+    if (!sessionId) return;
+    resetMessageCursor(sessionId);
+    deleteSessionTools(sessionId);
+  }
+
+  private evictStaleTasks(): void {
+    const now = Date.now();
+    for (const [id, task] of this.tasks) {
+      if (
+        isTerminalStatus(task.status) &&
+        task.completedAt &&
+        now - task.completedAt > TASK_TTL_MS
+      ) {
+        this.tasks.delete(id);
+      }
+    }
+  }
+
+  get(id: string): BackgroundTask | undefined {
+    return this.tasks.get(id);
+  }
+
+  getAll(): BackgroundTask[] {
+    return [...this.tasks.values()];
+  }
+}

package/src/features/background-agent/poller.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+
+import { checkStability, createPollState } from "./poller";
+
+describe("checkStability", () => {
+  test("#given idle session with stable message count for two stable polls #then stable becomes true", () => {
+    //#given
+    const initialState = createPollState();
+
+    //#when
+    const firstPoll = checkStability(initialState, 3, true);
+    const secondPoll = checkStability(firstPoll.nextState, 3, true);
+    const thirdPoll = checkStability(secondPoll.nextState, 3, true);
+
+    //#then
+    expect(firstPoll.stable).toBeFalse();
+    expect(secondPoll.stable).toBeFalse();
+    expect(thirdPoll.stable).toBeTrue();
+  });
+
+  test("#given message count changes between polls #then stability stays false", () => {
+    //#given
+    const initialState = createPollState();
+
+    //#when
+    const firstPoll = checkStability(initialState, 4, true);
+    const changedPoll = checkStability(firstPoll.nextState, 5, true);
+
+    //#then
+    expect(changedPoll.stable).toBeFalse();
+    expect(changedPoll.nextState.stablePolls).toBe(0);
+  });
+});