@nodaro/shared 1.4.1

package/src/__tests__/list-sort.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest"
+import { sortListItems } from "../list-sort.js"
+
+describe("sortListItems — direction and basic types", () => {
+  it("sorts text ascending by default (whole item, case-insensitive)", () => {
+    expect(sortListItems(["banana", "Apple", "cherry"], {
+      field: "", sortType: "text", direction: "asc",
+    })).toEqual(["Apple", "banana", "cherry"])
+  })
+
+  it("sorts text descending", () => {
+    expect(sortListItems(["banana", "apple", "cherry"], {
+      field: "", sortType: "text", direction: "desc",
+    })).toEqual(["cherry", "banana", "apple"])
+  })
+
+  it("sorts numbers numerically (not alphabetically)", () => {
+    expect(sortListItems(["10", "9", "2", "100"], {
+      field: "", sortType: "number", direction: "asc",
+    })).toEqual(["2", "9", "10", "100"])
+  })
+
+  it("sorts ISO dates chronologically", () => {
+    expect(sortListItems(
+      ["2024-03-02T00:00:00Z", "2024-01-01T00:00:00Z", "2024-02-15T00:00:00Z"],
+      { field: "", sortType: "date", direction: "asc" },
+    )).toEqual([
+      "2024-01-01T00:00:00Z",
+      "2024-02-15T00:00:00Z",
+      "2024-03-02T00:00:00Z",
+    ])
+  })
+})
+
+describe("sortListItems — auto detection", () => {
+  it("auto-detects numeric strings and sorts them numerically", () => {
+    expect(sortListItems(["10", "9", "2"], {
+      field: "", sortType: "auto", direction: "asc",
+    })).toEqual(["2", "9", "10"])
+  })
+
+  it("auto-detects ISO date strings", () => {
+    expect(sortListItems(
+      ["2024-03-02", "2024-01-01"],
+      { field: "", sortType: "auto", direction: "asc" },
+    )).toEqual(["2024-01-01", "2024-03-02"])
+  })
+
+  it("auto falls back to text when values aren't number or date", () => {
+    expect(sortListItems(["banana", "Apple", "cherry"], {
+      field: "", sortType: "auto", direction: "asc",
+    })).toEqual(["Apple", "banana", "cherry"])
+  })
+})
+
+describe("sortListItems — natural numeric-aware text", () => {
+  it("sorts file2 before file10 under Text mode via Intl numeric", () => {
+    expect(sortListItems(["file10", "file2", "file1"], {
+      field: "", sortType: "text", direction: "asc",
+    })).toEqual(["file1", "file2", "file10"])
+  })
+})
+
+describe("sortListItems — missing / invalid always last", () => {
+  it("keeps null/empty at the end in ascending order", () => {
+    expect(sortListItems(["", "2", "1", ""], {
+      field: "", sortType: "number", direction: "asc",
+    })).toEqual(["1", "2", "", ""])
+  })
+
+  it("keeps null/empty at the end in descending order", () => {
+    expect(sortListItems(["", "2", "1", ""], {
+      field: "", sortType: "number", direction: "desc",
+    })).toEqual(["2", "1", "", ""])
+  })
+
+  it("buckets unparseable Number strings as invalid (last)", () => {
+    expect(sortListItems(["abc", "3", "1"], {
+      field: "", sortType: "number", direction: "asc",
+    })).toEqual(["1", "3", "abc"])
+  })
+
+  it("buckets unparseable Date strings as invalid (last)", () => {
+    expect(sortListItems(["not-a-date", "2024-01-01", "2023-01-01"], {
+      field: "", sortType: "date", direction: "asc",
+    })).toEqual(["2023-01-01", "2024-01-01", "not-a-date"])
+  })
+})
+
+describe("sortListItems — JSON field extraction", () => {
+  it("sorts JSON items by a dot-path field", () => {
+    const items = [
+      JSON.stringify({ title: "A", score: 5 }),
+      JSON.stringify({ title: "B", score: 9 }),
+      JSON.stringify({ title: "C", score: 1 }),
+    ]
+    const result = sortListItems(items, {
+      field: "score", sortType: "number", direction: "desc",
+    })
+    expect(result.map((r) => JSON.parse(r).title)).toEqual(["B", "A", "C"])
+  })
+
+  it("buckets items missing the field as invalid (last)", () => {
+    const items = [
+      JSON.stringify({ id: 1, score: 5 }),
+      JSON.stringify({ id: 2 }),
+      JSON.stringify({ id: 3, score: 1 }),
+    ]
+    const result = sortListItems(items, {
+      field: "score", sortType: "number", direction: "asc",
+    })
+    expect(result.map((r) => JSON.parse(r).id)).toEqual([3, 1, 2])
+  })
+})
+
+describe("sortListItems — stability", () => {
+  it("preserves input order for equal keys", () => {
+    const items = [
+      JSON.stringify({ id: "a", tier: 1 }),
+      JSON.stringify({ id: "b", tier: 1 }),
+      JSON.stringify({ id: "c", tier: 1 }),
+    ]
+    const result = sortListItems(items, {
+      field: "tier", sortType: "number", direction: "asc",
+    })
+    expect(result.map((r) => JSON.parse(r).id)).toEqual(["a", "b", "c"])
+  })
+
+  it("does not mutate the input array", () => {
+    const input = ["c", "a", "b"]
+    sortListItems(input, { field: "", sortType: "text", direction: "asc" })
+    expect(input).toEqual(["c", "a", "b"])
+  })
+})

package/src/__tests__/llm-models.test.ts

@@ -0,0 +1,445 @@
+import {
+  LLM_MODELS,
+  LLM_MODEL_IDS,
+  LLM_FEATURE_DEFAULTS,
+  STRUCTURED_VISION_MODELS,
+  getLlmModel,
+  getLlmTier,
+  buildLlmCreditIdentifier,
+  resolveLlmCreditId,
+  motionGraphicsFeature,
+} from "../llm-models.js"
+import type { LlmModelDef, LlmTier, LlmFeature } from "../llm-models.js"
+
+// The provider-$ per-token rate table and `calculateLlmCost` moved to
+// backend/src/lib/pricing/llm-cost.ts (S5) — its tests live in
+// backend/src/lib/pricing/__tests__/llm-cost.test.ts. This file covers only
+// the NON-monetary model registry (ids, capabilities, tiers, feature
+// defaults) that stays in the published package.
+
+// ---------------------------------------------------------------------------
+// LLM_MODELS data integrity
+// ---------------------------------------------------------------------------
+describe("LLM_MODELS data integrity", () => {
+  it("should have exactly 7 models", () => {
+    expect(LLM_MODELS).toHaveLength(7)
+  })
+
+  it("each model has all required fields", () => {
+    const requiredKeys: (keyof LlmModelDef)[] = [
+      "id",
+      "displayName",
+      "tier",
+      "kieFormat",
+      "kieSlugOrModel",
+      "vendor",
+      "supportsImages",
+      "maxOutputTokens",
+    ]
+
+    for (const model of LLM_MODELS) {
+      for (const key of requiredKeys) {
+        expect(model).toHaveProperty(key)
+        expect(model[key]).toBeDefined()
+      }
+    }
+  })
+
+  it("each model id is a non-empty string", () => {
+    for (const model of LLM_MODELS) {
+      expect(typeof model.id).toBe("string")
+      expect(model.id.length).toBeGreaterThan(0)
+    }
+  })
+
+  it("model ids are unique", () => {
+    const ids = LLM_MODELS.map((m) => m.id)
+    expect(new Set(ids).size).toBe(ids.length)
+  })
+
+  it("has 2 economy, 2 standard, 3 premium models", () => {
+    const tierCounts: Record<LlmTier, number> = { economy: 0, standard: 0, premium: 0 }
+    for (const model of LLM_MODELS) {
+      tierCounts[model.tier]++
+    }
+    expect(tierCounts.economy).toBe(2)
+    expect(tierCounts.standard).toBe(2)
+    expect(tierCounts.premium).toBe(3)
+  })
+
+  it("all three kieFormats are represented", () => {
+    const formats = new Set(LLM_MODELS.map((m) => m.kieFormat))
+    expect(formats).toContain("chat-completions")
+    expect(formats).toContain("messages")
+    expect(formats).toContain("responses")
+  })
+
+  it("all three vendors are represented", () => {
+    const vendors = new Set(LLM_MODELS.map((m) => m.vendor))
+    expect(vendors).toContain("anthropic")
+    expect(vendors).toContain("google")
+    expect(vendors).toContain("openai")
+  })
+
+  it("all models support images", () => {
+    for (const model of LLM_MODELS) {
+      expect(model.supportsImages).toBe(true)
+    }
+  })
+
+  it("all models have positive maxOutputTokens", () => {
+    for (const model of LLM_MODELS) {
+      expect(model.maxOutputTokens).toBeGreaterThan(0)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// LLM_MODEL_IDS
+// ---------------------------------------------------------------------------
+describe("LLM_MODEL_IDS", () => {
+  it("matches model ids from LLM_MODELS in same order", () => {
+    expect(LLM_MODEL_IDS).toEqual(LLM_MODELS.map((m) => m.id))
+  })
+
+  it("contains all expected model ids", () => {
+    const expected = [
+      "gemini-3-flash",
+      "claude-haiku-4.5",
+      "claude-sonnet-4.6",
+      "gpt-5.2",
+      "gemini-3.1-pro",
+      "claude-opus-4.7",
+      "gpt-5.4",
+    ]
+    expect(LLM_MODEL_IDS).toEqual(expected)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getLlmModel
+// ---------------------------------------------------------------------------
+describe("getLlmModel", () => {
+  it('returns model def for "gemini-3-flash"', () => {
+    const model = getLlmModel("gemini-3-flash")
+    expect(model).toBeDefined()
+    expect(model!.id).toBe("gemini-3-flash")
+    expect(model!.tier).toBe("economy")
+    expect(model!.vendor).toBe("google")
+    expect(model!.kieFormat).toBe("chat-completions")
+  })
+
+  it('returns model def for "claude-opus-4.7" with directFallbackModel', () => {
+    const model = getLlmModel("claude-opus-4.7")
+    expect(model).toBeDefined()
+    expect(model!.id).toBe("claude-opus-4.7")
+    expect(model!.tier).toBe("premium")
+    expect(model!.vendor).toBe("anthropic")
+    expect(model!.directFallbackModel).toBe("claude-opus-4-7")
+  })
+
+  it('returns model def for "claude-haiku-4.5" with directFallbackModel', () => {
+    const model = getLlmModel("claude-haiku-4.5")
+    expect(model).toBeDefined()
+    expect(model!.directFallbackModel).toBe("claude-haiku-4-5-20251001")
+  })
+
+  it("returns undefined for unknown model id", () => {
+    expect(getLlmModel("nonexistent-model")).toBeUndefined()
+  })
+
+  it("returns undefined for empty string", () => {
+    expect(getLlmModel("")).toBeUndefined()
+  })
+
+  it("returns correct model for every id in LLM_MODEL_IDS", () => {
+    for (const id of LLM_MODEL_IDS) {
+      const model = getLlmModel(id)
+      expect(model).toBeDefined()
+      expect(model!.id).toBe(id)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getLlmTier
+// ---------------------------------------------------------------------------
+describe("getLlmTier", () => {
+  it.each([
+    ["gemini-3-flash", "economy"],
+    ["claude-haiku-4.5", "economy"],
+  ] as const)("%s -> %s", (id, expected) => {
+    expect(getLlmTier(id)).toBe(expected)
+  })
+
+  it.each([
+    ["claude-sonnet-4.6", "standard"],
+    ["gpt-5.2", "standard"],
+  ] as const)("%s -> %s", (id, expected) => {
+    expect(getLlmTier(id)).toBe(expected)
+  })
+
+  it.each([
+    ["gemini-3.1-pro", "premium"],
+    ["claude-opus-4.7", "premium"],
+    ["gpt-5.4", "premium"],
+  ] as const)("%s -> %s", (id, expected) => {
+    expect(getLlmTier(id)).toBe(expected)
+  })
+
+  it('defaults to "standard" for unknown model id', () => {
+    expect(getLlmTier("totally-fake-model")).toBe("standard")
+  })
+
+  it('defaults to "standard" for empty string', () => {
+    expect(getLlmTier("")).toBe("standard")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildLlmCreditIdentifier
+// ---------------------------------------------------------------------------
+describe("buildLlmCreditIdentifier", () => {
+  it("returns bare feature name when no modelId provided", () => {
+    expect(buildLlmCreditIdentifier("ai-writer")).toBe("ai-writer")
+  })
+
+  it("returns bare feature name when modelId is undefined", () => {
+    expect(buildLlmCreditIdentifier("scene-graph-ai", undefined)).toBe("scene-graph-ai")
+  })
+
+  it('appends ":economy" for economy-tier models', () => {
+    expect(buildLlmCreditIdentifier("ai-writer", "gemini-3-flash")).toBe("ai-writer:economy")
+    expect(buildLlmCreditIdentifier("prompt-helper", "claude-haiku-4.5")).toBe(
+      "prompt-helper:economy",
+    )
+  })
+
+  it("returns bare feature name for standard-tier models (backward compat)", () => {
+    expect(buildLlmCreditIdentifier("ai-writer", "claude-sonnet-4.6")).toBe("ai-writer")
+    expect(buildLlmCreditIdentifier("scene-graph-ai", "gpt-5.2")).toBe("scene-graph-ai")
+  })
+
+  it('appends ":premium" for premium-tier models', () => {
+    expect(buildLlmCreditIdentifier("scene-graph-ai", "claude-opus-4.7")).toBe(
+      "scene-graph-ai:premium",
+    )
+    expect(buildLlmCreditIdentifier("ai-writer", "gpt-5.4")).toBe("ai-writer:premium")
+    expect(buildLlmCreditIdentifier("after-effects", "gemini-3.1-pro")).toBe(
+      "after-effects:premium",
+    )
+  })
+
+  it("treats unknown model as standard tier (no suffix)", () => {
+    // getLlmTier defaults to "standard" for unknown models
+    expect(buildLlmCreditIdentifier("ai-writer", "fake-model")).toBe("ai-writer")
+  })
+
+  it("works with all LLM feature names", () => {
+    const features: LlmFeature[] = [
+      "ai-writer",
+      "llm-chat",
+      "prompt-helper",
+      "scene-graph-ai",
+      "after-effects",
+      "motion-graphics",
+      "lottie-overlay",
+      "3d-title",
+      "image-to-text",
+      "qa-check",
+      "generate-script",
+      "translate",
+      "image-critic",
+    ]
+
+    for (const feature of features) {
+      // economy
+      const economy = buildLlmCreditIdentifier(feature, "gemini-3-flash")
+      expect(economy).toBe(`${feature}:economy`)
+
+      // standard
+      const standard = buildLlmCreditIdentifier(feature, "claude-sonnet-4.6")
+      expect(standard).toBe(feature)
+
+      // premium
+      const premium = buildLlmCreditIdentifier(feature, "claude-opus-4.7")
+      expect(premium).toBe(`${feature}:premium`)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveLlmCreditId
+// ---------------------------------------------------------------------------
+describe("resolveLlmCreditId", () => {
+  it("uses llmModel from body when present (economy)", () => {
+    expect(resolveLlmCreditId("ai-writer", { llmModel: "gemini-3-flash" })).toBe(
+      "ai-writer:economy",
+    )
+  })
+
+  it("uses llmModel from body when present (standard)", () => {
+    expect(resolveLlmCreditId("ai-writer", { llmModel: "claude-sonnet-4.6" })).toBe("ai-writer")
+  })
+
+  it("uses llmModel from body when present (premium)", () => {
+    expect(resolveLlmCreditId("ai-writer", { llmModel: "claude-opus-4.7" })).toBe(
+      "ai-writer:premium",
+    )
+  })
+
+  it("returns bare feature when body has no llmModel", () => {
+    expect(resolveLlmCreditId("ai-writer", { prompt: "hello" })).toBe("ai-writer")
+  })
+
+  it("returns bare feature when body is empty object", () => {
+    expect(resolveLlmCreditId("prompt-helper", {})).toBe("prompt-helper")
+  })
+
+  it("returns bare feature when body is null", () => {
+    expect(resolveLlmCreditId("scene-graph-ai", null)).toBe("scene-graph-ai")
+  })
+
+  it("returns bare feature when body is undefined", () => {
+    expect(resolveLlmCreditId("after-effects", undefined)).toBe("after-effects")
+  })
+
+  it("handles body with llmModel set to undefined", () => {
+    expect(resolveLlmCreditId("translate", { llmModel: undefined })).toBe("translate")
+  })
+
+  it("works across different features", () => {
+    const body = { llmModel: "gpt-5.4" }
+    expect(resolveLlmCreditId("3d-title", body)).toBe("3d-title:premium")
+    expect(resolveLlmCreditId("motion-graphics", body)).toBe("motion-graphics:premium")
+    expect(resolveLlmCreditId("lottie-overlay", body)).toBe("lottie-overlay:premium")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// LLM_FEATURE_DEFAULTS
+// ---------------------------------------------------------------------------
+describe("LLM_FEATURE_DEFAULTS", () => {
+  const ALL_FEATURES: LlmFeature[] = [
+    "ai-writer",
+    "llm-chat",
+    "prompt-helper",
+    "scene-graph-ai",
+    "after-effects",
+    "motion-graphics",
+    "motion-graphics-lottie",
+    "lottie-overlay",
+    "3d-title",
+    "image-to-text",
+    "describe-to-picker",
+    "qa-check",
+    "generate-script",
+    "translate",
+    "image-critic",
+  ]
+
+  it("has entries for all 15 features", () => {
+    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(15)
+    for (const feature of ALL_FEATURES) {
+      expect(LLM_FEATURE_DEFAULTS).toHaveProperty(feature)
+    }
+  })
+
+  it("all default values are valid model IDs", () => {
+    for (const [feature, modelId] of Object.entries(LLM_FEATURE_DEFAULTS)) {
+      const model = getLlmModel(modelId)
+      expect(model).toBeDefined()
+    }
+  })
+
+  it('"prompt-helper" defaults to "gemini-3-flash" (economy)', () => {
+    expect(LLM_FEATURE_DEFAULTS["prompt-helper"]).toBe("gemini-3-flash")
+    expect(getLlmTier(LLM_FEATURE_DEFAULTS["prompt-helper"])).toBe("economy")
+  })
+
+  it('"ai-writer" defaults to "claude-sonnet-4.6" (standard)', () => {
+    expect(LLM_FEATURE_DEFAULTS["ai-writer"]).toBe("claude-sonnet-4.6")
+    expect(getLlmTier(LLM_FEATURE_DEFAULTS["ai-writer"])).toBe("standard")
+  })
+
+  it('"describe-to-picker" defaults to "claude-opus-4.7" (premium vision)', () => {
+    expect(LLM_FEATURE_DEFAULTS["describe-to-picker"]).toBe("claude-opus-4.7")
+    expect(getLlmTier(LLM_FEATURE_DEFAULTS["describe-to-picker"])).toBe("premium")
+    // The default MUST be an accepted analyzer model (vision + structured output).
+    expect(STRUCTURED_VISION_MODELS.map((m) => m.id)).toContain("claude-opus-4.7")
+  })
+
+  it('"generate-script" defaults to "gemini-3-flash" (economy)', () => {
+    expect(LLM_FEATURE_DEFAULTS["generate-script"]).toBe("gemini-3-flash")
+  })
+
+  it('"translate" defaults to "gemini-3-flash" (economy)', () => {
+    expect(LLM_FEATURE_DEFAULTS["translate"]).toBe("gemini-3-flash")
+  })
+
+  it("composition features default to claude-sonnet-4.6", () => {
+    const compositionFeatures: LlmFeature[] = [
+      "scene-graph-ai",
+      "after-effects",
+      "motion-graphics",
+      "motion-graphics-lottie",
+      "lottie-overlay",
+      "3d-title",
+    ]
+    for (const feature of compositionFeatures) {
+      expect(LLM_FEATURE_DEFAULTS[feature]).toBe("claude-sonnet-4.6")
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// motionGraphicsFeature
+// ---------------------------------------------------------------------------
+describe("motionGraphicsFeature", () => {
+  it.each([
+    [undefined, "motion-graphics"],
+    ["elements", "motion-graphics"],
+    ["lottie", "motion-graphics-lottie"],
+    ["junk", "motion-graphics"],
+  ] as const)("%s -> %s", (engine, expected) => {
+    expect(motionGraphicsFeature(engine)).toBe(expected)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// STRUCTURED_VISION_MODELS — describe-to-picker's single source of truth
+// (the model picker AND the backend route gate both derive from this list)
+// ---------------------------------------------------------------------------
+describe("STRUCTURED_VISION_MODELS", () => {
+  it("is exactly the vision models with a guaranteed structured-output mode", () => {
+    const ids = STRUCTURED_VISION_MODELS.map((m) => m.id).sort()
+    expect(ids).toEqual(
+      [
+        "claude-haiku-4.5",
+        "claude-opus-4.7",
+        "claude-sonnet-4.6",
+        "gemini-3-flash",
+        "gemini-3.1-pro",
+      ].sort(),
+    )
+  })
+
+  it("includes Anthropic (forced-tool) AND Gemini (response_format) vendors", () => {
+    const vendors = new Set(STRUCTURED_VISION_MODELS.map((m) => m.vendor))
+    expect(vendors).toContain("anthropic")
+    expect(vendors).toContain("google")
+  })
+
+  it("excludes GPT models — no native structured mode (parse+retry only)", () => {
+    const ids = STRUCTURED_VISION_MODELS.map((m) => m.id)
+    expect(ids).not.toContain("gpt-5.2")
+    expect(ids).not.toContain("gpt-5.4")
+  })
+
+  it("every member is vision-capable and has a structuredOutputMode", () => {
+    for (const m of STRUCTURED_VISION_MODELS) {
+      expect(m.supportsImages).toBe(true)
+      expect(m.structuredOutputMode).toBeDefined()
+    }
+  })
+})