gsd-pi 2.18.0 → 2.19.0

package/dist/resources/extensions/gsd/tests/model-router.test.ts

@@ -0,0 +1,167 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveModelForComplexity,
+  escalateTier,
+  defaultRoutingConfig,
+} from "../model-router.js";
+import type { DynamicRoutingConfig, RoutingDecision } from "../model-router.js";
+import type { ClassificationResult } from "../complexity-classifier.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeClassification(tier: "light" | "standard" | "heavy", reason = "test"): ClassificationResult {
+  return { tier, reason, downgraded: false };
+}
+
+const AVAILABLE_MODELS = [
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+  "gpt-4o-mini",
+];
+
+// ─── Passthrough when disabled ───────────────────────────────────────────────
+
+test("returns configured model when routing is disabled", () => {
+  const config = { ...defaultRoutingConfig(), enabled: false };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("returns configured model when no phase config", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    undefined,
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "");
+  assert.equal(result.wasDowngraded, false);
+});
+
+// ─── Downgrade-only semantics ────────────────────────────────────────────────
+
+test("does not downgrade when tier matches configured model tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("does not upgrade beyond configured model", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Configured model is sonnet (standard), classification says heavy
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-sonnet-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-sonnet-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("downgrades from opus to haiku for light tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  // Should pick haiku or gpt-4o-mini (cheapest light tier)
+  assert.ok(
+    result.modelId === "claude-haiku-4-5" || result.modelId === "gpt-4o-mini",
+    `Expected light-tier model, got ${result.modelId}`,
+  );
+  assert.equal(result.wasDowngraded, true);
+});
+
+test("downgrades from opus to sonnet for standard tier", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "claude-sonnet-4-6");
+  assert.equal(result.wasDowngraded, true);
+});
+
+// ─── Explicit tier_models ────────────────────────────────────────────────────
+
+test("uses explicit tier_models when configured", () => {
+  const config: DynamicRoutingConfig = {
+    ...defaultRoutingConfig(),
+    enabled: true,
+    tier_models: { light: "gpt-4o-mini", standard: "claude-sonnet-4-6" },
+  };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.equal(result.modelId, "gpt-4o-mini");
+  assert.equal(result.wasDowngraded, true);
+});
+
+// ─── Fallback chain construction ─────────────────────────────────────────────
+
+test("fallback chain includes configured primary as last resort", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: ["claude-sonnet-4-6"] },
+    config,
+    AVAILABLE_MODELS,
+  );
+  assert.ok(result.wasDowngraded);
+  // Fallbacks should include the configured fallbacks and primary
+  assert.ok(result.fallbacks.includes("claude-opus-4-6"), "primary should be in fallbacks");
+  assert.ok(result.fallbacks.includes("claude-sonnet-4-6"), "configured fallback should be in fallbacks");
+});
+
+// ─── Escalation ──────────────────────────────────────────────────────────────
+
+test("escalateTier moves light → standard", () => {
+  assert.equal(escalateTier("light"), "standard");
+});
+
+test("escalateTier moves standard → heavy", () => {
+  assert.equal(escalateTier("standard"), "heavy");
+});
+
+test("escalateTier returns null for heavy (max)", () => {
+  assert.equal(escalateTier("heavy"), null);
+});
+
+// ─── No suitable model available ─────────────────────────────────────────────
+
+test("falls back to configured model when no light-tier model available", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Only heavy-tier models available
+  const result = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["claude-opus-4-6"],
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});

package/dist/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -1,9 +1,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { parseSlackReply, parseDiscordResponse } from "../../remote-questions/format.ts";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSlackReply, parseDiscordResponse, formatForDiscord } from "../../remote-questions/format.ts";
 import { resolveRemoteConfig, isValidChannelId } from "../../remote-questions/config.ts";
 import { sanitizeError } from "../../remote-questions/manager.ts";
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 test("parseSlackReply handles single-number single-question answers", () => {
   const result = parseSlackReply("2", [{
     id: "choice",
@@ -153,3 +159,223 @@ test("sanitizeError preserves short safe messages", () => {
   assert.equal(sanitizeError("Connection refused"), "Connection refused");
 });
 
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Discord Parity Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("formatForDiscord includes context source in footer when present", () => {
+  const prompt = {
+    id: "test-1",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    context: { source: "auto-mode-dispatch" },
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 1);
+  assert.ok(embeds[0].footer?.text.includes("auto-mode-dispatch"), "footer should include context source");
+});
+
+test("formatForDiscord omits source from footer when context is absent", () => {
+  const prompt = {
+    id: "test-2",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Choice",
+      question: "Pick one",
+      options: [
+        { label: "A", description: "Alpha" },
+        { label: "B", description: "Beta" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.ok(!embeds[0].footer?.text.includes("Source:"), "footer should not include Source when context absent");
+});
+
+test("formatForDiscord multi-question footer includes question position", () => {
+  const prompt = {
+    id: "test-3",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 2);
+  assert.ok(embeds[0].footer?.text.includes("1/2"), "first embed footer should show 1/2");
+  assert.ok(embeds[1].footer?.text.includes("2/2"), "second embed footer should show 2/2");
+});
+
+test("formatForDiscord single-question generates reaction emojis", () => {
+  const prompt = {
+    id: "test-4",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Pick",
+      question: "Choose",
+      options: [
+        { label: "A", description: "a" },
+        { label: "B", description: "b" },
+        { label: "C", description: "c" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 3, "should generate 3 reaction emojis for 3 options");
+  assert.equal(reactionEmojis[0], "1️⃣");
+  assert.equal(reactionEmojis[1], "2️⃣");
+  assert.equal(reactionEmojis[2], "3️⃣");
+});
+
+test("formatForDiscord multi-question generates no reaction emojis", () => {
+  const prompt = {
+    id: "test-5",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 0, "multi-question should not generate reaction emojis");
+});
+
+test("parseDiscordResponse handles multi-question text reply via semicolons", () => {
+  const result = parseDiscordResponse([], "1;2", [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ]);
+
+  assert.deepEqual(result.answers.first.answers, ["Alpha"]);
+  assert.deepEqual(result.answers.second.answers, ["Delta"]);
+});
+
+test("parseDiscordResponse handles multiple reactions for allowMultiple question", () => {
+  const result = parseDiscordResponse(
+    [{ emoji: "1️⃣", count: 1 }, { emoji: "3️⃣", count: 1 }],
+    null,
+    [{
+      id: "choice",
+      header: "Choice",
+      question: "Pick any",
+      allowMultiple: true,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+        { label: "Gamma", description: "G" },
+      ],
+    }],
+  );
+
+  assert.deepEqual(result.answers.choice.answers, ["Alpha", "Gamma"]);
+});
+
+test("DiscordAdapter source-level: acknowledgeAnswer method exists", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("async acknowledgeAnswer"), "should have acknowledgeAnswer method");
+  assert.ok(adapterSrc.includes("✅"), "should use checkmark emoji for acknowledgement");
+});
+
+test("DiscordAdapter source-level: resolves guild ID for message URLs", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("guildId"), "should track guild ID");
+  assert.ok(adapterSrc.includes("guild_id"), "should read guild_id from channel info");
+  assert.ok(
+    adapterSrc.includes("discord.com/channels/"),
+    "should construct message URL with guild/channel/message format",
+  );
+});
+
+test("DiscordAdapter source-level: sendPrompt sets threadUrl in ref", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    adapterSrc.includes("threadUrl: messageUrl"),
+    "sendPrompt should set threadUrl to the constructed message URL",
+  );
+});