goatcode-sh 0.0.1 → 0.1.3

package/src/features/loops/loops.test.ts

@@ -0,0 +1,175 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  FileLoopStore,
+  MemoryLoopStore,
+  createLoopHandler,
+  fileLoopStore,
+  memoryLoopStore,
+  startLoop,
+  stopLoop,
+} from "./index";
+
+describe("unified loops", () => {
+  describe("MemoryLoopStore", () => {
+    let store: MemoryLoopStore;
+
+    beforeEach(() => {
+      store = new MemoryLoopStore();
+    });
+
+    it("starts active in memory and increments iterations", () => {
+      store.startLoop("memory-session", { maxIterations: 5 });
+      store.incrementIteration("memory-session");
+      store.incrementIteration("memory-session");
+
+      const state = store.getLoopState("memory-session");
+      expect(state?.persist).toBeFalse();
+      expect(state?.iteration).toBe(2);
+      expect(store.isActive("memory-session")).toBeTrue();
+    });
+
+    it("marks completion and deactivates the loop", () => {
+      store.startLoop("memory-complete");
+      store.markCompletionDetected("memory-complete");
+
+      const state = store.getLoopState("memory-complete");
+      expect(state?.active).toBeFalse();
+      expect(state?.completionDetected).toBeTrue();
+    });
+  });
+
+  describe("FileLoopStore", () => {
+    let tempDir = "";
+    let stateFilePath = "";
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(join(tmpdir(), "goatcode-loop-store-"));
+      stateFilePath = join(tempDir, "loop-state.json");
+    });
+
+    afterEach(() => {
+      if (tempDir) {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    it("persists loop state to disk and reloads it", () => {
+      const initialStore = new FileLoopStore({ stateFilePath });
+      initialStore.startLoop("persisted-session", { persist: true, maxIterations: 9 });
+
+      const reloadedStore = new FileLoopStore({ stateFilePath });
+      expect(reloadedStore.isActive("persisted-session")).toBeTrue();
+      expect(reloadedStore.getLoopState("persisted-session")?.maxIterations).toBe(9);
+      expect(reloadedStore.getLoopState("persisted-session")?.persist).toBeTrue();
+    });
+
+    it("stops loop and clears persisted state for that session", () => {
+      const initialStore = new FileLoopStore({ stateFilePath });
+      initialStore.startLoop("persisted-session", { persist: true });
+      initialStore.stopLoop("persisted-session");
+
+      const reloadedStore = new FileLoopStore({ stateFilePath });
+      expect(reloadedStore.getLoopState("persisted-session")).toBeUndefined();
+      expect(reloadedStore.isActive("persisted-session")).toBeFalse();
+    });
+  });
+
+  describe("createLoopHandler", () => {
+    async function runIdle(
+      handler: (input: unknown) => Promise<void>,
+      sessionID: string,
+    ): Promise<void> {
+      await handler({ event: { type: "session.idle", properties: { sessionID } } });
+    }
+
+    it("continues loop iterations until max is reached", async () => {
+      const store = new MemoryLoopStore();
+      const sentMessages: string[] = [];
+      const handler = createLoopHandler(store, {
+        detectCompletion: () => false,
+        sendContinuationMessage: (_sessionId, message) => {
+          sentMessages.push(message);
+        },
+      });
+
+      store.startLoop("handler-max", { maxIterations: 2 });
+      await runIdle(handler, "handler-max");
+      await runIdle(handler, "handler-max");
+      await runIdle(handler, "handler-max");
+
+      expect(sentMessages).toHaveLength(2);
+      expect(sentMessages[0]).toContain("[SYSTEM DIRECTIVE: LOOP CONTINUE]");
+      expect(store.isActive("handler-max")).toBeFalse();
+    });
+
+    it("marks completion when detector returns true", async () => {
+      const store = new MemoryLoopStore();
+      const handler = createLoopHandler(store, { detectCompletion: () => true });
+
+      store.startLoop("handler-complete", { maxIterations: 5 });
+      await runIdle(handler, "handler-complete");
+
+      expect(store.isActive("handler-complete")).toBeFalse();
+      expect(store.getLoopState("handler-complete")?.completionDetected).toBeTrue();
+    });
+
+    it("uses default completion detector for <promise>DONE</promise>", async () => {
+      const store = new MemoryLoopStore();
+      const handler = createLoopHandler(store);
+
+      store.startLoop("handler-default", { maxIterations: 5 });
+      await handler({
+        event: {
+          type: "session.idle",
+          properties: {
+            sessionID: "handler-default",
+            lastAssistantMessage: "all done <promise>DONE</promise>",
+          },
+        },
+      });
+
+      expect(store.getLoopState("handler-default")?.completionDetected).toBeTrue();
+    });
+  });
+
+  describe("default routed store", () => {
+    let tempDir = "";
+    let stateFilePath = "";
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(join(tmpdir(), "goatcode-loop-router-"));
+      stateFilePath = join(tempDir, "loop-state.json");
+      memoryLoopStore.clearAllForTests();
+      fileLoopStore.setStateFilePathForTests(stateFilePath);
+      fileLoopStore.clearAllForTests(true);
+    });
+
+    afterEach(() => {
+      memoryLoopStore.clearAllForTests();
+      fileLoopStore.clearAllForTests(true);
+      if (tempDir) {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    it("routes persisted loops to file store", () => {
+      startLoop("persisted", { persist: true });
+
+      expect(fileLoopStore.getLoopState("persisted")?.persist).toBeTrue();
+      expect(memoryLoopStore.getLoopState("persisted")).toBeUndefined();
+      stopLoop("persisted");
+    });
+
+    it("routes non-persisted loops to memory store", () => {
+      startLoop("in-memory");
+
+      expect(memoryLoopStore.getLoopState("in-memory")?.persist).toBeFalse();
+      expect(fileLoopStore.getLoopState("in-memory")).toBeUndefined();
+      stopLoop("in-memory");
+    });
+  });
+});

package/src/features/loops/memory-store.ts

@@ -0,0 +1,53 @@
+import { log } from "../../shared/logger";
+import { createInitialLoopState, type LoopOptions, type LoopState, type LoopStore } from "./state";
+
+export class MemoryLoopStore implements LoopStore {
+  private readonly loopStates = new Map<string, LoopState>();
+
+  startLoop(sessionId: string, options?: LoopOptions): void {
+    const state = createInitialLoopState({ ...options, persist: false });
+    this.loopStates.set(sessionId, state);
+    log("[loop] started (memory)", { sessionId, maxIterations: state.maxIterations });
+  }
+
+  stopLoop(sessionId: string): void {
+    const existing = this.loopStates.get(sessionId);
+    if (!existing) {
+      return;
+    }
+
+    this.loopStates.delete(sessionId);
+    log("[loop] stopped (memory)", { sessionId, iteration: existing.iteration });
+  }
+
+  isActive(sessionId: string): boolean {
+    return this.loopStates.get(sessionId)?.active === true;
+  }
+
+  getLoopState(sessionId: string): LoopState | undefined {
+    const state = this.loopStates.get(sessionId);
+    return state ? { ...state } : undefined;
+  }
+
+  incrementIteration(sessionId: string): void {
+    const state = this.loopStates.get(sessionId);
+    if (!state || !state.active || state.completionDetected) {
+      return;
+    }
+
+    this.loopStates.set(sessionId, { ...state, iteration: state.iteration + 1 });
+  }
+
+  markCompletionDetected(sessionId: string): void {
+    const state = this.loopStates.get(sessionId);
+    if (!state) {
+      return;
+    }
+
+    this.loopStates.set(sessionId, { ...state, active: false, completionDetected: true });
+  }
+
+  clearAllForTests(): void {
+    this.loopStates.clear();
+  }
+}

package/src/features/loops/plugin.ts

@@ -0,0 +1,107 @@
+import { definePlugin } from "../../plugin-api";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { FileLoopStore } from "./file-store";
+import { createLoopHandler, type LoopHandlerOptions } from "./handler";
+import { MemoryLoopStore } from "./memory-store";
+import { type LoopOptions, type LoopState, type LoopStore } from "./state";
+
+class RoutedLoopStore implements LoopStore {
+  constructor(
+    private readonly memoryStore: MemoryLoopStore,
+    private readonly fileStore: FileLoopStore,
+  ) {}
+
+  startLoop(sessionId: string, options?: LoopOptions): void {
+    if (options?.persist) {
+      this.memoryStore.stopLoop(sessionId);
+      this.fileStore.startLoop(sessionId, options);
+      return;
+    }
+
+    this.fileStore.stopLoop(sessionId);
+    this.memoryStore.startLoop(sessionId, options);
+  }
+
+  stopLoop(sessionId: string): void {
+    this.fileStore.stopLoop(sessionId);
+    this.memoryStore.stopLoop(sessionId);
+  }
+
+  isActive(sessionId: string): boolean {
+    return this.fileStore.isActive(sessionId) || this.memoryStore.isActive(sessionId);
+  }
+
+  getLoopState(sessionId: string): LoopState | undefined {
+    return this.fileStore.getLoopState(sessionId) ?? this.memoryStore.getLoopState(sessionId);
+  }
+
+  incrementIteration(sessionId: string): void {
+    this.fileStore.incrementIteration(sessionId);
+    this.memoryStore.incrementIteration(sessionId);
+  }
+
+  markCompletionDetected(sessionId: string): void {
+    this.fileStore.markCompletionDetected(sessionId);
+    this.memoryStore.markCompletionDetected(sessionId);
+  }
+
+  clearForTests(clearPersistedFile = false): void {
+    this.memoryStore.clearAllForTests();
+    this.fileStore.clearAllForTests(clearPersistedFile);
+  }
+
+  configureFilePathForTests(filePath: string): void {
+    this.fileStore.setStateFilePathForTests(filePath);
+  }
+
+  loadPersistedForTests(): void {
+    this.fileStore.loadPersistedStateForTests();
+  }
+}
+
+export const memoryLoopStore = new MemoryLoopStore();
+export const fileLoopStore = new FileLoopStore();
+export const defaultLoopStore = new RoutedLoopStore(memoryLoopStore, fileLoopStore);
+
+export function startLoop(sessionId: string, options?: LoopOptions): void {
+  defaultLoopStore.startLoop(sessionId, options);
+}
+
+export function stopLoop(sessionId: string): void {
+  defaultLoopStore.stopLoop(sessionId);
+}
+
+export function isLoopActive(sessionId: string): boolean {
+  return defaultLoopStore.isActive(sessionId);
+}
+
+export function getLoopState(sessionId: string): LoopState | undefined {
+  return defaultLoopStore.getLoopState(sessionId);
+}
+
+export function clearLoopStateForTests(clearPersistedFile = false): void {
+  defaultLoopStore.clearForTests(clearPersistedFile);
+}
+
+export function configureLoopStateFilePathForTests(filePath: string): void {
+  defaultLoopStore.configureFilePathForTests(filePath);
+}
+
+export function loadPersistedLoopStateForTests(): void {
+  defaultLoopStore.loadPersistedForTests();
+}
+
+export function createLoopPlugin(options?: LoopHandlerOptions) {
+  const eventHook = safeCreateHook("loop", () => createLoopHandler(defaultLoopStore, options));
+
+  return definePlugin({
+    name: "loop",
+    version: "0.1.0",
+    hooks: eventHook ? { event: eventHook } : {},
+  });
+}
+
+/**
+ * Default plugin registration. The host injects sendContinuationMessage at runtime via createLoopPlugin().
+ */
+export const loopPlugin = createLoopPlugin();

package/src/features/loops/shared/event-utils.ts

@@ -0,0 +1,50 @@
+export interface HookEvent {
+  type?: unknown;
+  properties?: unknown;
+}
+
+type HookInput = { event?: HookEvent };
+
+export function asEvent(input: unknown): HookEvent | null {
+  if (typeof input !== "object" || input === null) {
+    return null;
+  }
+
+  const value = (input as HookInput).event;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+
+  return value;
+}
+
+export function getSessionId(properties: unknown): string | null {
+  if (!properties || typeof properties !== "object") {
+    return null;
+  }
+
+  const value = properties as Record<string, unknown>;
+  const sessionID = value.sessionID;
+  const sessionId = value.sessionId;
+  if (typeof sessionID === "string") return sessionID;
+  if (typeof sessionId === "string") return sessionId;
+  return null;
+}
+
+export function defaultCompletionDetector(event: HookEvent, completionPromise: string): boolean {
+  if (!event.properties || typeof event.properties !== "object") {
+    return false;
+  }
+
+  const props = event.properties as Record<string, unknown>;
+  if (props.completionDetected === true) {
+    return true;
+  }
+
+  const lastAssistantMessage = props.lastAssistantMessage;
+  if (typeof lastAssistantMessage !== "string") {
+    return false;
+  }
+
+  return lastAssistantMessage.includes(`<promise>${completionPromise}</promise>`);
+}

package/src/features/loops/state.ts

@@ -0,0 +1,44 @@
+export interface LoopOptions {
+  persist?: boolean;
+  maxIterations?: number;
+}
+
+export interface LoopState {
+  active: boolean;
+  iteration: number;
+  maxIterations: number;
+  completionDetected: boolean;
+  persist: boolean;
+}
+
+export interface LoopStore {
+  startLoop(sessionId: string, options?: LoopOptions): void;
+  stopLoop(sessionId: string): void;
+  isActive(sessionId: string): boolean;
+  getLoopState(sessionId: string): LoopState | undefined;
+  incrementIteration(sessionId: string): void;
+  markCompletionDetected(sessionId: string): void;
+}
+
+export const DEFAULT_MAX_ITERATIONS = 100;
+export const UNBOUNDED_MAX_ITERATIONS = 1000;
+
+export function createInitialLoopState(options?: LoopOptions): LoopState {
+  const persist = options?.persist ?? false;
+  const configuredMaxIterations = options?.maxIterations;
+  if (
+    configuredMaxIterations !== undefined &&
+    (!Number.isSafeInteger(configuredMaxIterations) || configuredMaxIterations <= 0)
+  ) {
+    throw new RangeError("maxIterations must be a positive safe integer");
+  }
+
+  return {
+    active: true,
+    iteration: 0,
+    maxIterations:
+      configuredMaxIterations ?? (persist ? UNBOUNDED_MAX_ITERATIONS : DEFAULT_MAX_ITERATIONS),
+    completionDetected: false,
+    persist,
+  };
+}

package/src/features/prompt-builder/agent-table-builder.ts

@@ -0,0 +1,23 @@
+export interface AgentTableEntry {
+  name: string;
+  description: string;
+  whenToUse: string;
+}
+
+const TABLE_HEADER = "| Agent | Description | When to Use |";
+const TABLE_SEPARATOR = "|-------|-------------|-------------|";
+
+function escapeTableCell(value: string): string {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+}
+
+export function buildAgentTable(agents: AgentTableEntry[]): string {
+  if (agents.length === 0) return "";
+
+  const rows = agents.map((agent) => {
+    const desc = agent.description.split(".")[0] || agent.description;
+    return `| \`${escapeTableCell(agent.name)}\` | ${escapeTableCell(desc)} | ${escapeTableCell(agent.whenToUse)} |`;
+  });
+
+  return ["### Available Agents", "", TABLE_HEADER, TABLE_SEPARATOR, ...rows].join("\n");
+}

package/src/features/prompt-builder/category-section-builder.ts

@@ -0,0 +1,21 @@
+import type { AvailableCategory } from "../../types/category";
+
+export function buildCategoriesSection(categories: AvailableCategory[]): string {
+  if (categories.length === 0) return "";
+
+  const rows = categories.map((cat) => {
+    const model = cat.model ?? "default";
+    const safeDescription = cat.description.replace(/\|/g, "\\|");
+    return `| \`${cat.name}\` | ${safeDescription} | ${model} |`;
+  });
+
+  return [
+    "### Category Mapping",
+    "",
+    "Each category routes to a model optimized for that domain.",
+    "",
+    "| Category | Description | Model |",
+    "|----------|-------------|-------|",
+    ...rows,
+  ].join("\n");
+}

package/src/features/prompt-builder/dynamic-prompt-builder.ts

@@ -0,0 +1,42 @@
+import type { AvailableCategory } from "../../types/category";
+import { ORCHESTRATOR_PROMPT } from "../../agents/orchestrator/prompt";
+import { log } from "../../shared/logger";
+import { buildAgentTable } from "./agent-table-builder";
+import type { AgentTableEntry } from "./agent-table-builder";
+import { buildSkillsSection } from "./skill-section-builder";
+import type { SkillEntry } from "./skill-section-builder";
+import { buildCategoriesSection } from "./category-section-builder";
+
+export interface DynamicPromptInput {
+  agents: AgentTableEntry[];
+  skills: SkillEntry[];
+  categories: AvailableCategory[];
+}
+
+export function buildDynamicPrompt(input: DynamicPromptInput): string {
+  const sections: string[] = [ORCHESTRATOR_PROMPT];
+
+  const agentSection = buildAgentTable(input.agents);
+  if (agentSection) {
+    sections.push(agentSection);
+  }
+
+  const skillsSection = buildSkillsSection(input.skills);
+  if (skillsSection) {
+    sections.push(skillsSection);
+  }
+
+  const categoriesSection = buildCategoriesSection(input.categories);
+  if (categoriesSection) {
+    sections.push(categoriesSection);
+  }
+
+  const agentCount = input.agents.length;
+  const skillCount = input.skills.length;
+  const categoryCount = input.categories.length;
+  log(
+    `[PromptBuilder] Built dynamic prompt: ${agentCount} agents, ${skillCount} skills, ${categoryCount} categories`,
+  );
+
+  return sections.join("\n\n");
+}

package/src/features/prompt-builder/index.ts

@@ -0,0 +1,7 @@
+export type { AgentTableEntry } from "./agent-table-builder";
+export { buildAgentTable } from "./agent-table-builder";
+export type { SkillEntry } from "./skill-section-builder";
+export { buildSkillsSection } from "./skill-section-builder";
+export { buildCategoriesSection } from "./category-section-builder";
+export type { DynamicPromptInput } from "./dynamic-prompt-builder";
+export { buildDynamicPrompt } from "./dynamic-prompt-builder";