@sanity/ailf 0.5.0 → 1.0.0

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

@@ -0,0 +1,301 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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 {};