chore: import upstream snapshot with attribution

tests/unit/refactor-effortLevel.test.ts

@@ -0,0 +1,127 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+/**
+ * Characterization tests for the DeepSeek V4 Pro effort-level parsing logic.
+ *
+ * The parseDeepSeekEffortLevel function is module-level (non-exported) in
+ * open-sse/executors/opencode.ts. We re-implement the same logic here to lock
+ * down the expected behavior as a regression safety net.
+ *
+ * Source reference: open-sse/executors/opencode.ts lines 44-62
+ */
+
+const EFFORT_LEVELS = ["low", "medium", "high", "max"] as const;
+
+function parseDeepSeekEffortLevel(model: string): { baseModel: string; effort: string } | null {
+  const m = String(model || "");
+  const matchedLevel = EFFORT_LEVELS.find((level) => m.endsWith(`-${level}`));
+  if (!matchedLevel) return null;
+  const baseModel = m.slice(0, -matchedLevel.length - 1);
+  if (baseModel.toLowerCase() !== "deepseek-v4-pro") return null;
+  return { baseModel: "deepseek-v4-pro", effort: matchedLevel };
+}
+
+// -- Valid effort levels -------------------------------------------------------
+
+describe("parseDeepSeekEffortLevel - valid suffixes", () => {
+  it("deepseek-v4-pro-low returns low effort", () => {
+    const result = parseDeepSeekEffortLevel("deepseek-v4-pro-low");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "low" });
+  });
+
+  it("deepseek-v4-pro-medium returns medium effort", () => {
+    const result = parseDeepSeekEffortLevel("deepseek-v4-pro-medium");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "medium" });
+  });
+
+  it("deepseek-v4-pro-high returns high effort", () => {
+    const result = parseDeepSeekEffortLevel("deepseek-v4-pro-high");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "high" });
+  });
+
+  it("deepseek-v4-pro-max returns max effort", () => {
+    const result = parseDeepSeekEffortLevel("deepseek-v4-pro-max");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "max" });
+  });
+});
+
+// -- Case-insensitive base model matching --------------------------------------
+
+describe("parseDeepSeekEffortLevel - case-insensitive base model", () => {
+  it("matches DeepSeek-V4-Pro-high (uppercase base, lowercase suffix)", () => {
+    const result = parseDeepSeekEffortLevel("DeepSeek-V4-Pro-high");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "high" });
+  });
+
+  it("matches deepseek-V4-pro-low (mixed case base, lowercase suffix)", () => {
+    const result = parseDeepSeekEffortLevel("deepseek-V4-pro-low");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "low" });
+  });
+
+  it("returns null for DeepSeek-V4-Pro-High (uppercase suffix does not match)", () => {
+    // Suffix matching is case-sensitive — only the base model comparison uses toLowerCase
+    assert.equal(parseDeepSeekEffortLevel("DeepSeek-V4-Pro-High"), null);
+  });
+});
+
+// -- Returns null for non-matching inputs --------------------------------------
+
+describe("parseDeepSeekEffortLevel - no match cases", () => {
+  it("returns null for bare deepseek-v4-pro (no suffix)", () => {
+    assert.equal(parseDeepSeekEffortLevel("deepseek-v4-pro"), null);
+  });
+
+  it("returns null for gpt-5-high (not deepseek-v4-pro)", () => {
+    assert.equal(parseDeepSeekEffortLevel("gpt-5-high"), null);
+  });
+
+  it("returns null for empty string", () => {
+    assert.equal(parseDeepSeekEffortLevel(""), null);
+  });
+
+  it("returns null for trailing dash with no level (deepseek-v4-pro-)", () => {
+    assert.equal(parseDeepSeekEffortLevel("deepseek-v4-pro-"), null);
+  });
+
+  it("returns null for deepseek-v4-pro-lowextra (suffix is not an exact level)", () => {
+    assert.equal(parseDeepSeekEffortLevel("deepseek-v4-pro-lowextra"), null);
+  });
+
+  it("returns null for deepseek-v4-pro (case mismatch on level)", () => {
+    // The suffix "Low" does not match "low" exactly
+    assert.equal(parseDeepSeekEffortLevel("deepseek-v4-pro-Low"), null);
+  });
+
+  it("returns null for a random string", () => {
+    assert.equal(parseDeepSeekEffortLevel("random-string"), null);
+  });
+
+  it("returns null for just the suffix -high", () => {
+    assert.equal(parseDeepSeekEffortLevel("-high"), null);
+  });
+});
+
+// -- Edge cases ----------------------------------------------------------------
+
+describe("parseDeepSeekEffortLevel - edge cases", () => {
+  it("handles numeric input via String coercion", () => {
+    // String(123) === "123" — no dash suffix, returns null
+    assert.equal(parseDeepSeekEffortLevel(123 as unknown as string), null);
+  });
+
+  it("handles null input via String coercion", () => {
+    // String(null) === "null" — no match
+    assert.equal(parseDeepSeekEffortLevel(null as unknown as string), null);
+  });
+
+  it("handles undefined input via String coercion", () => {
+    // String(undefined) === "undefined" — no match
+    assert.equal(parseDeepSeekEffortLevel(undefined as unknown as string), null);
+  });
+
+  it("returns the canonical baseModel as lowercase when suffix matches", () => {
+    const result = parseDeepSeekEffortLevel("DeepSeek-V4-Pro-max");
+    assert.deepEqual(result, { baseModel: "deepseek-v4-pro", effort: "max" });
+  });
+});