@sanity/ailf 2.0.0 → 2.0.1

package/dist/pipeline/compiler/__tests__/task-bridge.test.js

@@ -0,0 +1,339 @@
+/**
+ * task-bridge.test.ts — Unit tests for the TaskDefinition ↔ LiteracyTaskDefinition bridge.
+ *
+ * Covers round-trip fidelity, edge cases (missing optionals, all optionals),
+ * assertion type mapping, and all four CanonicalDocRef / GeneralizedDocRef variants.
+ *
+ * Run: npx tsx --test src/pipeline/compiler/__tests__/task-bridge.test.ts
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { toGeneralized, toLiteracyTask } from "../task-bridge.js";
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+/** Minimal old-style task — only required fields, no optionals */
+const minimalOldTask = {
+    id: "groq-filter-basic",
+    description: "Filter documents with GROQ",
+    featureArea: "groq",
+    taskPrompt: "Write a GROQ query that filters by _type",
+    canonicalDocs: [],
+    referenceSolution: "solutions/groq-filter-basic.ts",
+    docCoverage: false,
+    assertions: [],
+};
+/** Fully-populated old-style task — every optional filled */
+const fullOldTask = {
+    id: "mutations-create-advanced",
+    description: "Create documents with mutations API",
+    featureArea: "mutations",
+    taskPrompt: "Use the mutations API to create a document with references",
+    canonicalDocs: [
+        { slug: "mutations-overview", reason: "Primary mutations guide" },
+        { path: "/docs/mutations/create", reason: "Create-specific docs" },
+        {
+            id: "doc-123",
+            reason: "Imported draft",
+            slug: "draft-slug",
+            path: "/docs/draft",
+        },
+        { perspective: "release-v3", reason: "V3 release content" },
+    ],
+    referenceSolution: "solutions/mutations-create-advanced.ts",
+    docCoverage: true,
+    assertions: [
+        {
+            type: "llm-rubric",
+            template: "code-quality",
+            criteria: ["correct", "idiomatic"],
+            weight: 2,
+        },
+        { type: "contains", value: "createIfNotExists" },
+        { type: "javascript", value: "output.includes('mutation')", weight: 1 },
+    ],
+    baseline: { enabled: true, rubric: "full" },
+    tags: ["mutations", "advanced", "references"],
+    status: "active",
+    extraVars: { customHint: "Use createIfNotExists", maxRetries: 3 },
+};
+/** Minimal new-style literacy task — only required/mode fields */
+const minimalNewTask = {
+    mode: "literacy",
+    id: "studio-config-basic",
+    title: "Configure a Sanity Studio",
+};
+/** Fully-populated new-style literacy task (only fields that round-trip through old type) */
+const fullNewTask = {
+    mode: "literacy",
+    id: "groq-projection-advanced",
+    title: "Advanced GROQ projections",
+    area: "groq",
+    tags: ["groq", "projections"],
+    status: "active",
+    assertions: [
+        {
+            type: "llm-rubric",
+            template: "completeness",
+            criteria: ["covers edge cases"],
+            weight: 3,
+        },
+        { type: "contains", value: "coalesce" },
+    ],
+    prompt: {
+        text: "Write a GROQ query using projections with coalesce",
+        vars: { difficulty: "advanced", topic: "projections" },
+    },
+    context: {
+        docs: [
+            { slug: "groq-projections", reason: "Projection docs" },
+            { path: "/docs/groq/projections", reason: "Path-based ref" },
+            { id: "groq-doc-456", reason: "By ID" },
+            { perspective: "release-groq-v2", reason: "GROQ v2 release" },
+        ],
+    },
+    referenceSolution: "solutions/groq-projection-advanced.ts",
+    docCoverage: true,
+    baseline: { enabled: false, rubric: "abbreviated" },
+};
+// ---------------------------------------------------------------------------
+// toGeneralized — old TaskDefinition → LiteracyTaskDefinition
+// ---------------------------------------------------------------------------
+describe("toGeneralized", () => {
+    it("converts a minimal old task to a LiteracyTaskDefinition", () => {
+        const result = toGeneralized(minimalOldTask);
+        assert.equal(result.mode, "literacy");
+        assert.equal(result.id, "groq-filter-basic");
+        assert.equal(result.title, "Filter documents with GROQ");
+        assert.equal(result.area, "groq");
+        assert.equal(result.referenceSolution, "solutions/groq-filter-basic.ts");
+        assert.equal(result.docCoverage, false);
+        assert.deepEqual(result.assertions, []);
+        assert.deepEqual(result.context?.docs, []);
+        assert.equal(result.prompt?.text, "Write a GROQ query that filters by _type");
+    });
+    it("converts a fully-populated old task preserving all fields", () => {
+        const result = toGeneralized(fullOldTask);
+        assert.equal(result.mode, "literacy");
+        assert.equal(result.id, "mutations-create-advanced");
+        assert.equal(result.title, "Create documents with mutations API");
+        assert.equal(result.area, "mutations");
+        assert.equal(result.referenceSolution, "solutions/mutations-create-advanced.ts");
+        assert.equal(result.docCoverage, true);
+        assert.deepEqual(result.baseline, { enabled: true, rubric: "full" });
+        assert.deepEqual(result.tags, ["mutations", "advanced", "references"]);
+        assert.equal(result.status, "active");
+        assert.deepEqual(result.prompt?.vars, {
+            customHint: "Use createIfNotExists",
+            maxRetries: 3,
+        });
+        assert.equal(result.prompt?.text, "Use the mutations API to create a document with references");
+    });
+    it("does not set optional fields when absent in old task", () => {
+        const result = toGeneralized(minimalOldTask);
+        assert.equal(result.baseline, undefined);
+        assert.equal(result.tags, undefined);
+        assert.equal(result.status, undefined);
+        assert.equal(result.prompt?.vars, undefined);
+    });
+});
+// ---------------------------------------------------------------------------
+// toLiteracyTask — LiteracyTaskDefinition → old TaskDefinition
+// ---------------------------------------------------------------------------
+describe("toLiteracyTask", () => {
+    it("converts a minimal new task to a TaskDefinition", () => {
+        const result = toLiteracyTask(minimalNewTask);
+        assert.equal(result.id, "studio-config-basic");
+        assert.equal(result.description, "Configure a Sanity Studio");
+        assert.equal(result.featureArea, "");
+        assert.equal(result.taskPrompt, "");
+        assert.deepEqual(result.canonicalDocs, []);
+        assert.equal(result.referenceSolution, "");
+        assert.equal(result.docCoverage, false);
+        assert.deepEqual(result.assertions, []);
+    });
+    it("converts a fully-populated new task preserving all mappable fields", () => {
+        const result = toLiteracyTask(fullNewTask);
+        assert.equal(result.id, "groq-projection-advanced");
+        assert.equal(result.description, "Advanced GROQ projections");
+        assert.equal(result.featureArea, "groq");
+        assert.equal(result.taskPrompt, "Write a GROQ query using projections with coalesce");
+        assert.equal(result.referenceSolution, "solutions/groq-projection-advanced.ts");
+        assert.equal(result.docCoverage, true);
+        assert.deepEqual(result.baseline, { enabled: false, rubric: "abbreviated" });
+        assert.deepEqual(result.tags, ["groq", "projections"]);
+        assert.equal(result.status, "active");
+        assert.deepEqual(result.extraVars, {
+            difficulty: "advanced",
+            topic: "projections",
+        });
+    });
+    it("uses prompt.template as fallback when prompt.text is absent", () => {
+        const task = {
+            mode: "literacy",
+            id: "template-task",
+            title: "Template-based task",
+            prompt: { template: "my-named-template" },
+        };
+        const result = toLiteracyTask(task);
+        assert.equal(result.taskPrompt, "my-named-template");
+    });
+    it("does not set optional fields when absent in new task", () => {
+        const result = toLiteracyTask(minimalNewTask);
+        assert.equal(result.baseline, undefined);
+        assert.equal(result.tags, undefined);
+        assert.equal(result.status, undefined);
+        assert.equal(result.extraVars, undefined);
+    });
+});
+// ---------------------------------------------------------------------------
+// Round-trip: old → new → old (must be lossless)
+// ---------------------------------------------------------------------------
+describe("round-trip: toLiteracyTask(toGeneralized(oldTask))", () => {
+    it("preserves all fields of a minimal old task", () => {
+        const roundTripped = toLiteracyTask(toGeneralized(minimalOldTask));
+        assert.deepEqual(roundTripped, minimalOldTask);
+    });
+    it("preserves all fields of a fully-populated old task", () => {
+        const roundTripped = toLiteracyTask(toGeneralized(fullOldTask));
+        assert.deepEqual(roundTripped, fullOldTask);
+    });
+});
+// ---------------------------------------------------------------------------
+// Round-trip: new → old → new (lossless for mappable fields)
+// ---------------------------------------------------------------------------
+describe("round-trip: toGeneralized(toLiteracyTask(newTask))", () => {
+    it("preserves all fields of a minimal new task", () => {
+        const roundTripped = toGeneralized(toLiteracyTask(minimalNewTask));
+        assert.equal(roundTripped.mode, "literacy");
+        assert.equal(roundTripped.id, minimalNewTask.id);
+        assert.equal(roundTripped.title, minimalNewTask.title);
+    });
+    it("preserves all mappable fields of a fully-populated new task", () => {
+        const roundTripped = toGeneralized(toLiteracyTask(fullNewTask));
+        assert.equal(roundTripped.mode, "literacy");
+        assert.equal(roundTripped.id, fullNewTask.id);
+        assert.equal(roundTripped.title, fullNewTask.title);
+        assert.equal(roundTripped.area, fullNewTask.area);
+        assert.deepEqual(roundTripped.tags, fullNewTask.tags);
+        assert.equal(roundTripped.status, fullNewTask.status);
+        assert.deepEqual(roundTripped.assertions, fullNewTask.assertions);
+        assert.equal(roundTripped.prompt?.text, fullNewTask.prompt?.text);
+        assert.deepEqual(roundTripped.prompt?.vars, fullNewTask.prompt?.vars);
+        assert.deepEqual(roundTripped.context?.docs, fullNewTask.context?.docs);
+        assert.equal(roundTripped.referenceSolution, fullNewTask.referenceSolution);
+        assert.equal(roundTripped.docCoverage, fullNewTask.docCoverage);
+        assert.deepEqual(roundTripped.baseline, fullNewTask.baseline);
+    });
+});
+// ---------------------------------------------------------------------------
+// CanonicalDocRef ↔ GeneralizedDocRef mapping (all 4 variants)
+// ---------------------------------------------------------------------------
+describe("doc ref mapping", () => {
+    const slugRef = {
+        slug: "my-article",
+        reason: "testing slug",
+    };
+    const pathRef = {
+        path: "/docs/my-article",
+        reason: "testing path",
+    };
+    const idRef = {
+        id: "abc-123",
+        reason: "testing id",
+        slug: "annotated-slug",
+        path: "/docs/annotated",
+    };
+    const perspectiveRef = {
+        perspective: "release-v4",
+        reason: "testing perspective",
+    };
+    it("preserves slug ref through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [slugRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [slugRef]);
+    });
+    it("preserves path ref through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [pathRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [pathRef]);
+    });
+    it("preserves id ref (with optional slug/path annotations) through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [idRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [idRef]);
+    });
+    it("preserves perspective ref through round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            canonicalDocs: [perspectiveRef],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [perspectiveRef]);
+    });
+    it("preserves all 4 ref variants together through round-trip", () => {
+        const allRefs = [slugRef, pathRef, idRef, perspectiveRef];
+        const task = { ...minimalOldTask, canonicalDocs: allRefs };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, allRefs);
+    });
+});
+// ---------------------------------------------------------------------------
+// Assertion type mapping
+// ---------------------------------------------------------------------------
+describe("assertion type mapping", () => {
+    const templatedAssertion = {
+        type: "llm-rubric",
+        template: "code-quality",
+        criteria: ["correct", "idiomatic", "secure"],
+        weight: 2,
+    };
+    const valueAssertion = {
+        type: "contains",
+        value: "createDocument",
+    };
+    const jsAssertion = {
+        type: "javascript",
+        value: "output.includes('done')",
+        weight: 1,
+    };
+    it("preserves templated assertions through old→new→old round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            assertions: [templatedAssertion],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, [templatedAssertion]);
+    });
+    it("preserves value assertions through old→new→old round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            assertions: [valueAssertion],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, [valueAssertion]);
+    });
+    it("preserves mixed assertion types through old→new→old round-trip", () => {
+        const mixed = [templatedAssertion, valueAssertion, jsAssertion];
+        const task = { ...minimalOldTask, assertions: mixed };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, mixed);
+    });
+    it("preserves assertions through new→old→new round-trip", () => {
+        const genAssertions = [
+            {
+                type: "llm-rubric",
+                template: "completeness",
+                criteria: ["thorough"],
+                weight: 1,
+            },
+            { type: "regex", value: "^import.*sanity" },
+        ];
+        const task = {
+            ...minimalNewTask,
+            assertions: genAssertions,
+        };
+        const roundTripped = toGeneralized(toLiteracyTask(task));
+        assert.deepEqual(roundTripped.assertions, genAssertions);
+    });
+});

package/dist/pipeline/compiler/__tests__/tool-loop-openai.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * tool-loop-openai.test.ts — Tests for the OpenAI MCP tool loop.
+ *
+ * Tests both API variants (Chat Completions and Responses) with mocked
+ * fetch to verify tool calling, error handling, token tracking, and
+ * round exhaustion.
+ *
+ * Run: npx tsx --test src/pipeline/compiler/__tests__/tool-loop-openai.test.ts
+ */
+export {};