goatcode-sh 0.0.1 → 0.1.3

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

@@ -0,0 +1,244 @@
+import { describe, expect, it } from "bun:test";
+
+import type { AgentTableEntry } from "./agent-table-builder";
+import { buildAgentTable } from "./agent-table-builder";
+import type { SkillEntry } from "./skill-section-builder";
+import { buildSkillsSection } from "./skill-section-builder";
+import { buildCategoriesSection } from "./category-section-builder";
+import { buildDynamicPrompt } from "./dynamic-prompt-builder";
+import { ORCHESTRATOR_PROMPT } from "../../agents/orchestrator/prompt";
+import type { AvailableCategory } from "../../types/category";
+
+const SAMPLE_AGENTS: AgentTableEntry[] = [
+  {
+    name: "explorer",
+    description: "Searches the codebase for patterns.",
+    whenToUse: "Need to find code references",
+  },
+  {
+    name: "deep-worker",
+    description: "Autonomous implementation agent.",
+    whenToUse: "Complex multi-file changes",
+  },
+  {
+    name: "advisor",
+    description: "Read-only architecture consultant.",
+    whenToUse: "Design decisions and debugging",
+  },
+];
+
+const SAMPLE_SKILLS: SkillEntry[] = [
+  { name: "playwright", description: "Browser automation and testing." },
+  { name: "git-master", description: "Atomic commits and rebase surgery." },
+];
+
+const SAMPLE_CATEGORIES: AvailableCategory[] = [
+  { name: "visual-engineering", description: "Frontend and UI/UX work", model: "gpt-5.3-codex" },
+  { name: "ultrabrain", description: "Hard logic and architecture", model: "gpt-5.4" },
+  { name: "quick", description: "Trivial single-file fixes", model: "gpt-5-nano" },
+];
+
+describe("prompt-builder", () => {
+  describe("#given buildAgentTable", () => {
+    describe("#when called with agents", () => {
+      it("#then returns markdown table containing all agent names", () => {
+        //#given
+        const agents = SAMPLE_AGENTS;
+
+        //#when
+        const result = buildAgentTable(agents);
+
+        //#then
+        expect(result).toContain("explorer");
+        expect(result).toContain("deep-worker");
+        expect(result).toContain("advisor");
+        expect(result).toContain("| Agent | Description | When to Use |");
+      });
+
+      it("#then truncates descriptions at the first period", () => {
+        //#given
+        const agents: AgentTableEntry[] = [
+          {
+            name: "test-agent",
+            description: "First sentence. Second sentence.",
+            whenToUse: "Always",
+          },
+        ];
+
+        //#when
+        const result = buildAgentTable(agents);
+
+        //#then
+        expect(result).toContain("First sentence");
+        expect(result).not.toContain("Second sentence");
+      });
+
+      it("#then returns full description when no period present", () => {
+        //#given
+        const agents: AgentTableEntry[] = [
+          { name: "test-agent", description: "No period here", whenToUse: "Always" },
+        ];
+
+        //#when
+        const result = buildAgentTable(agents);
+
+        //#then
+        expect(result).toContain("No period here");
+      });
+    });
+
+    describe("#when called with empty array", () => {
+      it("#then returns empty string", () => {
+        //#given #when
+        const result = buildAgentTable([]);
+
+        //#then
+        expect(result).toBe("");
+      });
+    });
+  });
+
+  describe("#given buildSkillsSection", () => {
+    describe("#when called with skills", () => {
+      it("#then returns section containing all skill names", () => {
+        //#given
+        const skills = SAMPLE_SKILLS;
+
+        //#when
+        const result = buildSkillsSection(skills);
+
+        //#then
+        expect(result).toContain("playwright");
+        expect(result).toContain("git-master");
+        expect(result).toContain("### Available Skills");
+      });
+    });
+
+    describe("#when called with empty array", () => {
+      it("#then returns empty string", () => {
+        //#given #when
+        const result = buildSkillsSection([]);
+
+        //#then
+        expect(result).toBe("");
+      });
+    });
+  });
+
+  describe("#given buildCategoriesSection", () => {
+    describe("#when called with categories", () => {
+      it("#then returns table with category names and models", () => {
+        //#given
+        const categories = SAMPLE_CATEGORIES;
+
+        //#when
+        const result = buildCategoriesSection(categories);
+
+        //#then
+        expect(result).toContain("visual-engineering");
+        expect(result).toContain("gpt-5.3-codex");
+        expect(result).toContain("ultrabrain");
+        expect(result).toContain("gpt-5.4");
+        expect(result).toContain("quick");
+        expect(result).toContain("gpt-5-nano");
+      });
+
+      it("#then shows 'default' when model is undefined", () => {
+        //#given
+        const categories: AvailableCategory[] = [
+          { name: "unspecified-low", description: "General purpose" },
+        ];
+
+        //#when
+        const result = buildCategoriesSection(categories);
+
+        //#then
+        expect(result).toContain("default");
+      });
+
+      it("#then escapes pipe characters in descriptions", () => {
+        //#given
+        const categories: AvailableCategory[] = [
+          { name: "test-cat", description: "Contains | pipe character", model: "gpt-5" },
+        ];
+
+        //#when
+        const result = buildCategoriesSection(categories);
+
+        //#then
+        expect(result).toContain("Contains \\| pipe character");
+        expect(result).not.toContain("Contains | pipe character");
+      });
+    });
+
+    describe("#when called with empty array", () => {
+      it("#then returns empty string", () => {
+        //#given #when
+        const result = buildCategoriesSection([]);
+
+        //#then
+        expect(result).toBe("");
+      });
+    });
+  });
+
+  describe("#given buildDynamicPrompt", () => {
+    describe("#when called with agents, skills, and categories", () => {
+      it("#then composes prompt containing base orchestrator prompt and all sections", () => {
+        //#given
+        const input = {
+          agents: SAMPLE_AGENTS,
+          skills: SAMPLE_SKILLS,
+          categories: SAMPLE_CATEGORIES,
+        };
+
+        //#when
+        const result = buildDynamicPrompt(input);
+
+        //#then
+        expect(result).toContain(ORCHESTRATOR_PROMPT);
+        expect(result).toContain("explorer");
+        expect(result).toContain("deep-worker");
+        expect(result).toContain("playwright");
+        expect(result).toContain("git-master");
+        expect(result).toContain("visual-engineering");
+        expect(result).toContain("gpt-5.3-codex");
+      });
+    });
+
+    describe("#when called with empty inputs", () => {
+      it("#then returns only the base orchestrator prompt", () => {
+        //#given
+        const input = { agents: [], skills: [], categories: [] };
+
+        //#when
+        const result = buildDynamicPrompt(input);
+
+        //#then
+        expect(result).toBe(ORCHESTRATOR_PROMPT);
+        expect(result).not.toContain("### Available Agents");
+        expect(result).not.toContain("### Available Skills");
+        expect(result).not.toContain("### Category Mapping");
+      });
+    });
+
+    describe("#when called with partial inputs", () => {
+      it("#then includes only populated sections", () => {
+        //#given
+        const input = {
+          agents: SAMPLE_AGENTS,
+          skills: [],
+          categories: [],
+        };
+
+        //#when
+        const result = buildDynamicPrompt(input);
+
+        //#then
+        expect(result).toContain("### Available Agents");
+        expect(result).not.toContain("### Available Skills");
+        expect(result).not.toContain("### Category Mapping");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,25 @@
+export interface SkillEntry {
+  name: string;
+  description: string;
+}
+
+function normaliseInline(value: string): string {
+  return value.replace(/\r?\n/g, " ").trim();
+}
+
+export function buildSkillsSection(skills: SkillEntry[]): string {
+  if (skills.length === 0) return "";
+
+  const items = skills.map((skill) => {
+    const shortDesc = skill.description.split(".")[0] || skill.description;
+    return `- \`${normaliseInline(skill.name)}\`: ${normaliseInline(shortDesc)}`;
+  });
+
+  return [
+    "### Available Skills",
+    "",
+    "Use the `skill` tool to load a skill before delegating work.",
+    "",
+    ...items,
+  ].join("\n");
+}

package/src/features/session-state/index.ts

@@ -0,0 +1,17 @@
+export {
+  setSessionState,
+  getSessionState,
+  deleteSessionState,
+  clearSessionStore,
+} from "./session-store";
+export type { SessionState } from "./session-store";
+
+export { consumeNewMessages, resetMessageCursor } from "./session-cursor";
+export type { CursorMessage } from "./session-cursor";
+
+export {
+  setSessionTools,
+  getSessionTools,
+  deleteSessionTools,
+  clearSessionTools,
+} from "./session-tools-store";

package/src/features/session-state/session-cursor.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { consumeNewMessages, resetMessageCursor } from "./session-cursor";
+
+describe("session-cursor", () => {
+  beforeEach(() => {
+    resetMessageCursor();
+  });
+
+  describe("#given no prior cursor state", () => {
+    describe("#when consumeNewMessages is called with messages", () => {
+      it("#then returns all messages on first call", () => {
+        const messages = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+        ];
+
+        const result = consumeNewMessages("session-1", messages);
+        expect(result).toHaveLength(3);
+        expect(result).toEqual(messages);
+      });
+    });
+
+    describe("#when consumeNewMessages is called with empty array", () => {
+      it("#then returns empty array", () => {
+        const result = consumeNewMessages("session-1", []);
+        expect(result).toHaveLength(0);
+      });
+    });
+
+    describe("#when sessionId is undefined", () => {
+      it("#then returns all messages without tracking", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+        const result = consumeNewMessages(undefined, messages);
+        expect(result).toHaveLength(2);
+      });
+    });
+  });
+
+  describe("#given messages already consumed", () => {
+    describe("#when consumeNewMessages is called again with same messages", () => {
+      it("#then returns empty array (no new messages)", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+
+        consumeNewMessages("session-2", messages);
+        const result = consumeNewMessages("session-2", messages);
+
+        expect(result).toHaveLength(0);
+      });
+    });
+
+    describe("#when consumeNewMessages is called with additional messages", () => {
+      it("#then returns only the new messages", () => {
+        const initial = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+        const extended = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+          { info: { id: "msg-4" } },
+        ];
+
+        consumeNewMessages("session-3", initial);
+        const result = consumeNewMessages("session-3", extended);
+
+        expect(result).toHaveLength(2);
+        expect(result[0].info?.id).toBe("msg-3");
+        expect(result[1].info?.id).toBe("msg-4");
+      });
+    });
+
+    describe("#when message list shrinks (history reset)", () => {
+      it("#then returns all messages from the beginning", () => {
+        const large = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+        ];
+        const small = [{ info: { id: "msg-new-1" } }];
+
+        consumeNewMessages("session-4", large);
+        const result = consumeNewMessages("session-4", small);
+
+        expect(result).toHaveLength(1);
+        expect(result[0].info?.id).toBe("msg-new-1");
+      });
+    });
+  });
+
+  describe("#given messages with timestamp-based keys", () => {
+    describe("#when consumeNewMessages is called with time-based messages", () => {
+      it("#then tracks cursor by timestamp", () => {
+        const initial = [{ info: { time: 1000 } }, { info: { time: 2000 } }];
+        const extended = [
+          { info: { time: 1000 } },
+          { info: { time: 2000 } },
+          { info: { time: 3000 } },
+        ];
+
+        consumeNewMessages("session-5", initial);
+        const result = consumeNewMessages("session-5", extended);
+
+        expect(result).toHaveLength(1);
+        expect(result[0].info?.time).toBe(3000);
+      });
+    });
+  });
+
+  describe("#given a cursor that was reset", () => {
+    describe("#when resetMessageCursor is called for a specific session", () => {
+      it("#then that session returns all messages again", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+
+        consumeNewMessages("session-6", messages);
+        resetMessageCursor("session-6");
+
+        const result = consumeNewMessages("session-6", messages);
+        expect(result).toHaveLength(2);
+      });
+    });
+
+    describe("#when resetMessageCursor is called without session ID", () => {
+      it("#then all sessions return all messages again", () => {
+        const messages = [{ info: { id: "msg-1" } }];
+
+        consumeNewMessages("session-7", messages);
+        consumeNewMessages("session-8", messages);
+        resetMessageCursor();
+
+        const result7 = consumeNewMessages("session-7", messages);
+        const result8 = consumeNewMessages("session-8", messages);
+
+        expect(result7).toHaveLength(1);
+        expect(result8).toHaveLength(1);
+      });
+    });
+  });
+});

package/src/features/session-state/session-cursor.ts

@@ -0,0 +1,80 @@
+type MessageTime = { created?: number | string } | number | string | undefined;
+
+type MessageInfo = {
+  id?: string;
+  time?: MessageTime;
+};
+
+export type CursorMessage = {
+  info?: MessageInfo;
+};
+
+interface CursorState {
+  lastKey?: string;
+  lastCount: number;
+}
+
+const sessionCursors = new Map<string, CursorState>();
+
+function buildMessageKey(message: CursorMessage, index: number): string {
+  const id = message.info?.id;
+  if (id) return `id:${id}`;
+
+  const time = message.info?.time;
+  if (typeof time === "number" || typeof time === "string") {
+    return `t:${time}:${index}`;
+  }
+
+  const created = (time as { created?: number | string } | undefined)?.created;
+  if (typeof created === "number") {
+    return `t:${created}:${index}`;
+  }
+  if (typeof created === "string") {
+    return `t:${created}:${index}`;
+  }
+
+  return `i:${index}`;
+}
+
+export function consumeNewMessages<T extends CursorMessage>(
+  sessionId: string | undefined,
+  messages: T[],
+): T[] {
+  if (!sessionId) return messages;
+
+  const keys = messages.map((message, index) => buildMessageKey(message, index));
+  const cursor = sessionCursors.get(sessionId);
+  let startIndex = 0;
+
+  if (cursor) {
+    if (cursor.lastCount > messages.length) {
+      startIndex = 0;
+    } else if (cursor.lastKey) {
+      const lastIndex = keys.lastIndexOf(cursor.lastKey);
+      if (lastIndex >= 0) {
+        startIndex = lastIndex + 1;
+      } else {
+        startIndex = 0;
+      }
+    }
+  }
+
+  if (messages.length === 0) {
+    sessionCursors.delete(sessionId);
+  } else {
+    sessionCursors.set(sessionId, {
+      lastKey: keys[keys.length - 1],
+      lastCount: messages.length,
+    });
+  }
+
+  return messages.slice(startIndex);
+}
+
+export function resetMessageCursor(sessionId?: string): void {
+  if (sessionId) {
+    sessionCursors.delete(sessionId);
+    return;
+  }
+  sessionCursors.clear();
+}

package/src/features/session-state/session-store.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+  setSessionState,
+  getSessionState,
+  deleteSessionState,
+  clearSessionStore,
+} from "./session-store";
+
+describe("session-store", () => {
+  beforeEach(() => {
+    clearSessionStore();
+  });
+
+  describe("#given a new session ID", () => {
+    describe("#when setSessionState is called", () => {
+      it("#then creates a new session entry with defaults", () => {
+        const before = Date.now();
+        setSessionState("session-1", { model: "claude-opus", status: "active" });
+        const after = Date.now();
+
+        const state = getSessionState("session-1");
+        expect(state).toBeDefined();
+        expect(state?.sessionId).toBe("session-1");
+        expect(state?.model).toBe("claude-opus");
+        expect(state?.status).toBe("active");
+        expect(state?.createdAt).toBeGreaterThanOrEqual(before);
+        expect(state?.createdAt).toBeLessThanOrEqual(after);
+        expect(state?.updatedAt).toBeGreaterThanOrEqual(before);
+        expect(state?.updatedAt).toBeLessThanOrEqual(after);
+      });
+    });
+
+    describe("#when getSessionState is called before any set", () => {
+      it("#then returns undefined", () => {
+        const state = getSessionState("nonexistent");
+        expect(state).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given an existing session", () => {
+    describe("#when setSessionState is called again", () => {
+      it("#then updates fields while preserving createdAt", () => {
+        setSessionState("session-2", { model: "gpt-4", status: "active" });
+        const first = getSessionState("session-2");
+        const originalCreatedAt = first?.createdAt;
+
+        setSessionState("session-2", { status: "idle" });
+        const updated = getSessionState("session-2");
+
+        expect(updated?.createdAt).toBe(originalCreatedAt);
+        expect(updated?.status).toBe("idle");
+        expect(updated?.model).toBe("gpt-4");
+        expect(updated?.updatedAt).toBeGreaterThanOrEqual(first?.updatedAt ?? 0);
+      });
+    });
+
+    describe("#when deleteSessionState is called", () => {
+      it("#then removes the session entry", () => {
+        setSessionState("session-3", { agent: "sisyphus" });
+        expect(getSessionState("session-3")).toBeDefined();
+
+        deleteSessionState("session-3");
+        expect(getSessionState("session-3")).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given multiple sessions", () => {
+    describe("#when clearSessionStore is called", () => {
+      it("#then removes all session entries", () => {
+        setSessionState("session-a", { model: "claude" });
+        setSessionState("session-b", { model: "gpt" });
+
+        clearSessionStore();
+
+        expect(getSessionState("session-a")).toBeUndefined();
+        expect(getSessionState("session-b")).toBeUndefined();
+      });
+    });
+  });
+});

package/src/features/session-state/session-store.ts

@@ -0,0 +1,37 @@
+export interface SessionState {
+  sessionId: string;
+  model?: string;
+  agent?: string;
+  status?: "active" | "idle" | "completed";
+  createdAt: number;
+  updatedAt: number;
+}
+
+const store = new Map<string, SessionState>();
+
+export function setSessionState(
+  sessionId: string,
+  state: Partial<Omit<SessionState, "sessionId" | "createdAt">>,
+): void {
+  const existing = store.get(sessionId);
+  const now = Date.now();
+  store.set(sessionId, {
+    ...existing,
+    ...state,
+    sessionId,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+  });
+}
+
+export function getSessionState(sessionId: string): SessionState | undefined {
+  return store.get(sessionId);
+}
+
+export function deleteSessionState(sessionId: string): void {
+  store.delete(sessionId);
+}
+
+export function clearSessionStore(): void {
+  store.clear();
+}

package/src/features/session-state/session-tools-store.ts

@@ -0,0 +1,18 @@
+const store = new Map<string, Record<string, boolean>>();
+
+export function setSessionTools(sessionId: string, tools: Record<string, boolean>): void {
+  store.set(sessionId, { ...tools });
+}
+
+export function getSessionTools(sessionId: string): Record<string, boolean> | undefined {
+  const tools = store.get(sessionId);
+  return tools ? { ...tools } : undefined;
+}
+
+export function deleteSessionTools(sessionId: string): void {
+  store.delete(sessionId);
+}
+
+export function clearSessionTools(): void {
+  store.clear();
+}