goatcode-sh 0.0.1 → 0.1.2

package/src/hooks/keyword-detector/handler.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { clearSessionMode, createKeywordDetectorHandler, getSessionMode } from "./handler";
+
+const SESSION_ID = "ses_test";
+
+function makeInput(sessionID: string = SESSION_ID) {
+  return { sessionID };
+}
+
+function makeOutput(text: string) {
+  return {
+    message: {},
+    parts: [{ type: "text", text }],
+  };
+}
+
+describe("createKeywordDetectorHandler", () => {
+  afterEach(() => {
+    clearSessionMode(SESSION_ID);
+  });
+
+  describe("#given a handler instance", () => {
+    const handler = createKeywordDetectorHandler();
+
+    describe("#when message contains 'ultrawork'", () => {
+      it("#then sets session mode to ultrawork", async () => {
+        const input = makeInput();
+        const output = makeOutput("let's ultrawork on this");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("ultrawork");
+      });
+    });
+
+    describe("#when message contains 'ulw' shorthand", () => {
+      it("#then sets session mode to ultrawork", async () => {
+        const input = makeInput();
+        const output = makeOutput("ulw this task");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("ultrawork");
+      });
+    });
+
+    describe("#when message contains 'deepthink'", () => {
+      it("#then sets session mode to think", async () => {
+        const input = makeInput();
+        const output = makeOutput("deepthink this problem");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("think");
+      });
+    });
+
+    describe("#when message contains 'deep-think'", () => {
+      it("#then sets session mode to think", async () => {
+        const input = makeInput();
+        const output = makeOutput("please deep-think about this");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("think");
+      });
+    });
+
+    describe("#when message contains 'fast'", () => {
+      it("#then sets session mode to fast", async () => {
+        const input = makeInput();
+        const output = makeOutput("do this fast");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBe("fast");
+      });
+    });
+
+    describe("#when keyword is inside a code block", () => {
+      it("#then does not set session mode", async () => {
+        const input = makeInput();
+        const output = makeOutput("check this: ```ultrawork```");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBeUndefined();
+      });
+    });
+
+    describe("#when keyword is inside inline code", () => {
+      it("#then does not set session mode", async () => {
+        const input = makeInput();
+        const output = makeOutput("the function `ultrawork` is defined here");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBeUndefined();
+      });
+    });
+
+    describe("#when message contains no keywords", () => {
+      it("#then does not set session mode", async () => {
+        const input = makeInput();
+        const output = makeOutput("hello world");
+
+        await handler(input, output);
+
+        expect(getSessionMode(SESSION_ID)).toBeUndefined();
+      });
+    });
+  });
+});

package/src/hooks/keyword-detector/handler.ts

@@ -0,0 +1,73 @@
+import type { PluginHookContributions } from "../../types/hook";
+import { log } from "../../shared/logger";
+
+export type ActiveMode = "ultrawork" | "think" | "fast";
+
+const sessionModes = new Map<string, ActiveMode>();
+
+export function getSessionMode(sessionId: string): ActiveMode | undefined {
+  return sessionModes.get(sessionId);
+}
+
+export function setSessionMode(sessionId: string, mode: ActiveMode): void {
+  sessionModes.set(sessionId, mode);
+}
+
+export function clearSessionMode(sessionId: string): void {
+  sessionModes.delete(sessionId);
+}
+
+type ChatMessageHook = NonNullable<PluginHookContributions["chat.message"]>;
+
+const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
+const INLINE_CODE_PATTERN = /`[^`]+`/g;
+
+const KEYWORD_MAP: Array<{ pattern: RegExp; mode: ActiveMode }> = [
+  { pattern: /\b(ultrawork|ulw)\b/i, mode: "ultrawork" },
+  { pattern: /\b(deep-think|deepthink|ultrathink)\b/i, mode: "think" },
+  { pattern: /\bfast\b/i, mode: "fast" },
+];
+
+function stripCodeBlocks(text: string): string {
+  return text.replace(CODE_BLOCK_PATTERN, "").replace(INLINE_CODE_PATTERN, "");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function extractPartsText(parts: unknown): string {
+  if (!Array.isArray(parts)) return "";
+  return parts
+    .filter(
+      (p): p is { type: string; text: string } =>
+        isRecord(p) && p.type === "text" && typeof p.text === "string",
+    )
+    .map((p) => p.text)
+    .join(" ");
+}
+
+function detectMode(text: string): ActiveMode | null {
+  const clean = stripCodeBlocks(text);
+  for (const { pattern, mode } of KEYWORD_MAP) {
+    if (pattern.test(clean)) {
+      return mode;
+    }
+  }
+  return null;
+}
+
+export function createKeywordDetectorHandler(): ChatMessageHook {
+  return async (input: unknown, output: unknown): Promise<void> => {
+    if (!isRecord(input) || !isRecord(output)) return;
+    const sessionID = input.sessionID;
+    if (typeof sessionID !== "string") return;
+
+    const text = extractPartsText(output.parts);
+    const mode = detectMode(text);
+    if (!mode) return;
+
+    sessionModes.set(sessionID, mode);
+    log(`[keyword-detector] mode "${mode}" set`, { sessionID });
+  };
+}

package/src/hooks/keyword-detector/index.ts

@@ -0,0 +1,8 @@
+export {
+  createKeywordDetectorHandler,
+  getSessionMode,
+  setSessionMode,
+  clearSessionMode,
+} from "./handler";
+export type { ActiveMode } from "./handler";
+export { keywordDetectorPlugin } from "./plugin";

package/src/hooks/keyword-detector/plugin.ts

@@ -0,0 +1,24 @@
+import { definePlugin } from "../../plugin-api/define-plugin";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createKeywordDetectorHandler, clearSessionMode } from "./handler";
+
+const chatMessageHook = safeCreateHook("keyword-detector", createKeywordDetectorHandler);
+
+export const keywordDetectorPlugin = definePlugin({
+  name: "keyword-detector",
+  version: "0.1.0",
+  hooks: chatMessageHook
+    ? {
+        "chat.message": chatMessageHook,
+        event: async (input) => {
+          const evt = (input as { event?: { type?: string; properties?: unknown } }).event;
+          if (evt?.type === "session.deleted") {
+            const props = evt.properties as Record<string, unknown> | undefined;
+            const sessionID = (props?.sessionID ??
+              (props?.info as Record<string, unknown> | undefined)?.id) as string | undefined;
+            if (sessionID) clearSessionMode(sessionID);
+          }
+        },
+      }
+    : {},
+});

package/src/hooks/model-fallback/handler.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it, mock } from "bun:test";
+import { createModelFallbackHandler } from "./handler";
+
+describe("createModelFallbackHandler", () => {
+  describe("#given a handler with a fallback chain", () => {
+    describe("#when a rate limit error (429) occurs", () => {
+      it("#then switches to the next model in the chain", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+        const onFallbackApplied = mock(() => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+          onFallbackApplied,
+        });
+
+        await handler({
+          event: {
+            type: "session.error",
+            properties: {
+              sessionID: "ses-rate",
+              model: "anthropic/claude-3-5-sonnet",
+              error: { statusCode: 429, message: "Rate limit exceeded" },
+              fallbackChain: [
+                "anthropic/claude-3-5-sonnet",
+                "openai/gpt-4o",
+                "google/gemini-2.5-pro",
+              ],
+            },
+          },
+        });
+
+        expect(setCurrentModel).toHaveBeenCalledTimes(1);
+        expect(setCurrentModel).toHaveBeenCalledWith("ses-rate", "openai/gpt-4o");
+        expect(onFallbackApplied).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("#when a service unavailable error (503) occurs", () => {
+      it("#then switches to the next model in the chain", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+        });
+
+        await handler({
+          event: {
+            type: "session.error",
+            properties: {
+              sessionID: "ses-503",
+              model: "openai/gpt-4o",
+              error: { statusCode: 503, message: "Service unavailable" },
+              fallbackChain: ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"],
+            },
+          },
+        });
+
+        expect(setCurrentModel).toHaveBeenCalledTimes(1);
+        expect(setCurrentModel).toHaveBeenCalledWith("ses-503", "anthropic/claude-3-5-sonnet");
+      });
+    });
+
+    describe("#when a non-matching error (400) occurs", () => {
+      it("#then does not trigger a fallback", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+        });
+
+        await handler({
+          event: {
+            type: "session.error",
+            properties: {
+              sessionID: "ses-400",
+              model: "openai/gpt-4o",
+              error: { statusCode: 400, message: "Bad request" },
+              fallbackChain: ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"],
+            },
+          },
+        });
+
+        expect(setCurrentModel).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given a handler receives non-error events", () => {
+    describe("#when event type is not session.error", () => {
+      it("#then does nothing", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+        });
+
+        await handler({
+          event: {
+            type: "session.idle",
+            properties: {
+              sessionID: "ses-idle",
+              model: "openai/gpt-4o",
+            },
+          },
+        });
+
+        expect(setCurrentModel).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given a handler receives an error with no model info", () => {
+    describe("#when the event has no model property and no getCurrentModel", () => {
+      it("#then does nothing", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+        });
+
+        await handler({
+          event: {
+            type: "session.error",
+            properties: {
+              sessionID: "ses-nomodel",
+              error: { statusCode: 429, message: "Too many requests" },
+              fallbackChain: ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"],
+            },
+          },
+        });
+
+        expect(setCurrentModel).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given a handler with rate limit message detection", () => {
+    describe("#when error message contains 'too many requests' without statusCode", () => {
+      it("#then triggers fallback via message classification", async () => {
+        const setCurrentModel = mock((_sid: string, _model: string) => {});
+
+        const handler = createModelFallbackHandler({
+          setCurrentModel,
+        });
+
+        await handler({
+          event: {
+            type: "session.error",
+            properties: {
+              sessionID: "ses-msg",
+              model: "openai/gpt-4o",
+              error: { message: "Too many requests, please slow down" },
+              fallbackChain: ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"],
+            },
+          },
+        });
+
+        expect(setCurrentModel).toHaveBeenCalledTimes(1);
+        expect(setCurrentModel).toHaveBeenCalledWith("ses-msg", "anthropic/claude-3-5-sonnet");
+      });
+    });
+  });
+});

package/src/hooks/model-fallback/handler.ts

@@ -0,0 +1,178 @@
+import { buildFallbackChain } from "../../shared/fallback-chain";
+import { resolveModel } from "../../shared/model-resolution-pipeline";
+import { log } from "../../shared/logger";
+
+type ModelSwitchReason = "rate-limit" | "service-unavailable";
+
+type ModelFallbackErrorEvent = {
+  event: {
+    type: string;
+    properties?: unknown;
+  };
+};
+
+type ModelFallbackState = {
+  sessionModels: Map<string, string>;
+};
+
+type ModelFallbackDependencies = {
+  defaultFallbackChain?: string[];
+  getCurrentModel?: (sessionID: string) => string | undefined;
+  getAvailableModels?: (sessionID: string) => Set<string>;
+  setCurrentModel?: (sessionID: string, model: string) => void | Promise<void>;
+  onFallbackApplied?: (input: {
+    sessionID: string;
+    previousModel: string;
+    nextModel: string;
+    reason: ModelSwitchReason;
+  }) => void | Promise<void>;
+};
+
+function toRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  return value as Record<string, unknown>;
+}
+
+function toStatusCode(error: unknown): number | undefined {
+  const record = toRecord(error);
+  if (!record) return undefined;
+
+  const direct = record["statusCode"];
+  if (typeof direct === "number") return direct;
+
+  const status = record["status"];
+  if (typeof status === "number") return status;
+
+  const nested = toRecord(record["error"]);
+  if (nested) {
+    const nestedCode = nested["statusCode"];
+    if (typeof nestedCode === "number") return nestedCode;
+  }
+
+  return undefined;
+}
+
+function getErrorMessage(error: unknown): string {
+  if (typeof error === "string") return error.toLowerCase();
+  const record = toRecord(error);
+  const message = record?.["message"];
+  if (typeof message === "string") return message.toLowerCase();
+  return "";
+}
+
+function classifyModelFallbackReason(error: unknown): ModelSwitchReason | undefined {
+  const statusCode = toStatusCode(error);
+  const message = getErrorMessage(error);
+
+  if (
+    statusCode === 429 ||
+    message.includes("rate limit") ||
+    message.includes("too many requests")
+  ) {
+    return "rate-limit";
+  }
+
+  if (
+    statusCode === 503 ||
+    message.includes("service unavailable") ||
+    message.includes("temporarily unavailable")
+  ) {
+    return "service-unavailable";
+  }
+
+  return undefined;
+}
+
+function getSessionID(properties: Record<string, unknown>): string | undefined {
+  const sessionID = properties["sessionID"];
+  if (typeof sessionID === "string" && sessionID.length > 0) return sessionID;
+
+  const info = toRecord(properties["info"]);
+  const infoID = info?.["id"];
+  if (typeof infoID === "string" && infoID.length > 0) return infoID;
+
+  return undefined;
+}
+
+function getNextFallbackModel(input: {
+  currentModel: string;
+  configuredFallbacks: string | string[] | undefined;
+  defaultChain: string[];
+  availableModels: Set<string>;
+}): string | undefined {
+  const fullChain = buildFallbackChain(input.configuredFallbacks, input.defaultChain);
+  const currentIndex = fullChain.findIndex(
+    (model) => model.toLowerCase() === input.currentModel.toLowerCase(),
+  );
+  const remaining = currentIndex >= 0 ? fullChain.slice(currentIndex + 1) : fullChain;
+
+  return resolveModel({
+    fallbackChain: remaining,
+    availableModels: input.availableModels,
+  })?.model;
+}
+
+export function createModelFallbackHandler(deps: ModelFallbackDependencies = {}) {
+  const state: ModelFallbackState = { sessionModels: new Map() };
+  const defaultSwitch = async (sessionID: string, model: string) => {
+    state.sessionModels.set(sessionID, model);
+  };
+
+  return async ({ event }: ModelFallbackErrorEvent): Promise<void> => {
+    if (event.type !== "session.error") return;
+
+    const properties = toRecord(event.properties);
+    if (!properties) return;
+
+    const reason = classifyModelFallbackReason(properties["error"]);
+    if (!reason) return;
+
+    const sessionID = getSessionID(properties);
+    if (!sessionID) return;
+
+    const configuredFallbacks = properties["fallbackChain"];
+    const fallbackInput =
+      typeof configuredFallbacks === "string" || Array.isArray(configuredFallbacks)
+        ? configuredFallbacks
+        : undefined;
+
+    const eventModel = properties["model"];
+    const currentModel =
+      (typeof eventModel === "string" && eventModel.length > 0 ? eventModel : undefined) ??
+      deps.getCurrentModel?.(sessionID) ??
+      state.sessionModels.get(sessionID);
+    if (!currentModel) return;
+
+    const availableModels = deps.getAvailableModels?.(sessionID) ?? new Set<string>();
+    const nextModel = getNextFallbackModel({
+      currentModel,
+      configuredFallbacks: fallbackInput,
+      defaultChain: deps.defaultFallbackChain ?? [],
+      availableModels,
+    });
+
+    if (!nextModel || nextModel.toLowerCase() === currentModel.toLowerCase()) {
+      log("[model-fallback] no eligible fallback model", { sessionID, currentModel, reason });
+      return;
+    }
+
+    const applyModel = deps.setCurrentModel ?? defaultSwitch;
+    await Promise.resolve(applyModel(sessionID, nextModel));
+
+    await Promise.resolve(
+      deps.onFallbackApplied?.({
+        sessionID,
+        previousModel: currentModel,
+        nextModel,
+        reason,
+      }),
+    );
+
+    log("[model-fallback] switched model", {
+      sessionID,
+      from: currentModel,
+      to: nextModel,
+      reason,
+    });
+  };
+}

package/src/hooks/model-fallback/index.ts

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

package/src/hooks/model-fallback/plugin.ts

@@ -0,0 +1,11 @@
+import { definePlugin } from "../../plugin-api";
+import { safeCreateHook } from "../../shared/safe-create-hook";
+import { createModelFallbackHandler } from "./handler";
+
+const modelFallbackEventHook = safeCreateHook("model-fallback", () => createModelFallbackHandler());
+
+export const modelFallbackPlugin = definePlugin({
+  name: "model-fallback",
+  version: "0.1.0",
+  hooks: modelFallbackEventHook ? { event: modelFallbackEventHook } : undefined,
+});