@mhingston5/lasso 0.1.0

package/test/composition/parallel.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, it } from "vitest";
+import { parallelHarnesses } from "../../src/composition/parallel.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("parallelHarnesses", () => {
+  describe("basic parallel execution", () => {
+    it("merges two harnesses in parallel", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("alpha", [
+          { id: "a1", kind: "tool", tool: "echo", args: ["alpha"] },
+        ]),
+        makeSpec("beta", [
+          { id: "b1", kind: "tool", tool: "echo", args: ["beta"] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      expect(result.stageCount).toBe(2);
+      expect(result.totalNodes).toBeGreaterThanOrEqual(3);
+    });
+
+    it("creates a merge node to synchronize parallel branches", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("alpha", [
+          { id: "a1", kind: "tool", tool: "echo", args: ["a"] },
+        ]),
+        makeSpec("beta", [
+          { id: "b1", kind: "tool", tool: "echo", args: ["b"] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const mergeNode = result.combinedSpec.graph.nodes.find((n) => n.kind === "merge");
+      expect(mergeNode).toBeDefined();
+      expect(mergeNode!.kind).toBe("merge");
+    });
+
+    it("merge node waits for all branch terminal nodes", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("alpha", [
+          { id: "a1", kind: "tool", tool: "echo", args: ["a"] },
+        ]),
+        makeSpec("beta", [
+          { id: "b1", kind: "tool", tool: "echo", args: ["b"] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const mergeNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "merge",
+      ) as any;
+      expect(mergeNode).toBeDefined();
+      expect(mergeNode.waitFor).toContain("alpha:a1");
+      expect(mergeNode.waitFor).toContain("beta:b1");
+    });
+  });
+
+  describe("node ID prefixing", () => {
+    it("prefixes node IDs with harness name to avoid collisions", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [
+          { id: "step", kind: "tool", tool: "a", args: [] },
+        ]),
+        makeSpec("h2", [
+          { id: "step", kind: "tool", tool: "b", args: [] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      expect(nodeIds).toContain("h1:step");
+      expect(nodeIds).toContain("h2:step");
+    });
+
+    it("produces all unique node IDs", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [
+          { id: "x", kind: "tool", tool: "a", args: [] },
+          { id: "y", kind: "tool", tool: "b", args: [] },
+        ]),
+        makeSpec("h2", [
+          { id: "x", kind: "tool", tool: "c", args: [] },
+          { id: "y", kind: "tool", tool: "d", args: [] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const nodeIds = result.combinedSpec.graph.nodes.map((n) => n.id);
+      const uniqueIds = new Set(nodeIds);
+      expect(uniqueIds.size).toBe(nodeIds.length);
+    });
+  });
+
+  describe("edge rewiring", () => {
+    it("rewires internal edges with prefixed IDs", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [
+          { id: "first", kind: "tool", tool: "a", args: [] },
+          { id: "second", kind: "tool", tool: "b", args: [] },
+        ], [{ from: "first", to: "second" }]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const edge = result.combinedSpec.graph.edges.find(
+        (e) => e.from === "h1:first" && e.to === "h1:second",
+      );
+      expect(edge).toBeDefined();
+    });
+
+    it("connects each branch terminal node to merge node", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [
+          { id: "a1", kind: "tool", tool: "a", args: [] },
+        ]),
+        makeSpec("h2", [
+          { id: "b1", kind: "tool", tool: "b", args: [] },
+        ]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const mergeNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "merge",
+      )!;
+      const mergeNodeId = mergeNode.id;
+
+      const edgesToMerge = result.combinedSpec.graph.edges.filter(
+        (e) => e.to === mergeNodeId,
+      );
+      expect(edgesToMerge.length).toBe(2);
+    });
+  });
+
+  describe("multi-harness parallel", () => {
+    it("merges three harnesses in parallel", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [{ id: "a", kind: "tool", tool: "a", args: [] }]),
+        makeSpec("h2", [{ id: "b", kind: "tool", tool: "b", args: [] }]),
+        makeSpec("h3", [{ id: "c", kind: "tool", tool: "c", args: [] }]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      expect(result.stageCount).toBe(3);
+      const mergeNode = result.combinedSpec.graph.nodes.find(
+        (n) => n.kind === "merge",
+      ) as any;
+      expect(mergeNode.waitFor.length).toBe(3);
+    });
+
+    it("entry point connects to all harness entry nodes", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [{ id: "a", kind: "tool", tool: "a", args: [] }]),
+        makeSpec("h2", [{ id: "b", kind: "tool", tool: "b", args: [] }]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      const entryId = result.combinedSpec.graph.entryNodeId;
+      const entryNode = result.combinedSpec.graph.nodes.find((n) => n.id === entryId);
+      expect(entryNode).toBeDefined();
+
+      const edgesFromEntry = result.combinedSpec.graph.edges.filter(
+        (e) => e.from === entryId,
+      );
+      expect(edgesFromEntry.length).toBe(2);
+    });
+  });
+
+  describe("composition result", () => {
+    it("calculates total nodes including merge and entry", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [{ id: "a", kind: "tool", tool: "a", args: [] }]),
+        makeSpec("h2", [{ id: "b", kind: "tool", tool: "b", args: [] }]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      expect(result.totalNodes).toBe(4);
+    });
+
+    it("estimates duration", () => {
+      const harnesses: HarnessSpec[] = [
+        makeSpec("h1", [{ id: "a", kind: "tool", tool: "a", args: [] }]),
+      ];
+
+      const result = parallelHarnesses(harnesses);
+
+      expect(result.estimatedDurationMs).toBeGreaterThan(0);
+    });
+  });
+
+  describe("empty harnesses", () => {
+    it("throws on empty array", () => {
+      expect(() => parallelHarnesses([])).toThrow();
+    });
+  });
+});

package/test/environment/analyzer.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect } from "vitest";
+import { analyzeEnvironment } from "../../src/environment/analyzer.js";
+import type { EnvironmentModel, ToolCapability, Constraint } from "../../src/environment/types.js";
+
+function createMockModel(overrides: Partial<EnvironmentModel> = {}): EnvironmentModel {
+  return {
+    tools: [
+      { name: "bash", version: "5.0.0", available: true },
+      { name: "git", version: "2.30.0", available: true },
+      { name: "node", version: "18.0.0", available: true },
+    ],
+    resources: [
+      { name: "disk", type: "disk", available: true, limit: "500GB", usage: "200GB" },
+    ],
+    constraints: [],
+    authState: [],
+    externalSystems: [],
+    discoveredAt: Date.now(),
+    ...overrides,
+  };
+}
+
+describe("analyzeEnvironment", () => {
+  describe("tool matching", () => {
+    it("matches all available required tools", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.matchedTools).toHaveLength(2);
+      expect(result.missingTools).toHaveLength(0);
+      expect(result.matchedTools.map(t => t.name)).toContain("bash");
+      expect(result.matchedTools.map(t => t.name)).toContain("git");
+    });
+
+    it("identifies missing required tools", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, ["bash", "nonexistent-tool"]);
+
+      expect(result.matchedTools).toHaveLength(1);
+      expect(result.missingTools).toHaveLength(1);
+      expect(result.missingTools).toContain("nonexistent-tool");
+    });
+
+    it("handles empty required tools list", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, []);
+
+      expect(result.matchedTools).toHaveLength(0);
+      expect(result.missingTools).toHaveLength(0);
+    });
+
+    it("handles undefined required tools", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model);
+
+      expect(result.matchedTools).toHaveLength(0);
+      expect(result.missingTools).toHaveLength(0);
+    });
+
+    it("identifies multiple missing tools", () => {
+      const model = createMockModel({
+        tools: [
+          { name: "bash", available: true },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash", "git", "node", "docker"]);
+
+      expect(result.missingTools).toHaveLength(3);
+      expect(result.missingTools).toContain("git");
+      expect(result.missingTools).toContain("node");
+      expect(result.missingTools).toContain("docker");
+    });
+  });
+
+  describe("readiness score", () => {
+    it("computes 100 when all tools available", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.readinessScore).toBe(100);
+    });
+
+    it("computes 0 when no tools available", () => {
+      const model = createMockModel({
+        tools: [
+          { name: "bash", available: false },
+          { name: "git", available: false },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.readinessScore).toBe(0);
+    });
+
+    it("computes 50 when half tools available", () => {
+      const model = createMockModel({
+        tools: [
+          { name: "bash", available: true },
+          { name: "git", available: false },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.readinessScore).toBe(50);
+    });
+
+    it("reduces score for high-risk constraints", () => {
+      const model = createMockModel({
+        tools: [
+          { name: "bash", available: true },
+          { name: "git", available: true },
+        ],
+        constraints: [
+          { type: "auth", description: "GitHub not authenticated", severity: "high" },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.readinessScore).toBeLessThan(100);
+    });
+  });
+
+  describe("constraint analysis", () => {
+    it("flags high-risk constraints", () => {
+      const highRisk: Constraint = {
+        type: "auth",
+        description: "GitHub not authenticated",
+        severity: "high",
+      };
+      const model = createMockModel({
+        constraints: [
+          highRisk,
+          { type: "network", description: "Slow network", severity: "low" },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash"]);
+
+      expect(result.highRiskConstraints).toHaveLength(1);
+      expect(result.highRiskConstraints[0]).toBe(highRisk);
+    });
+
+    it("returns empty highRiskConstraints when none exist", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, ["bash"]);
+
+      expect(result.highRiskConstraints).toHaveLength(0);
+    });
+
+    it("includes medium severity constraints in preparatory steps", () => {
+      const model = createMockModel({
+        constraints: [
+          { type: "network", description: "Rate limit approaching", severity: "medium" },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash"]);
+
+      expect(result.preparatorySteps.some(s => s.includes("Rate limit"))).toBe(true);
+    });
+  });
+
+  describe("preparatory steps", () => {
+    it("suggests steps for missing tools", () => {
+      const model = createMockModel({
+        tools: [{ name: "bash", available: true }],
+      });
+
+      const result = analyzeEnvironment(model, ["bash", "docker"]);
+
+      expect(result.preparatorySteps.some(s => s.includes("docker"))).toBe(true);
+    });
+
+    it("suggests steps for high-risk constraints", () => {
+      const model = createMockModel({
+        constraints: [
+          { type: "auth", description: "GitHub not authenticated", severity: "high" },
+        ],
+      });
+
+      const result = analyzeEnvironment(model, ["bash"]);
+
+      expect(result.preparatorySteps.some(s => s.includes("GitHub"))).toBe(true);
+    });
+
+    it("returns empty preparatory steps when environment is ready", () => {
+      const model = createMockModel();
+
+      const result = analyzeEnvironment(model, ["bash", "git"]);
+
+      expect(result.preparatorySteps).toHaveLength(0);
+    });
+  });
+});

package/test/environment/discovery.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { discoverEnvironment } from "../../src/environment/discovery.js";
+import type { DiscoveryOptions } from "../../src/environment/types.js";
+
+describe("discoverEnvironment", () => {
+  describe("tool detection", () => {
+    it("detects available tools (bash should be available)", async () => {
+      const model = await discoverEnvironment();
+
+      const bashTool = model.tools.find(t => t.name === "bash");
+      expect(bashTool).toBeDefined();
+      expect(bashTool!.available).toBe(true);
+      expect(bashTool!.version).toBeDefined();
+    });
+
+    it("detects git as available", async () => {
+      const model = await discoverEnvironment();
+
+      const gitTool = model.tools.find(t => t.name === "git");
+      expect(gitTool).toBeDefined();
+      expect(gitTool!.available).toBe(true);
+    });
+
+    it("detects node as available", async () => {
+      const model = await discoverEnvironment();
+
+      const nodeTool = model.tools.find(t => t.name === "node");
+      expect(nodeTool).toBeDefined();
+      expect(nodeTool!.available).toBe(true);
+    });
+
+    it("reports missing tools as unavailable", async () => {
+      const options: DiscoveryOptions = {
+        tools: ["bash", "nonexistent-tool-xyz-123"],
+      };
+      const model = await discoverEnvironment(undefined, options);
+
+      const missingTool = model.tools.find(t => t.name === "nonexistent-tool-xyz-123");
+      expect(missingTool).toBeDefined();
+      expect(missingTool!.available).toBe(false);
+    });
+
+    it("uses default tool set when no tools specified", async () => {
+      const model = await discoverEnvironment();
+
+      const defaultTools = ["bash", "git", "node"];
+      for (const toolName of defaultTools) {
+        const tool = model.tools.find(t => t.name === toolName);
+        expect(tool).toBeDefined();
+      }
+    });
+
+    it("discovers custom tools list", async () => {
+      const options: DiscoveryOptions = {
+        tools: ["bash", "node"],
+      };
+      const model = await discoverEnvironment(undefined, options);
+
+      expect(model.tools).toHaveLength(2);
+      expect(model.tools.map(t => t.name)).toContain("bash");
+      expect(model.tools.map(t => t.name)).toContain("node");
+    });
+  });
+
+  describe("resource detection", () => {
+    it("detects disk resource", async () => {
+      const model = await discoverEnvironment();
+
+      const diskResource = model.resources.find(r => r.type === "disk");
+      expect(diskResource).toBeDefined();
+      expect(diskResource!.available).toBe(true);
+    });
+  });
+
+  describe("repo state detection", () => {
+    it("detects repo state when repoPath provided", async () => {
+      const model = await discoverEnvironment(process.cwd());
+
+      expect(model.repoState).toBeDefined();
+      expect(model.repoState!.path).toBe(process.cwd());
+    });
+
+    it("does not set repoState when no repoPath provided", async () => {
+      const model = await discoverEnvironment();
+
+      expect(model.repoState).toBeUndefined();
+    });
+
+    it("detects branch name in a git repo", async () => {
+      const model = await discoverEnvironment(process.cwd());
+
+      expect(model.repoState!.branch).toBeDefined();
+    });
+
+    it("detects remotes in a git repo", async () => {
+      const model = await discoverEnvironment(process.cwd());
+
+      expect(Array.isArray(model.repoState!.remotes)).toBe(true);
+    });
+  });
+
+  describe("external system probing", () => {
+    it("probes external systems when specified", async () => {
+      const options: DiscoveryOptions = {
+        externalSystems: ["example.com"],
+        networkTimeoutMS: 2000,
+      };
+      const model = await discoverEnvironment(undefined, options);
+
+      const exampleSystem = model.externalSystems.find(s => s.name === "example.com");
+      expect(exampleSystem).toBeDefined();
+    });
+
+    it("reports unreachable systems", async () => {
+      const options: DiscoveryOptions = {
+        externalSystems: ["192.0.2.1"],
+        networkTimeoutMS: 500,
+      };
+      const model = await discoverEnvironment(undefined, options);
+
+      const unreachableSystem = model.externalSystems.find(s => s.name === "192.0.2.1");
+      expect(unreachableSystem).toBeDefined();
+      expect(unreachableSystem!.reachable).toBe(false);
+    });
+  });
+
+  describe("model metadata", () => {
+    it("sets discoveredAt timestamp", async () => {
+      const before = Date.now();
+      const model = await discoverEnvironment();
+      const after = Date.now();
+
+      expect(model.discoveredAt).toBeGreaterThanOrEqual(before);
+      expect(model.discoveredAt).toBeLessThanOrEqual(after);
+    });
+
+    it("includes auth state array", async () => {
+      const model = await discoverEnvironment();
+
+      expect(Array.isArray(model.authState)).toBe(true);
+    });
+
+    it("includes constraints array", async () => {
+      const model = await discoverEnvironment();
+
+      expect(Array.isArray(model.constraints)).toBe(true);
+    });
+  });
+});