@sanity/ailf 3.8.0 → 3.9.0

package/dist/pipeline/compiler/__tests__/task-graph-builder.test.js

@@ -1,301 +0,0 @@
-/**
- * task-graph-builder.test.ts — Unit tests for TaskGraphBuilder.
- *
- * Tests DAG construction, cycle detection, filtering, and priority assignment.
- *
- * Run: npx tsx --test src/pipeline/compiler/__tests__/task-graph-builder.test.ts
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { buildTaskGraph, detectCycle } from "../task-graph-builder.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Build a LiteracyTaskDefinition for testing. The task-graph-builder now
- * accepts GeneralizedTaskDefinition[] and LiteracyTaskDefinition is a
- * valid variant of that union.
- */
-function makeTask(overrides) {
-    return {
-        mode: "literacy",
-        title: `Task ${overrides.id}`,
-        area: overrides.area ?? "groq",
-        prompt: overrides.prompt ?? { text: `Do ${overrides.id}` },
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// buildTaskGraph — basic construction
-// ---------------------------------------------------------------------------
-describe("buildTaskGraph", () => {
-    it("builds a graph from a list of tasks", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "task-a" }), makeTask({ id: "task-b" })],
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 2);
-        assert.ok(result.graph.nodes.has("task-a"));
-        assert.ok(result.graph.nodes.has("task-b"));
-        assert.equal(result.warnings.length, 0);
-    });
-    it("returns null graph when no tasks match filter", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "task-a", area: "groq" })],
-            filter: { areas: ["studio"] },
-        });
-        assert.equal(result.graph, null);
-        assert.equal(result.filteredOut.length, 1);
-        assert.ok(result.filteredOut.includes("task-a"));
-    });
-    it("filters by area", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({ id: "groq-1", area: "groq" }),
-                makeTask({ id: "studio-1", area: "studio" }),
-            ],
-            filter: { areas: ["groq"] },
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-        assert.ok(result.graph.nodes.has("groq-1"));
-    });
-    it("filters by task IDs", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "task-a" }), makeTask({ id: "task-b" })],
-            filter: { taskIds: ["task-a"] },
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-    });
-    it("filters by tags", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({ id: "task-a", tags: ["groq", "basics"] }),
-                makeTask({ id: "task-b", tags: ["studio"] }),
-            ],
-            filter: { tags: ["groq"] },
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-        assert.ok(result.graph.nodes.has("task-a"));
-    });
-    it("filters out archived tasks", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({ id: "active" }),
-                makeTask({ id: "archived", status: "archived" }),
-            ],
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-        assert.ok(result.graph.nodes.has("active"));
-    });
-    it("filters out paused tasks unless targeted by ID", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "paused-task", status: "paused" })],
-            filter: { taskIds: ["paused-task"] },
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-    });
-    it("warns about duplicate task IDs", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "dup" }), makeTask({ id: "dup", area: "studio" })],
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.nodes.size, 1);
-        assert.ok(result.warnings.some((w) => w.includes("Duplicate")));
-    });
-    it("resolves task variables into envelope", () => {
-        const result = buildTaskGraph({
-            tasks: [makeTask({ id: "task-a", prompt: { text: "Do the thing" } })],
-        });
-        assert.ok(result.graph);
-        const node = result.graph.nodes.get("task-a");
-        assert.equal(node.resolvedVariables.values.task, "Do the thing");
-    });
-    it("includes prompt.vars in the variable envelope", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({
-                    id: "task-a",
-                    prompt: { text: "Do task-a", vars: { docs: "file://ctx.md" } },
-                }),
-            ],
-        });
-        assert.ok(result.graph);
-        const node = result.graph.nodes.get("task-a");
-        assert.equal(node.resolvedVariables.values.docs, "file://ctx.md");
-    });
-});
-// ---------------------------------------------------------------------------
-// Dependency edges and ordering
-// ---------------------------------------------------------------------------
-describe("buildTaskGraph — dependencies", () => {
-    it("resolves explicit dependsOn edges", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({ id: "base" }),
-                makeTask({
-                    id: "derived",
-                    prompt: { text: "Do derived", vars: { dependsOn: ["base"] } },
-                }),
-            ],
-        });
-        assert.ok(result.graph);
-        assert.equal(result.graph.edges.length, 1);
-        assert.equal(result.graph.edges[0].from, "base");
-        assert.equal(result.graph.edges[0].to, "derived");
-    });
-    it("assigns lower priority to upstream nodes", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({ id: "step-1" }),
-                makeTask({
-                    id: "step-2",
-                    prompt: { text: "Do step-2", vars: { dependsOn: ["step-1"] } },
-                }),
-                makeTask({
-                    id: "step-3",
-                    prompt: { text: "Do step-3", vars: { dependsOn: ["step-2"] } },
-                }),
-            ],
-        });
-        assert.ok(result.graph);
-        const p1 = result.graph.nodes.get("step-1").priority;
-        const p2 = result.graph.nodes.get("step-2").priority;
-        const p3 = result.graph.nodes.get("step-3").priority;
-        assert.ok(p1 < p2, `step-1 priority (${p1}) should be < step-2 (${p2})`);
-        assert.ok(p2 < p3, `step-2 priority (${p2}) should be < step-3 (${p3})`);
-    });
-    it("warns when dependency target is not in graph", () => {
-        const result = buildTaskGraph({
-            tasks: [
-                makeTask({
-                    id: "task-a",
-                    prompt: { text: "Do task-a", vars: { dependsOn: ["missing"] } },
-                }),
-            ],
-        });
-        assert.ok(result.graph);
-        assert.ok(result.warnings.some((w) => w.includes("missing")));
-    });
-});
-// ---------------------------------------------------------------------------
-// Cycle detection
-// ---------------------------------------------------------------------------
-describe("detectCycle", () => {
-    it("returns null for acyclic graph", () => {
-        const nodes = new Map([
-            [
-                "a",
-                {
-                    taskId: "a",
-                    dependsOn: [],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-            [
-                "b",
-                {
-                    taskId: "b",
-                    dependsOn: ["a"],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-        ]);
-        const edges = [{ from: "a", to: "b", type: "ordering" }];
-        assert.equal(detectCycle(nodes, edges), null);
-    });
-    it("detects simple two-node cycle", () => {
-        const nodes = new Map([
-            [
-                "a",
-                {
-                    taskId: "a",
-                    dependsOn: ["b"],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-            [
-                "b",
-                {
-                    taskId: "b",
-                    dependsOn: ["a"],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-        ]);
-        const edges = [
-            { from: "a", to: "b", type: "ordering" },
-            { from: "b", to: "a", type: "ordering" },
-        ];
-        const cycle = detectCycle(nodes, edges);
-        assert.ok(cycle, "Should detect a cycle");
-        assert.ok(cycle.length >= 2, "Cycle should have at least 2 nodes");
-    });
-    it("detects three-node cycle", () => {
-        const nodes = new Map([
-            [
-                "a",
-                {
-                    taskId: "a",
-                    dependsOn: [],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-            [
-                "b",
-                {
-                    taskId: "b",
-                    dependsOn: [],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-            [
-                "c",
-                {
-                    taskId: "c",
-                    dependsOn: [],
-                    priority: 0,
-                    resolvedPrompt: "",
-                    resolvedVariables: { values: {}, provenance: {}, declarations: [] },
-                },
-            ],
-        ]);
-        const edges = [
-            { from: "a", to: "b", type: "ordering" },
-            { from: "b", to: "c", type: "ordering" },
-            { from: "c", to: "a", type: "ordering" },
-        ];
-        const cycle = detectCycle(nodes, edges);
-        assert.ok(cycle, "Should detect a cycle");
-    });
-    it("throws when building a graph with cycles", () => {
-        assert.throws(() => buildTaskGraph({
-            tasks: [
-                makeTask({
-                    id: "a",
-                    prompt: { text: "Do a", vars: { dependsOn: ["b"] } },
-                }),
-                makeTask({
-                    id: "b",
-                    prompt: { text: "Do b", vars: { dependsOn: ["a"] } },
-                }),
-            ],
-        }), /cycle/i);
-    });
-});

package/dist/pipeline/compiler/__tests__/telemetry.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * telemetry.test.ts — Tests for the observability & telemetry subsystem.
- *
- * Covers tool call classification, trace collection, cost tracking,
- * redaction pipeline, trace storage, and per-turn trace merging.
- *
- * Run: npx tsx --test src/pipeline/compiler/__tests__/telemetry.test.ts
- */
-export {};