@mhingston5/lasso 0.1.0

package/test/composition/chain.test.ts

@@ -0,0 +1,328 @@
+import { describe, expect, it } from "vitest";
+import { chainHarnesses } from "../../src/composition/chain.js";
+import type { HarnessStage } from "../../src/composition/types.js";
+import type { HarnessSpec, TaskNode } from "../../src/spec/types.js";
+
+function makeSpec(name: string, nodes: TaskNode[], edges: { from: string; to: string }[] = []): HarnessSpec {
+  return {
+    name,
+    graph: {
+      entryNodeId: nodes[0]?.id ?? "entry",
+      nodes,
+      edges,
+    },
+  };
+}
+
+describe("chainHarnesses", () => {
+  describe("basic chaining", () => {
+    it("chains a single stage and returns its spec", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: ["term"] },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.stageCount).toBe(1);
+      expect(result.totalNodes).toBe(1);
+      expect(result.combinedSpec.name).toBe("research");
+      expect(result.combinedSpec.graph.nodes.length).toBe(1);
+    });
+
+    it("chains two stages with edge connection", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: ["term"] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "write-plan", kind: "llm", provider: "openai", model: "gpt-4", prompt: "plan" },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.stageCount).toBe(2);
+      expect(result.totalNodes).toBe(2);
+      expect(result.combinedSpec.graph.edges.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("chains three stages sequentially", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: ["term"] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "write-plan", kind: "llm", provider: "openai", model: "gpt-4", prompt: "plan" },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "execute",
+          spec: makeSpec("execute", [
+            { id: "run", kind: "tool", tool: "bash", args: ["make"] },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.stageCount).toBe(3);
+      expect(result.totalNodes).toBe(3);
+      const entryNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.id === result.combinedSpec.graph.entryNodeId,
+      );
+      expect(entryNode).toBeDefined();
+    });
+  });
+
+  describe("node ID collision avoidance", () => {
+    it("prefixes node IDs with stage name to avoid collisions", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "step-1", kind: "tool", tool: "grep", args: ["a"] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "step-1", kind: "tool", tool: "echo", args: ["b"] },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      expect(nodeIds).toContain("research:step-1");
+      expect(nodeIds).toContain("plan:step-1");
+      expect(nodeIds.length).toBe(2);
+    });
+
+    it("produces unique node IDs across all stages", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "alpha",
+          spec: makeSpec("alpha", [
+            { id: "node", kind: "tool", tool: "a", args: [] },
+            { id: "shared", kind: "tool", tool: "b", args: [] },
+          ], [{ from: "node", to: "shared" }]),
+          inputMapping: {},
+        },
+        {
+          name: "beta",
+          spec: makeSpec("beta", [
+            { id: "node", kind: "tool", tool: "c", args: [] },
+            { id: "shared", kind: "tool", tool: "d", args: [] },
+          ], [{ from: "node", to: "shared" }]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      const uniqueIds = new Set(nodeIds);
+      expect(uniqueIds.size).toBe(nodeIds.length);
+    });
+  });
+
+  describe("edge connections", () => {
+    it("rewires internal edges with prefixed node IDs", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "stage-a",
+          spec: makeSpec("stage-a", [
+            { id: "first", kind: "tool", tool: "a", args: [] },
+            { id: "second", kind: "tool", tool: "b", args: [] },
+          ], [{ from: "first", to: "second" }]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      const edge = result.combinedSpec.graph.edges[0];
+      expect(edge.from).toBe("stage-a:first");
+      expect(edge.to).toBe("stage-a:second");
+    });
+
+    it("connects last node of stage N to first node of stage N+1", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: [] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "write", kind: "llm", provider: "openai", model: "gpt-4", prompt: "p" },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      const interStageEdge = result.combinedSpec.graph.edges.find(
+        (e) => e.from === "research:search" && e.to === "plan:write",
+      );
+      expect(interStageEdge).toBeDefined();
+    });
+
+    it("connects multi-node stages correctly", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "a", args: [] },
+            { id: "analyze", kind: "llm", provider: "openai", model: "gpt-4", prompt: "p" },
+          ], [{ from: "search", to: "analyze" }]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "draft", kind: "llm", provider: "openai", model: "gpt-4", prompt: "d" },
+            { id: "review", kind: "tool", tool: "b", args: [] },
+          ], [{ from: "draft", to: "review" }]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      const interStageEdge = result.combinedSpec.graph.edges.find(
+        (e) => e.from === "research:analyze" && e.to === "plan:draft",
+      );
+      expect(interStageEdge).toBeDefined();
+    });
+  });
+
+  describe("input mapping", () => {
+    it("records input mapping in combined spec metadata", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: [] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "plan",
+          spec: makeSpec("plan", [
+            { id: "write", kind: "llm", provider: "openai", model: "gpt-4", prompt: "p" },
+          ]),
+          inputMapping: { "research:output": "plan:input" },
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.stageCount).toBe(2);
+    });
+  });
+
+  describe("condition stages", () => {
+    it("includes condition field on stage", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "research",
+          spec: makeSpec("research", [
+            { id: "search", kind: "tool", tool: "grep", args: [] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "deep-research",
+          spec: makeSpec("deep-research", [
+            { id: "deep-search", kind: "tool", tool: "grep", args: ["--deep"] },
+          ]),
+          inputMapping: {},
+          condition: "results.length > 10",
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.stageCount).toBe(2);
+      expect(result.combinedSpec.graph.nodes.length).toBe(2);
+    });
+  });
+
+  describe("composition result", () => {
+    it("calculates total nodes correctly", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "a",
+          spec: makeSpec("a", [
+            { id: "a1", kind: "tool", tool: "a", args: [] },
+            { id: "a2", kind: "tool", tool: "b", args: [] },
+          ]),
+          inputMapping: {},
+        },
+        {
+          name: "b",
+          spec: makeSpec("b", [
+            { id: "b1", kind: "tool", tool: "c", args: [] },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.totalNodes).toBe(3);
+    });
+
+    it("estimates duration based on node count", () => {
+      const stages: HarnessStage[] = [
+        {
+          name: "a",
+          spec: makeSpec("a", [
+            { id: "a1", kind: "tool", tool: "a", args: [] },
+          ]),
+          inputMapping: {},
+        },
+      ];
+
+      const result = chainHarnesses(stages);
+
+      expect(result.estimatedDurationMs).toBeGreaterThan(0);
+    });
+  });
+
+  describe("empty stages", () => {
+    it("throws on empty stages array", () => {
+      expect(() => chainHarnesses([])).toThrow();
+    });
+  });
+});

package/test/composition/conditional.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it } from "vitest";
+import { conditionalHarness } from "../../src/composition/conditional.js";
+import type { HarnessSpec, TaskNode } from "../../src/spec/types.js";
+
+function makeSpec(name: string, nodes: TaskNode[], edges: { from: string; to: string }[] = []): HarnessSpec {
+  return {
+    name,
+    graph: {
+      entryNodeId: nodes[0]?.id ?? "entry",
+      nodes,
+      edges,
+    },
+  };
+}
+
+describe("conditionalHarness", () => {
+  describe("basic conditional", () => {
+    it("creates a condition node at entry", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "echo", args: ["true"] },
+      ]);
+
+      const result = conditionalHarness("hasData", trueHarness);
+
+      const conditionNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "condition",
+      );
+      expect(conditionNode).toBeDefined();
+      expect((conditionNode as any).condition).toBe("hasData");
+    });
+
+    it("connects condition true branch to true harness", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "echo", args: ["true"] },
+      ]);
+
+      const result = conditionalHarness("hasData", trueHarness);
+
+      const conditionNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "condition",
+      ) as any;
+      expect(conditionNode.thenNodeId).toBe("true-path:t1");
+    });
+
+    it("connects condition false branch to true harness when no false harness provided", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "echo", args: ["true"] },
+      ]);
+
+      const result = conditionalHarness("hasData", trueHarness);
+
+      const conditionNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "condition",
+      ) as any;
+      expect(conditionNode.elseNodeId).toBe("true-path:t1");
+    });
+  });
+
+  describe("with false harness", () => {
+    it("connects false branch to false harness", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "echo", args: ["true"] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "echo", args: ["false"] },
+      ]);
+
+      const result = conditionalHarness("hasData", trueHarness, falseHarness);
+
+      const conditionNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "condition",
+      ) as any;
+      expect(conditionNode.thenNodeId).toBe("true-path:t1");
+      expect(conditionNode.elseNodeId).toBe("false-path:f1");
+    });
+
+    it("includes nodes from both branches", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "echo", args: ["true"] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "echo", args: ["false"] },
+      ]);
+
+      const result = conditionalHarness("hasData", trueHarness, falseHarness);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      expect(nodeIds).toContain("true-path:t1");
+      expect(nodeIds).toContain("false-path:f1");
+    });
+  });
+
+  describe("node ID prefixing", () => {
+    it("prefixes true harness node IDs", () => {
+      const trueHarness = makeSpec("alpha", [
+        { id: "step", kind: "tool", tool: "a", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      expect(nodeIds).toContain("alpha:step");
+    });
+
+    it("prefixes false harness node IDs", () => {
+      const trueHarness = makeSpec("alpha", [
+        { id: "step", kind: "tool", tool: "a", args: [] },
+      ]);
+      const falseHarness = makeSpec("beta", [
+        { id: "step", kind: "tool", tool: "b", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness, falseHarness);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      expect(nodeIds).toContain("alpha:step");
+      expect(nodeIds).toContain("beta:step");
+    });
+  });
+
+  describe("edge rewiring", () => {
+    it("rewires internal edges in true harness", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+        { id: "t2", kind: "tool", tool: "b", args: [] },
+      ], [{ from: "t1", to: "t2" }]);
+
+      const result = conditionalHarness("cond", trueHarness);
+
+      const edge = result.combinedSpec.graph.edges.find(
+        (e) => e.from === "true-path:t1" && e.to === "true-path:t2",
+      );
+      expect(edge).toBeDefined();
+    });
+
+    it("rewires internal edges in false harness", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "b", args: [] },
+        { id: "f2", kind: "tool", tool: "c", args: [] },
+      ], [{ from: "f1", to: "f2" }]);
+
+      const result = conditionalHarness("cond", trueHarness, falseHarness);
+
+      const edge = result.combinedSpec.graph.edges.find(
+        (e) => e.from === "false-path:f1" && e.to === "false-path:f2",
+      );
+      expect(edge).toBeDefined();
+    });
+  });
+
+  describe("merge after conditional", () => {
+    it("creates merge node after both branches", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "b", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness, falseHarness);
+
+      const mergeNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "merge",
+      );
+      expect(mergeNode).toBeDefined();
+    });
+
+    it("merge node waits for both branch terminals", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "b", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness, falseHarness);
+
+      const mergeNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "merge",
+      ) as any;
+      expect(mergeNode).toBeDefined();
+      expect(mergeNode.waitFor).toContain("true-path:t1");
+      expect(mergeNode.waitFor).toContain("false-path:f1");
+    });
+  });
+
+  describe("composition result", () => {
+    it("counts stages as 2 (true + false)", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+      const falseHarness = makeSpec("false-path", [
+        { id: "f1", kind: "tool", tool: "b", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness, falseHarness);
+
+      expect(result.stageCount).toBe(2);
+    });
+
+    it("counts stage as 1 when no false harness", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness);
+
+      expect(result.stageCount).toBe(1);
+    });
+
+    it("estimates duration", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness);
+
+      expect(result.estimatedDurationMs).toBeGreaterThan(0);
+    });
+  });
+
+  describe("multi-node harnesses", () => {
+    it("handles true harness with multiple nodes", () => {
+      const trueHarness = makeSpec("true-path", [
+        { id: "t1", kind: "tool", tool: "a", args: [] },
+        { id: "t2", kind: "llm", provider: "openai", model: "gpt-4", prompt: "p" },
+        { id: "t3", kind: "tool", tool: "b", args: [] },
+      ], [
+        { from: "t1", to: "t2" },
+        { from: "t2", to: "t3" },
+      ]);
+
+      const result = conditionalHarness("cond", trueHarness);
+
+      expect(result.combinedSpec.graph.nodes.filter((n) => n.id.startsWith("true-path:")).length).toBe(3);
+    });
+  });
+});