@mhingston5/lasso 0.1.0

package/test/state/snapshots.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it } from "vitest";
+import type { HarnessState } from "../../src/state/types.js";
+import { createHarnessState, addFailure, recordNodeResult, updateMetrics, captureSnapshot } from "../../src/state/snapshots.js";
+import type { FailureRecord } from "../../src/failures/types.js";
+
+describe("State snapshots", () => {
+  describe("HarnessState type", () => {
+    it("should represent complete harness execution state", () => {
+      const state: HarnessState = {
+        inputs: { prNumber: 42 },
+        outputs: { patchApplied: true },
+        nodeResults: {
+          "fetch-pr": { data: "..." },
+          "apply-patch": { success: true },
+        },
+        failures: [
+          {
+            domainType: "pr-review",
+            rootCause: "tool_timeout",
+            nodeId: "apply-patch",
+            message: "Timeout on first attempt",
+          },
+        ],
+        metrics: {
+          retries: 1,
+          durationMs: 5000,
+        },
+      };
+
+      expect(state.inputs).toEqual({ prNumber: 42 });
+      expect(state.outputs).toEqual({ patchApplied: true });
+      expect(state.nodeResults["fetch-pr"]).toEqual({ data: "..." });
+      expect(state.failures).toHaveLength(1);
+      expect(state.metrics.retries).toBe(1);
+      expect(state.metrics.durationMs).toBe(5000);
+    });
+  });
+
+  describe("createHarnessState", () => {
+    it("should initialize empty harness state", () => {
+      const state = createHarnessState({ userId: 123 });
+
+      expect(state.inputs).toEqual({ userId: 123 });
+      expect(state.outputs).toEqual({});
+      expect(state.nodeResults).toEqual({});
+      expect(state.failures).toEqual([]);
+      expect(state.metrics.retries).toBe(0);
+      expect(state.metrics.durationMs).toBe(0);
+    });
+
+    it("should initialize with empty input", () => {
+      const state = createHarnessState(undefined);
+
+      expect(state.inputs).toEqual({});
+      expect(state.outputs).toEqual({});
+      expect(state.nodeResults).toEqual({});
+      expect(state.failures).toEqual([]);
+      expect(state.metrics.retries).toBe(0);
+      expect(state.metrics.durationMs).toBe(0);
+    });
+
+    it("should deeply clone nested input objects to prevent external mutation", () => {
+      const input = {
+        config: { debug: true, retries: 3 },
+        data: { items: [1, 2, 3] },
+      };
+      const state = createHarnessState(input);
+
+      // Mutate the original input object
+      (input.config as any).debug = false;
+      (input.config as any).retries = 999;
+      input.data.items.push(4);
+
+      // State should be unaffected
+      expect(state.inputs.config).toEqual({ debug: true, retries: 3 });
+      expect(state.inputs.data).toEqual({ items: [1, 2, 3] });
+    });
+  });
+
+  describe("addFailure", () => {
+    it("should append failure to state", () => {
+      const state = createHarnessState({ test: true });
+      const failure: FailureRecord = {
+        domainType: "test",
+        rootCause: "tool_timeout",
+        nodeId: "node-1",
+        message: "Timeout",
+      };
+
+      addFailure(state, failure);
+
+      expect(state.failures).toHaveLength(1);
+      expect(state.failures[0]).toEqual(failure);
+    });
+
+    it("should support multiple failures", () => {
+      const state = createHarnessState({});
+      const failure1: FailureRecord = {
+        domainType: "test",
+        rootCause: "tool_timeout",
+        message: "First",
+      };
+      const failure2: FailureRecord = {
+        domainType: "test",
+        rootCause: "rate_limited",
+        message: "Second",
+      };
+
+      addFailure(state, failure1);
+      addFailure(state, failure2);
+
+      expect(state.failures).toHaveLength(2);
+      expect(state.failures[0]).toEqual(failure1);
+      expect(state.failures[1]).toEqual(failure2);
+    });
+  });
+
+  describe("recordNodeResult", () => {
+    it("should record node execution result", () => {
+      const state = createHarnessState({});
+      const result = { status: "success", data: 42 };
+
+      recordNodeResult(state, "compute-node", result);
+
+      expect(state.nodeResults["compute-node"]).toEqual(result);
+    });
+
+    it("should overwrite previous result for same node", () => {
+      const state = createHarnessState({});
+
+      recordNodeResult(state, "retry-node", { attempt: 1, failed: true });
+      recordNodeResult(state, "retry-node", { attempt: 2, succeeded: true });
+
+      expect(state.nodeResults["retry-node"]).toEqual({ attempt: 2, succeeded: true });
+    });
+  });
+
+  describe("updateMetrics", () => {
+    it("should update retry count", () => {
+      const state = createHarnessState({});
+
+      updateMetrics(state, { retries: 3 });
+
+      expect(state.metrics.retries).toBe(3);
+      expect(state.metrics.durationMs).toBe(0);
+    });
+
+    it("should update duration", () => {
+      const state = createHarnessState({});
+
+      updateMetrics(state, { durationMs: 1234 });
+
+      expect(state.metrics.retries).toBe(0);
+      expect(state.metrics.durationMs).toBe(1234);
+    });
+
+    it("should update both metrics", () => {
+      const state = createHarnessState({});
+
+      updateMetrics(state, { retries: 2, durationMs: 5678 });
+
+      expect(state.metrics.retries).toBe(2);
+      expect(state.metrics.durationMs).toBe(5678);
+    });
+
+    it("should increment metrics when called multiple times", () => {
+      const state = createHarnessState({});
+
+      updateMetrics(state, { retries: 1 });
+      updateMetrics(state, { retries: 2 });
+
+      expect(state.metrics.retries).toBe(2);
+    });
+  });
+
+  describe("captureSnapshot", () => {
+    it("should return immutable snapshot of current state", () => {
+      const state = createHarnessState({ input: "test" });
+      recordNodeResult(state, "node-1", { value: 1 });
+      addFailure(state, {
+        domainType: "test",
+        rootCause: "unknown",
+        message: "Error",
+      });
+      updateMetrics(state, { retries: 1, durationMs: 100 });
+
+      const snapshot = captureSnapshot(state);
+
+      expect(snapshot.inputs).toEqual({ input: "test" });
+      expect(snapshot.nodeResults).toEqual({ "node-1": { value: 1 } });
+      expect(snapshot.failures).toHaveLength(1);
+      expect(snapshot.metrics.retries).toBe(1);
+      expect(snapshot.metrics.durationMs).toBe(100);
+    });
+
+    it("should be independent from original state", () => {
+      const state = createHarnessState({ x: 1 });
+      const snapshot = captureSnapshot(state);
+
+      recordNodeResult(state, "node-2", { value: 2 });
+      addFailure(state, {
+        domainType: "test",
+        rootCause: "unknown",
+        message: "New failure",
+      });
+
+      expect(snapshot.nodeResults).toEqual({});
+      expect(snapshot.failures).toHaveLength(0);
+      expect(state.nodeResults["node-2"]).toEqual({ value: 2 });
+      expect(state.failures).toHaveLength(1);
+    });
+
+    it("should deeply clone nested objects in inputs", () => {
+      const nestedInput = { config: { debug: true, retries: 3 } };
+      const state = createHarnessState(nestedInput);
+      const snapshot = captureSnapshot(state);
+
+      (state.inputs.config as any).debug = false;
+      (state.inputs.config as any).retries = 999;
+
+      expect(snapshot.inputs.config).toEqual({ debug: true, retries: 3 });
+      expect(state.inputs.config).toEqual({ debug: false, retries: 999 });
+    });
+
+    it("should deeply clone nested objects in outputs", () => {
+      const state = createHarnessState({});
+      state.outputs["node-1"] = { result: { status: "ok", data: [1, 2, 3] } };
+      const snapshot = captureSnapshot(state);
+
+      (state.outputs["node-1"] as any).result.status = "failed";
+      (state.outputs["node-1"] as any).result.data.push(4);
+
+      expect(snapshot.outputs["node-1"]).toEqual({ result: { status: "ok", data: [1, 2, 3] } });
+      expect(state.outputs["node-1"]).toEqual({ result: { status: "failed", data: [1, 2, 3, 4] } });
+    });
+
+    it("should deeply clone nested objects in nodeResults", () => {
+      const state = createHarnessState({});
+      recordNodeResult(state, "compute", { matrix: [[1, 2], [3, 4]] });
+      const snapshot = captureSnapshot(state);
+
+      ((state.nodeResults["compute"] as any).matrix[0] as number[]).push(999);
+
+      expect(snapshot.nodeResults["compute"]).toEqual({ matrix: [[1, 2], [3, 4]] });
+      expect(state.nodeResults["compute"]).toEqual({ matrix: [[1, 2, 999], [3, 4]] });
+    });
+
+    it("should deeply clone failure records", () => {
+      const state = createHarnessState({});
+      addFailure(state, {
+        domainType: "test",
+        rootCause: "unknown",
+        message: "Error",
+        nodeId: "node-1",
+      });
+      const snapshot = captureSnapshot(state);
+
+      state.failures[0]!.message = "Modified message";
+
+      expect(snapshot.failures[0]?.message).toBe("Error");
+      expect(state.failures[0]?.message).toBe("Modified message");
+    });
+  });
+});

package/test/synthesis/custom-workflow.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect } from "vitest";
+import { parsePromptOrSkill } from "../../src/synthesis/skill-parser.js";
+import { validateIntent } from "../../src/synthesis/intent-ir.js";
+import type { IntentIR } from "../../src/synthesis/intent-ir.js";
+import { buildTaskGraph } from "../../src/synthesis/graph-builder.js";
+import { synthesizePolicy } from "../../src/synthesis/policy-builder.js";
+import type { RiskModel } from "../../src/synthesis/risk-analyzer.js";
+
+describe("custom workflow families", () => {
+  const lowRisks: RiskModel = {
+    overallRisk: "low",
+    approvalRequired: false,
+    candidateSourceKind: null,
+    verificationBreadth: "moderate",
+    stageRisks: new Map(),
+    mitigations: []
+  };
+
+  describe("validateIntent", () => {
+    it("should accept a custom family with steps", () => {
+      const intent: IntentIR = {
+        family: "deploy-staging",
+        goal: "Deploy to staging",
+        inputs: { repoPath: "/repo" },
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        steps: [
+          { id: "step-1", label: "Build", kind: "tool" },
+          { id: "step-2", label: "Deploy", kind: "tool" }
+        ]
+      };
+
+      const result = validateIntent(intent);
+      expect(result).toBeNull();
+    });
+
+    it("should accept a custom family without steps", () => {
+      const intent: IntentIR = {
+        family: "data-pipeline",
+        goal: "Run data pipeline",
+        inputs: {},
+        requiredTools: [],
+        humanCheckpoints: [],
+        verificationTargets: []
+      };
+
+      const result = validateIntent(intent);
+      expect(result).toBeNull();
+    });
+
+    it("should still accept patch-validation", () => {
+      const intent: IntentIR = {
+        family: "patch-validation",
+        goal: "Validate patch",
+        inputs: {},
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: []
+      };
+
+      const result = validateIntent(intent);
+      expect(result).toBeNull();
+    });
+
+    it("should still accept pr-review-merge", () => {
+      const intent: IntentIR = {
+        family: "pr-review-merge",
+        goal: "Review PR",
+        inputs: {},
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: []
+      };
+
+      const result = validateIntent(intent);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("buildTaskGraph", () => {
+    it("should create a graph from custom-family steps", () => {
+      const intent: IntentIR = {
+        family: "deploy-staging",
+        goal: "Deploy to staging",
+        inputs: { repoPath: "/repo", environment: "staging" },
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: ["curl https://staging.example.com/health"],
+        steps: [
+          { id: "step-1", label: "Build artifacts", kind: "tool" },
+          { id: "step-2", label: "Deploy to staging", kind: "tool" },
+          { id: "step-3", label: "Verify health", kind: "condition" }
+        ]
+      };
+
+      const graph = buildTaskGraph(intent);
+
+      expect(graph.family).toBe("deploy-staging");
+      expect(graph.stages.find(s => s.id === "step-1")).toBeDefined();
+      expect(graph.stages.find(s => s.id === "step-2")).toBeDefined();
+      expect(graph.stages.find(s => s.id === "step-3")).toBeDefined();
+      expect(graph.stages.find(s => s.id === "verify-target-0")).toBeDefined();
+    });
+
+    it("should create a minimal single-node graph for custom family without steps", () => {
+      const intent: IntentIR = {
+        family: "data-pipeline",
+        goal: "Run pipeline",
+        inputs: { source: "s3://bucket/data" },
+        requiredTools: [],
+        humanCheckpoints: [],
+        verificationTargets: []
+      };
+
+      const graph = buildTaskGraph(intent);
+
+      expect(graph.family).toBe("data-pipeline");
+      expect(graph.stages).toHaveLength(0);
+      expect(graph.goal).toBe("Run pipeline");
+    });
+
+    it("should connect steps sequentially for custom families", () => {
+      const intent: IntentIR = {
+        family: "deploy-staging",
+        goal: "Deploy",
+        inputs: {},
+        requiredTools: [],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        steps: [
+          { id: "step-1", label: "First", kind: "tool" },
+          { id: "step-2", label: "Second", kind: "tool" },
+          { id: "step-3", label: "Third", kind: "llm" }
+        ]
+      };
+
+      const graph = buildTaskGraph(intent);
+
+      expect(graph.stages.find(s => s.id === "step-1")!.dependencies).toEqual([]);
+      expect(graph.stages.find(s => s.id === "step-2")!.dependencies).toEqual(["step-1"]);
+      expect(graph.stages.find(s => s.id === "step-3")!.dependencies).toEqual(["step-2"]);
+    });
+  });
+
+  describe("synthesizePolicy", () => {
+    it("should produce a valid bundle for custom families with steps", () => {
+      const graph = buildTaskGraph({
+        family: "deploy-staging",
+        goal: "Deploy to staging",
+        inputs: { repoPath: "/repo" },
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        steps: [
+          { id: "step-1", label: "Build", kind: "tool" }
+        ]
+      });
+
+      const result = synthesizePolicy(graph, lowRisks);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.policy.workflow).toBe("deploy-staging");
+        expect(result.policy.bundle).toBeDefined();
+        expect(result.policy.rationale.length).toBeGreaterThan(0);
+      }
+    });
+
+    it("should produce a valid bundle for custom families without steps", () => {
+      const graph = buildTaskGraph({
+        family: "data-pipeline",
+        goal: "Run pipeline",
+        inputs: {},
+        requiredTools: [],
+        humanCheckpoints: [],
+        verificationTargets: []
+      });
+
+      const result = synthesizePolicy(graph, lowRisks);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.policy.workflow).toBe("data-pipeline");
+        expect(result.policy.bundle).toBeDefined();
+      }
+    });
+  });
+
+  describe("end-to-end: skill markdown with custom family", () => {
+    it("should compile a deploy-staging skill markdown end-to-end", () => {
+      const skillMd = `
+# Deploy to Staging
+
+workflow: deploy-staging
+
+## Inputs
+- repoPath: /path/to/repo
+- environment: staging
+
+## Steps
+- [tool] Build artifacts
+- [tool] Deploy to staging env
+- [condition] Health check passed
+- [human] Approve go-live
+
+## Verification
+- curl https://staging.example.com/health
+      `;
+
+      const result = parsePromptOrSkill(skillMd);
+
+      expect(result).toHaveProperty("success", true);
+      if ("success" in result && result.success) {
+        expect(result.intent.family).toBe("deploy-staging");
+        expect(result.intent.steps).toHaveLength(4);
+        expect(result.intent.inputs.repoPath).toBe("/path/to/repo");
+        expect(result.intent.inputs.environment).toBe("staging");
+        expect(result.intent.verificationTargets).toContain("curl https://staging.example.com/health");
+
+        const graph = buildTaskGraph(result.intent);
+        expect(graph.family).toBe("deploy-staging");
+        expect(graph.stages.find(s => s.id === "step-1")).toBeDefined();
+        expect(graph.stages.find(s => s.id === "step-4")).toBeDefined();
+        expect(graph.stages.find(s => s.id === "verify-target-0")).toBeDefined();
+
+        const risks = {
+          overallRisk: "low" as const,
+          approvalRequired: false,
+          candidateSourceKind: null as null,
+          verificationBreadth: "moderate" as const,
+          stageRisks: new Map(),
+          mitigations: []
+        };
+        const policyResult = synthesizePolicy(graph, risks);
+        expect(policyResult.success).toBe(true);
+      }
+    });
+
+    it("should compile a custom family skill markdown with no steps", () => {
+      const skillMd = `
+# Data Pipeline
+
+workflow: data-pipeline
+
+## Inputs
+- source: s3://bucket/data
+      `;
+
+      const result = parsePromptOrSkill(skillMd);
+
+      expect(result).toHaveProperty("success", true);
+      if ("success" in result && result.success) {
+        expect(result.intent.family).toBe("data-pipeline");
+
+        const graph = buildTaskGraph(result.intent);
+        expect(graph.family).toBe("data-pipeline");
+
+        const policyResult = synthesizePolicy(graph, lowRisks);
+        expect(policyResult.success).toBe(true);
+      }
+    });
+  });
+});