goatcode-sh 0.0.1 → 0.1.2

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

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

@@ -0,0 +1,75 @@
+import { log } from "../../shared/logger";
+
+export const POLLING_INTERVAL_MS = 3_000;
+export const STABILITY_REQUIRED_POLLS = 2;
+
+export type PollState = {
+  lastMessageCount: number;
+  stablePolls: number;
+};
+
+export type PollSnapshot = {
+  messageCount: number;
+  isIdle: boolean;
+  result?: string;
+};
+
+export function createPollState(): PollState {
+  return { lastMessageCount: -1, stablePolls: 0 };
+}
+
+export function checkStability(
+  state: PollState,
+  currentMessageCount: number,
+  isIdle: boolean,
+): { stable: boolean; nextState: PollState } {
+  if (!isIdle) {
+    return {
+      stable: false,
+      nextState: { lastMessageCount: currentMessageCount, stablePolls: 0 },
+    };
+  }
+
+  if (currentMessageCount === state.lastMessageCount) {
+    const stablePolls = state.stablePolls + 1;
+    return {
+      stable: stablePolls >= STABILITY_REQUIRED_POLLS,
+      nextState: { lastMessageCount: currentMessageCount, stablePolls },
+    };
+  }
+
+  return {
+    stable: false,
+    nextState: { lastMessageCount: currentMessageCount, stablePolls: 0 },
+  };
+}
+
+export async function pollUntilStable(
+  fetchSnapshot: () => Promise<PollSnapshot>,
+  maxPolls = 120,
+  signal?: AbortSignal,
+): Promise<PollSnapshot> {
+  let state = createPollState();
+
+  for (let attempt = 0; attempt < maxPolls; attempt += 1) {
+    if (signal?.aborted) {
+      throw new Error("Polling cancelled");
+    }
+
+    const latest = await fetchSnapshot();
+    const { stable, nextState } = checkStability(state, latest.messageCount, latest.isIdle);
+    state = nextState;
+
+    if (stable) {
+      log("[poller] Session reached stable completion", {
+        messageCount: latest.messageCount,
+        stablePolls: state.stablePolls,
+      });
+      return latest;
+    }
+
+    await new Promise<void>((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+  }
+
+  throw new Error("Background polling timed out before reaching stable completion");
+}

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

@@ -0,0 +1,26 @@
+import { BackgroundAgentManager } from "./manager";
+
+export type BackgroundAgentContext = {
+  manager: BackgroundAgentManager;
+};
+
+let instance: BackgroundAgentContext | undefined;
+
+export function initBackgroundAgent(): BackgroundAgentContext {
+  instance = {
+    manager: new BackgroundAgentManager(),
+  };
+  return instance;
+}
+
+export function getBackgroundAgent(): BackgroundAgentContext {
+  if (!instance) {
+    throw new Error("BackgroundAgent not initialized. Call initBackgroundAgent first.");
+  }
+  return instance;
+}
+
+export function resetBackgroundAgent(): void {
+  instance?.manager.dispose();
+  instance = undefined;
+}

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

@@ -0,0 +1,51 @@
+import type { OpenCodeContext } from "../../types/plugin";
+
+import { log } from "../../shared/logger";
+import { parseModelId } from "../../shared/model-normalization";
+import { qualifyModel } from "../../shared/provider-registry";
+
+import type { LaunchInput } from "./types";
+
+export type SpawnResult = {
+  sessionId: string;
+};
+
+export async function spawnBackgroundSession(
+  ctx: OpenCodeContext,
+  input: LaunchInput,
+): Promise<SpawnResult> {
+  log("[spawner] Spawning background session", {
+    id: input.id,
+    model: input.model,
+  });
+
+  const createResult = await ctx.client.session.create({
+    body: {
+      title: `bg:${input.id}`,
+    },
+    query: {
+      directory: ctx.directory,
+    },
+  });
+
+  if (createResult.error) {
+    throw new Error(`Failed to create background session: ${String(createResult.error)}`);
+  }
+
+  const sessionId = createResult.data.id;
+
+  const parsed = parseModelId(qualifyModel(input.model));
+  const promptResult = await ctx.client.session.promptAsync({
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text: input.prompt }],
+      ...(parsed && { model: { providerID: parsed.provider, modelID: parsed.modelId } }),
+    },
+  });
+
+  if (promptResult.error) {
+    throw new Error(`Failed to send prompt to background session: ${String(promptResult.error)}`);
+  }
+
+  return { sessionId };
+}

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

@@ -0,0 +1,20 @@
+export type BackgroundTaskStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+
+export interface BackgroundTask {
+  id: string;
+  sessionId?: string;
+  status: BackgroundTaskStatus;
+  prompt: string;
+  model: string;
+  createdAt: number;
+  startedAt?: number;
+  completedAt?: number;
+  result?: string;
+  error?: string;
+}
+
+export interface LaunchInput {
+  id: string;
+  prompt: string;
+  model: string;
+}

package/src/features/builtin-features.ts

@@ -0,0 +1,5 @@
+import { createAutoUpdatePlugin } from "./auto-update/plugin";
+import { loopPlugin } from "./loops/plugin";
+import type { PluginDefinition } from "../types/plugin";
+
+export const BUILTIN_FEATURE_PLUGINS: PluginDefinition[] = [createAutoUpdatePlugin(), loopPlugin];

package/src/features/categories/categories.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "bun:test";
+import { CategoryResolver, resolveCategory } from "./category-resolver";
+import { DEFAULT_CATEGORIES } from "./category-config";
+
+describe("category-resolver", () => {
+  describe("#given built-in category names", () => {
+    describe("#when resolve is called", () => {
+      it("#then resolves each category to its default model", () => {
+        const resolver = new CategoryResolver();
+
+        expect(resolver.resolve("visual-engineering")?.model).toBe(
+          DEFAULT_CATEGORIES["visual-engineering"].model,
+        );
+        expect(resolver.resolve("ultrabrain")?.model).toBe(DEFAULT_CATEGORIES.ultrabrain.model);
+        expect(resolver.resolve("deep")?.model).toBe(DEFAULT_CATEGORIES.deep.model);
+        expect(resolver.resolve("artistry")?.model).toBe(DEFAULT_CATEGORIES.artistry.model);
+        expect(resolver.resolve("quick")?.model).toBe(DEFAULT_CATEGORIES.quick.model);
+        expect(resolver.resolve("unspecified-low")?.model).toBe(
+          DEFAULT_CATEGORIES["unspecified-low"].model,
+        );
+        expect(resolver.resolve("unspecified-high")?.model).toBe(
+          DEFAULT_CATEGORIES["unspecified-high"].model,
+        );
+        expect(resolver.resolve("writing")?.model).toBe(DEFAULT_CATEGORIES.writing.model);
+      });
+    });
+  });
+
+  describe("#given category overrides", () => {
+    describe("#when model override is provided", () => {
+      it("#then override model takes precedence over defaults", () => {
+        const resolver = new CategoryResolver();
+
+        const resolved = resolver.resolve("visual-engineering", {
+          "visual-engineering": {
+            model: "custom/model",
+          },
+        });
+
+        expect(resolved?.model).toBe("custom/model");
+      });
+    });
+
+    describe("#when resolveCategory helper is called with overrides", () => {
+      it("#then returns merged category config", () => {
+        const resolved = resolveCategory("writing", {
+          writing: {
+            model: "custom/writer-model",
+            variant: "high",
+          },
+        });
+
+        expect(resolved?.model).toBe("custom/writer-model");
+        expect(resolved?.variant).toBe("high");
+        expect(typeof resolved?.prompt_append).toBe("string");
+      });
+    });
+  });
+
+  describe("#given an unknown category", () => {
+    describe("#when resolve is called", () => {
+      it("#then returns undefined", () => {
+        const resolver = new CategoryResolver();
+        expect(resolver.resolve("not-a-category")).toBeUndefined();
+      });
+    });
+  });
+});