goatcode-sh 0.0.1 → 0.1.3

package/src/hooks/safe-hook-wrapper.ts

@@ -0,0 +1,12 @@
+import type { PluginHookHandler } from "../types/plugin";
+import { log } from "../shared/logger";
+
+export function wrapSafely(name: string, handler: PluginHookHandler): PluginHookHandler {
+  return async (input: unknown, output: unknown) => {
+    try {
+      await handler(input, output);
+    } catch (error) {
+      log(`[hook] Error in hook "${name}"`, { error });
+    }
+  };
+}

package/src/hooks/session-recovery/handler.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "bun:test";
+
+import { createSessionRecoveryHandler, SESSION_RECOVERY_MESSAGE } from "./handler";
+
+type UnknownHandler = (input: unknown) => Promise<void>;
+
+describe("createSessionRecoveryHandler", () => {
+  describe("#given a handler instance", () => {
+    const handler = createSessionRecoveryHandler() as unknown as UnknownHandler;
+
+    describe("#when event is session.error with a matching recovery pattern", () => {
+      it("#then sets recoveryContext on properties", async () => {
+        const properties: Record<string, unknown> = { error: "session crash detected" };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toBe(SESSION_RECOVERY_MESSAGE);
+      });
+    });
+
+    describe("#when event is session.error with 'connection reset'", () => {
+      it("#then sets recoveryContext", async () => {
+        const properties: Record<string, unknown> = { error: "connection reset by peer" };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toContain("[SESSION RECOVERY]");
+      });
+    });
+
+    describe("#when event is session.error but error does not match patterns", () => {
+      it("#then no recoveryContext is added", async () => {
+        const properties: Record<string, unknown> = { error: "unknown error happened" };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toBeUndefined();
+      });
+    });
+
+    describe("#when event type is not session.error", () => {
+      it("#then no-op", async () => {
+        const properties: Record<string, unknown> = { error: "session crash detected" };
+        const input = {
+          event: { type: "session.idle", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toBeUndefined();
+      });
+    });
+
+    describe("#when recoveryContext already contains the marker", () => {
+      it("#then does not double-append", async () => {
+        const properties: Record<string, unknown> = {
+          error: "session crash detected",
+          recoveryContext: SESSION_RECOVERY_MESSAGE,
+        };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toBe(SESSION_RECOVERY_MESSAGE);
+      });
+    });
+
+    describe("#when input is not a record", () => {
+      it("#then no-op", async () => {
+        await handler(null);
+      });
+    });
+
+    describe("#when error is an object with message property", () => {
+      it("#then extracts message for pattern matching", async () => {
+        const properties: Record<string, unknown> = {
+          error: { message: "socket hang up" },
+        };
+        const input = {
+          event: { type: "session.error", properties },
+        };
+        await handler(input);
+        expect(properties.recoveryContext).toContain("[SESSION RECOVERY]");
+      });
+    });
+  });
+});

package/src/hooks/session-recovery/handler.ts

@@ -0,0 +1,87 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+export const SESSION_RECOVERY_PATTERNS = [
+  /session.*crash/i,
+  /session.*disconnect/i,
+  /connection reset/i,
+  /socket hang up/i,
+  /network.*interrupted/i,
+] as const;
+
+const SESSION_RECOVERY_MARKER = "[SESSION RECOVERY]";
+
+export const SESSION_RECOVERY_MESSAGE = `${SESSION_RECOVERY_MARKER}\nSession interruption detected. Reuse the latest confirmed state, avoid replaying completed tool calls, and continue from the last successful step.`;
+
+type EventHook = NonNullable<PluginHookContributions["event"]>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function extractErrorText(input: Record<string, unknown>): string {
+  const event = input.event;
+  if (!isRecord(event)) {
+    return "";
+  }
+
+  const properties = event.properties;
+  if (!isRecord(properties)) {
+    return "";
+  }
+
+  const rawError = properties.error;
+  if (typeof rawError === "string") {
+    return rawError;
+  }
+
+  if (isRecord(rawError) && typeof rawError.message === "string") {
+    return rawError.message;
+  }
+
+  return "";
+}
+
+function appendRecoveryContext(properties: Record<string, unknown>, message: string): void {
+  const existing = properties.recoveryContext;
+  if (typeof existing === "string" && existing.includes(SESSION_RECOVERY_MARKER)) {
+    return;
+  }
+
+  if (typeof existing === "string" && existing.length > 0) {
+    properties.recoveryContext = `${existing}\n${message}`;
+    return;
+  }
+
+  properties.recoveryContext = message;
+}
+
+export function createSessionRecoveryHandler(): EventHook {
+  return async (input: unknown) => {
+    if (!isRecord(input)) {
+      return;
+    }
+
+    const event = input.event;
+    if (!isRecord(event) || event.type !== "session.error") {
+      return;
+    }
+
+    const properties = event.properties;
+    if (!isRecord(properties)) {
+      return;
+    }
+
+    const errorText = extractErrorText(input);
+    const isRecoverableSessionError = SESSION_RECOVERY_PATTERNS.some((pattern) =>
+      pattern.test(errorText),
+    );
+
+    if (!isRecoverableSessionError) {
+      return;
+    }
+
+    appendRecoveryContext(properties, SESSION_RECOVERY_MESSAGE);
+    log("[session-recovery] injected session recovery context");
+  };
+}

package/src/hooks/session-recovery/index.ts

@@ -0,0 +1,6 @@
+export { sessionRecoveryPlugin } from "./plugin";
+export {
+  createSessionRecoveryHandler,
+  SESSION_RECOVERY_PATTERNS,
+  SESSION_RECOVERY_MESSAGE,
+} from "./handler";

package/src/hooks/session-recovery/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createSessionRecoveryHandler } from "./handler";
+
+const eventHook = safeCreateHook("session-recovery", createSessionRecoveryHandler);
+
+export const sessionRecoveryPlugin = definePlugin({
+  name: "session-recovery",
+  version: "0.1.0",
+  hooks: eventHook
+    ? {
+        event: eventHook,
+      }
+    : {},
+});

package/src/hooks/skill-discovery/plugin.ts

@@ -0,0 +1,45 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { getAvailableSkills } from "../../tools/skill/handler";
+
+function buildSkillsSystemBlock(): string | null {
+  const skills = getAvailableSkills();
+  if (skills.length === 0) return null;
+
+  const lines = skills.map((s) => `- **${s.name}**`);
+
+  return [
+    "## Available Skills",
+    "",
+    "Use the `skill` tool to load any of these skills by name:",
+    ...lines,
+  ].join("\n");
+}
+
+export const skillDiscoveryPlugin = definePlugin({
+  name: "skill-discovery",
+  version: "0.1.0",
+  hooks: {
+    "experimental.chat.system.transform": async (
+      _input: { sessionID?: string; model: unknown },
+      output: { system: string[] },
+    ) => {
+      const block = buildSkillsSystemBlock();
+      if (block) {
+        output.system.push(block);
+      }
+    },
+    "tool.definition": async (
+      input: { toolID: string },
+      output: { description: string; parameters: unknown },
+    ) => {
+      if (input.toolID !== "skill") return;
+
+      const skills = getAvailableSkills();
+      if (skills.length === 0) return;
+
+      const listing = skills.map((s) => `  - ${s.name}`).join("\n");
+
+      output.description += `\n\nAvailable skills:\n${listing}`;
+    },
+  },
+});

package/src/hooks/stop-guard/handler.test.ts

@@ -0,0 +1,147 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearSessionStore,
+  getSessionState,
+  setSessionState,
+} from "../../features/session-state/session-store";
+import { createStopGuardHandler } from "./handler";
+
+type MutableTodoState = {
+  todos?: Array<{
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+  }>;
+};
+
+type GenericHook = (input: unknown) => Promise<void>;
+
+function seedTodos(sessionID: string, todos: NonNullable<MutableTodoState["todos"]>): void {
+  setSessionState(sessionID, { status: "active" });
+  const state = getSessionState(sessionID) as unknown as MutableTodoState | undefined;
+  if (!state) {
+    throw new Error(`Failed to seed session state for test (sessionID: ${sessionID})`);
+  }
+  state.todos = todos;
+}
+
+describe("createStopGuardHandler", () => {
+  beforeEach(() => {
+    clearSessionStore();
+  });
+
+  describe("#given a handler instance", () => {
+    describe("#when a stop-like message arrives with pending todos", () => {
+      it("#then injects a stopGuardMessage referencing the next todo", async () => {
+        const sessionID = "ses-stop-pending";
+        seedTodos(sessionID, [{ content: "Finish verification step", status: "pending" }]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          sessionID,
+          message: "I'm done.",
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(typeof input.stopGuardMessage).toBe("string");
+        expect(String(input.stopGuardMessage)).toContain("Finish verification step");
+        expect(String(input.stopGuardMessage)).toContain("stop-guard");
+      });
+    });
+
+    describe("#when message matches 'task complete' pattern", () => {
+      it("#then also triggers the guard", async () => {
+        const sessionID = "ses-stop-taskcomplete";
+        seedTodos(sessionID, [{ content: "Run final build", status: "in_progress" }]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          sessionID,
+          message: "Task complete, moving on.",
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(typeof input.stopGuardMessage).toBe("string");
+        expect(String(input.stopGuardMessage)).toContain("Run final build");
+      });
+    });
+
+    describe("#when message matches 'all done' pattern", () => {
+      it("#then triggers for this stop pattern too", async () => {
+        const sessionID = "ses-stop-alldone";
+        seedTodos(sessionID, [{ content: "Deploy to staging", status: "pending" }]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          sessionID,
+          content: "All done here!",
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(typeof input.stopGuardMessage).toBe("string");
+        expect(String(input.stopGuardMessage)).toContain("Deploy to staging");
+      });
+    });
+
+    describe("#when a non-stop message arrives with pending todos", () => {
+      it("#then does not inject a guard message", async () => {
+        const sessionID = "ses-stop-normal";
+        seedTodos(sessionID, [{ content: "Some pending work", status: "pending" }]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          sessionID,
+          message: "Please continue working on the next item.",
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(input.stopGuardMessage).toBeUndefined();
+      });
+    });
+
+    describe("#when a stop-like message arrives but no pending todos", () => {
+      it("#then does not inject a guard message", async () => {
+        const sessionID = "ses-stop-empty";
+        seedTodos(sessionID, [
+          { content: "Already done", status: "completed" },
+          { content: "Cancelled item", status: "cancelled" },
+        ]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          sessionID,
+          message: "I'm done.",
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(input.stopGuardMessage).toBeUndefined();
+      });
+    });
+
+    describe("#when sessionID is on the nested message object", () => {
+      it("#then resolves the sessionID from message.sessionID", async () => {
+        const sessionID = "ses-stop-nested";
+        seedTodos(sessionID, [{ content: "Pending nested", status: "pending" }]);
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = {
+          message: { sessionID, content: "Work is complete now." },
+        } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(typeof input.stopGuardMessage).toBe("string");
+        expect(String(input.stopGuardMessage)).toContain("Pending nested");
+      });
+    });
+
+    describe("#when input has no sessionID at all", () => {
+      it("#then does nothing", async () => {
+        const handler = createStopGuardHandler() as unknown as GenericHook;
+        const input = { message: "I'm done." } as Record<string, unknown>;
+
+        await handler(input);
+
+        expect(input.stopGuardMessage).toBeUndefined();
+      });
+    });
+  });
+});

package/src/hooks/stop-guard/handler.ts

@@ -0,0 +1,127 @@
+import { getSessionState } from "../../runtime";
+import { log } from "../../shared/logger";
+import type { PluginHookContributions } from "../../types/hook";
+
+type ChatMessageHook = NonNullable<PluginHookContributions["chat.message"]>;
+
+type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
+
+interface SessionTodo {
+  content: string;
+  status: TodoStatus;
+}
+
+const STOP_PATTERNS = [
+  /\bi['']?m done\b/i,
+  /\btask complete\b/i,
+  /\btasks? complete\b/i,
+  /\ball done\b/i,
+  /\bwork is complete\b/i,
+  /\bfinished (all tasks|the work|everything)\b/i,
+] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isTodoStatus(value: unknown): value is TodoStatus {
+  return (
+    value === "pending" || value === "in_progress" || value === "completed" || value === "cancelled"
+  );
+}
+
+function resolveSessionID(input: unknown): string | undefined {
+  if (!isRecord(input)) {
+    return undefined;
+  }
+
+  if (typeof input.sessionID === "string") {
+    return input.sessionID;
+  }
+
+  if (isRecord(input.message) && typeof input.message.sessionID === "string") {
+    return input.message.sessionID;
+  }
+
+  return undefined;
+}
+
+function resolveMessageText(input: unknown): string {
+  if (!isRecord(input)) {
+    return "";
+  }
+
+  if (typeof input.message === "string") {
+    return input.message;
+  }
+
+  if (typeof input.content === "string") {
+    return input.content;
+  }
+
+  if (isRecord(input.message) && typeof input.message.content === "string") {
+    return input.message.content;
+  }
+
+  return "";
+}
+
+function extractPendingTodos(sessionID: string): SessionTodo[] {
+  const state = getSessionState(sessionID);
+  if (!state) {
+    return [];
+  }
+
+  const todos = (state as unknown as { todos?: unknown }).todos;
+  if (!Array.isArray(todos)) {
+    return [];
+  }
+
+  return todos
+    .filter((todo): todo is SessionTodo => {
+      if (!isRecord(todo)) {
+        return false;
+      }
+      return typeof todo.content === "string" && isTodoStatus(todo.status);
+    })
+    .filter((todo) => todo.status === "pending" || todo.status === "in_progress");
+}
+
+function isStopLikeMessage(message: string): boolean {
+  return STOP_PATTERNS.some((pattern) => pattern.test(message));
+}
+
+function injectReminder(input: unknown, reminder: string): void {
+  if (!isRecord(input)) {
+    return;
+  }
+  input.stopGuardMessage = reminder;
+}
+
+export function createStopGuardHandler(): ChatMessageHook {
+  return async (input: unknown, ..._rest: unknown[]) => {
+    const sessionID = resolveSessionID(input);
+    if (!sessionID) {
+      return;
+    }
+
+    const message = resolveMessageText(input);
+    if (!isStopLikeMessage(message)) {
+      return;
+    }
+
+    const pendingTodos = extractPendingTodos(sessionID);
+    if (pendingTodos.length === 0) {
+      return;
+    }
+
+    const reminder = `[stop-guard] Completion claim detected, but ${pendingTodos.length} todo item(s) are still pending. Continue with: ${pendingTodos[0]?.content}`;
+    injectReminder(input, reminder);
+
+    log("[stop-guard] Blocked premature stop with pending todos", {
+      sessionID,
+      pendingCount: pendingTodos.length,
+      message,
+    });
+  };
+}

package/src/hooks/stop-guard/index.ts

@@ -0,0 +1,2 @@
+export { stopGuardPlugin } from "./plugin";
+export { createStopGuardHandler } from "./handler";

package/src/hooks/stop-guard/plugin.ts

@@ -0,0 +1,15 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createStopGuardHandler } from "./handler";
+
+const stopGuardHook = safeCreateHook("stop-guard", createStopGuardHandler);
+
+export const stopGuardPlugin = definePlugin({
+  name: "stop-guard",
+  version: "0.1.0",
+  hooks: stopGuardHook
+    ? {
+        "chat.message": stopGuardHook,
+      }
+    : {},
+});