@mhingston5/lasso 0.1.0

package/src/versioning/file-store.ts

@@ -0,0 +1,103 @@
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { HarnessVersion, LineageEntry } from "./types.js";
+import type { LineageFilter, LineageStore } from "./store.js";
+
+export class FileLineageStore implements LineageStore {
+  private readonly versionsDir: string;
+  private readonly lineageDir: string;
+
+  constructor(private readonly storeDir: string) {
+    this.versionsDir = join(storeDir, "versions");
+    this.lineageDir = join(storeDir, "lineage");
+  }
+
+  async saveVersion(version: HarnessVersion): Promise<void> {
+    await mkdir(this.versionsDir, { recursive: true });
+    const data = structuredClone(version);
+    const filePath = join(this.versionsDir, `${version.version}.json`);
+    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+
+  async saveLineage(entry: LineageEntry): Promise<void> {
+    await mkdir(this.lineageDir, { recursive: true });
+    const data = structuredClone(entry);
+    const filePath = join(this.lineageDir, `${entry.version}.json`);
+    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+
+  async getVersion(version: number): Promise<HarnessVersion | null> {
+    try {
+      const filePath = join(this.versionsDir, `${version}.json`);
+      const raw = await readFile(filePath, "utf-8");
+      return JSON.parse(raw) as HarnessVersion;
+    } catch {
+      return null;
+    }
+  }
+
+  async getLineageForVersion(version: number): Promise<LineageEntry | null> {
+    try {
+      const filePath = join(this.lineageDir, `${version}.json`);
+      const raw = await readFile(filePath, "utf-8");
+      return JSON.parse(raw) as LineageEntry;
+    } catch {
+      return null;
+    }
+  }
+
+  async getLineageChain(version: number): Promise<LineageEntry[]> {
+    const chain: LineageEntry[] = [];
+    let current: number | undefined = version;
+
+    while (current !== undefined) {
+      const [entry, versionData] = await Promise.all([
+        this.getLineageForVersion(current),
+        this.getVersion(current),
+      ]);
+
+      if (!entry || !versionData) {
+        break;
+      }
+
+      chain.unshift(entry);
+      current = versionData.parentVersion;
+    }
+
+    return chain;
+  }
+
+  async queryLineage(filter: LineageFilter): Promise<LineageEntry[]> {
+    let entries = await this.loadAllLineage();
+
+    if (filter.terminalNodeId) {
+      entries = entries.filter((e) => e.terminalNodeId === filter.terminalNodeId);
+    }
+
+    if (filter.since !== undefined) {
+      entries = entries.filter((e) => e.completedAt >= filter.since!);
+    }
+
+    if (filter.limit !== undefined) {
+      entries = entries.slice(0, filter.limit);
+    }
+
+    return entries;
+  }
+
+  private async loadAllLineage(): Promise<LineageEntry[]> {
+    try {
+      const files = await readdir(this.lineageDir);
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      const entries = await Promise.all(
+        jsonFiles.map(async (file) => {
+          const raw = await readFile(join(this.lineageDir, file), "utf-8");
+          return JSON.parse(raw) as LineageEntry;
+        }),
+      );
+      return entries.sort((a, b) => a.version - b.version);
+    } catch {
+      return [];
+    }
+  }
+}

package/src/versioning/history.ts

@@ -0,0 +1,43 @@
+import type { CompiledHarnessResult } from "../compiler/compile.js";
+import type { HarnessSpec } from "../spec/types.js";
+import type { HarnessVersion, LineageEntry } from "./types.js";
+
+export function createInitialVersion(spec: HarnessSpec): HarnessVersion {
+  return {
+    version: 1,
+    parentVersion: undefined,
+    reason: "initial",
+    spec: structuredClone(spec),
+    generatedAt: Date.now(),
+  };
+}
+
+export function createNextVersion(
+  parentVersion: HarnessVersion,
+  spec: HarnessSpec,
+  reason: string,
+): HarnessVersion {
+  return {
+    version: parentVersion.version + 1,
+    parentVersion: parentVersion.version,
+    reason,
+    spec: structuredClone(spec),
+    generatedAt: Date.now(),
+  };
+}
+
+export function createLineageEntry(
+  version: HarnessVersion,
+  result: CompiledHarnessResult,
+): LineageEntry {
+  return {
+    version: version.version,
+    terminalNodeId: result.terminalNodeId,
+    outputs: structuredClone(result.outputs),
+    nodeResults: structuredClone(result.harnessState.nodeResults),
+    failures: structuredClone(result.harnessState.failures),
+    metrics: structuredClone(result.harnessState.metrics),
+    trace: structuredClone(result.trace),
+    completedAt: Date.now(),
+  };
+}

package/src/versioning/store.ts

@@ -0,0 +1,16 @@
+import type { HarnessVersion, LineageEntry } from "./types.js";
+
+export interface LineageFilter {
+  terminalNodeId?: string;
+  since?: number;
+  limit?: number;
+}
+
+export interface LineageStore {
+  saveVersion(version: HarnessVersion): Promise<void>;
+  saveLineage(entry: LineageEntry): Promise<void>;
+  getVersion(version: number): Promise<HarnessVersion | null>;
+  getLineageForVersion(version: number): Promise<LineageEntry | null>;
+  getLineageChain(version: number): Promise<LineageEntry[]>;
+  queryLineage(filter: LineageFilter): Promise<LineageEntry[]>;
+}

package/src/versioning/types.ts

@@ -0,0 +1,31 @@
+import type { HarnessSpec } from "../spec/types.js";
+import type { HarnessState } from "../state/types.js";
+import type { ExecutionTraceEntry } from "../compiler/runtime-helpers.js";
+
+export interface HarnessVersion {
+  version: number;
+  parentVersion?: number;
+  reason: string;
+  spec: HarnessSpec;
+  generatedAt: number;
+}
+
+export interface HarnessExecutionTrace {
+  entries: ExecutionTraceEntry[];
+  totalDurationMs: number;
+  nodeCount: number;
+  failureCount: number;
+  startTimeMs: number;
+  endTimeMs: number;
+}
+
+export interface LineageEntry {
+  version: number;
+  terminalNodeId: string;
+  outputs: Record<string, unknown>;
+  nodeResults: Record<string, unknown>;
+  failures: HarnessState["failures"];
+  metrics: HarnessState["metrics"];
+  trace: HarnessExecutionTrace;
+  completedAt: number;
+}

package/test/capabilities/matcher.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { matchCapabilities } from "../../src/capabilities/matcher.js";
+import { DefaultCapabilityRegistry } from "../../src/capabilities/registry.js";
+import type { Capability } from "../../src/capabilities/types.js";
+
+describe("capability matcher", () => {
+  describe("matchCapabilities", () => {
+    it("should match all available capabilities", () => {
+      const registry = new DefaultCapabilityRegistry();
+
+      const result = matchCapabilities(["bash", "git"], registry);
+
+      expect(result.matched).toHaveLength(2);
+      expect(result.missing).toHaveLength(0);
+      expect(result.matched.map(c => c.id)).toContain("bash");
+      expect(result.matched.map(c => c.id)).toContain("git");
+    });
+
+    it("should report missing capabilities", () => {
+      const registry = new DefaultCapabilityRegistry();
+
+      const result = matchCapabilities(["bash", "nonexistent-tool"], registry);
+
+      expect(result.matched).toHaveLength(1);
+      expect(result.missing).toHaveLength(1);
+      expect(result.missing).toContain("nonexistent-tool");
+      expect(result.matched.map(c => c.id)).toContain("bash");
+    });
+
+    it("should handle empty required tools", () => {
+      const registry = new DefaultCapabilityRegistry();
+
+      const result = matchCapabilities([], registry);
+
+      expect(result.matched).toHaveLength(0);
+      expect(result.missing).toHaveLength(0);
+    });
+
+    it("should match capability with prerequisites declared", () => {
+      const registry = new DefaultCapabilityRegistry();
+      const custom: Capability = {
+        id: "custom-tool",
+        kind: "tool",
+        name: "Custom Tool",
+        prerequisites: ["bash", "git"],
+        risks: [],
+        verification: []
+      };
+      registry.registerCapability(custom);
+
+      const result = matchCapabilities(["custom-tool"], registry);
+
+      expect(result.matched).toHaveLength(1);
+      expect(result.missing).toHaveLength(0);
+      expect(result.matched[0].id).toBe("custom-tool");
+    });
+
+    it("should include all pre-registered capabilities", () => {
+      const registry = new DefaultCapabilityRegistry();
+
+      const result = matchCapabilities(["bash", "git", "node", "llm-review", "human-approval"], registry);
+
+      expect(result.matched).toHaveLength(5);
+      expect(result.missing).toHaveLength(0);
+    });
+  });
+});

package/test/capabilities/registry.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from "vitest";
+import { DefaultCapabilityRegistry } from "../../src/capabilities/registry.js";
+import type { Capability } from "../../src/capabilities/types.js";
+
+describe("capability registry", () => {
+  describe("DefaultCapabilityRegistry", () => {
+    describe("CRUD operations", () => {
+      it("should register and retrieve a capability", () => {
+        const registry = new DefaultCapabilityRegistry();
+        const cap: Capability = {
+          id: "test-cap",
+          kind: "tool",
+          name: "Test Capability",
+          prerequisites: [],
+          risks: [],
+          verification: []
+        };
+
+        registry.registerCapability(cap);
+
+        expect(registry.hasCapability("test-cap")).toBe(true);
+        expect(registry.getCapability("test-cap")).toEqual(cap);
+      });
+
+      it("should return undefined for non-existent capability", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("nonexistent")).toBe(false);
+        expect(registry.getCapability("nonexistent")).toBeUndefined();
+      });
+
+      it("should list all registered capabilities", () => {
+        const registry = new DefaultCapabilityRegistry();
+        const initialCount = registry.getCapabilities().length;
+        const cap1: Capability = {
+          id: "cap1",
+          kind: "tool",
+          name: "Cap 1",
+          prerequisites: [],
+          risks: [],
+          verification: []
+        };
+        const cap2: Capability = {
+          id: "cap2",
+          kind: "llm",
+          name: "Cap 2",
+          prerequisites: [],
+          risks: [],
+          verification: []
+        };
+
+        registry.registerCapability(cap1);
+        registry.registerCapability(cap2);
+
+        const all = registry.getCapabilities();
+        expect(all).toHaveLength(initialCount + 2);
+        expect(all).toContainEqual(cap1);
+        expect(all).toContainEqual(cap2);
+      });
+
+      it("should overwrite existing capability on re-register", () => {
+        const registry = new DefaultCapabilityRegistry();
+        const initialCount = registry.getCapabilities().length;
+        const cap1: Capability = {
+          id: "test",
+          kind: "tool",
+          name: "Original",
+          prerequisites: [],
+          risks: [],
+          verification: []
+        };
+        const cap2: Capability = {
+          id: "test",
+          kind: "llm",
+          name: "Updated",
+          prerequisites: ["other"],
+          risks: ["risk1"],
+          verification: ["verify1"]
+        };
+
+        registry.registerCapability(cap1);
+        registry.registerCapability(cap2);
+
+        expect(registry.getCapabilities()).toHaveLength(initialCount + 1);
+        expect(registry.getCapability("test")?.name).toBe("Updated");
+        expect(registry.getCapability("test")?.prerequisites).toEqual(["other"]);
+      });
+    });
+
+    describe("pre-registered capabilities", () => {
+      it("should have bash capability pre-registered", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("bash")).toBe(true);
+        const bash = registry.getCapability("bash");
+        expect(bash?.kind).toBe("tool");
+        expect(bash?.risks.length).toBeGreaterThan(0);
+      });
+
+      it("should have git capability pre-registered", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("git")).toBe(true);
+        const git = registry.getCapability("git");
+        expect(git?.kind).toBe("tool");
+        expect(git?.prerequisites).toContain("bash");
+      });
+
+      it("should have node capability pre-registered", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("node")).toBe(true);
+        const node = registry.getCapability("node");
+        expect(node?.kind).toBe("tool");
+        expect(node?.prerequisites).toContain("bash");
+      });
+
+      it("should have llm-review capability pre-registered", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("llm-review")).toBe(true);
+        const llmReview = registry.getCapability("llm-review");
+        expect(llmReview?.kind).toBe("llm");
+        expect(llmReview?.verification.length).toBeGreaterThan(0);
+      });
+
+      it("should have human-approval capability pre-registered", () => {
+        const registry = new DefaultCapabilityRegistry();
+
+        expect(registry.hasCapability("human-approval")).toBe(true);
+        const humanApproval = registry.getCapability("human-approval");
+        expect(humanApproval?.kind).toBe("human");
+      });
+    });
+  });
+});

package/test/capabilities/synthesis.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect } from "vitest";
+import { buildTaskGraph } from "../../src/synthesis/graph-builder.js";
+import { analyzeRisks } from "../../src/synthesis/risk-analyzer.js";
+import { synthesizePolicy } from "../../src/synthesis/policy-builder.js";
+import { planWorkflowRequest } from "../../src/planner/synthesize.js";
+import { DefaultCapabilityRegistry } from "../../src/capabilities/registry.js";
+import type { IntentIR } from "../../src/synthesis/intent-ir.js";
+import type { CapabilityRegistry } from "../../src/capabilities/types.js";
+
+function createRegistry(): CapabilityRegistry {
+  return new DefaultCapabilityRegistry();
+}
+
+describe("capability-driven synthesis", () => {
+  describe("graph construction from capabilities", () => {
+    it("should build capability-driven graph when capabilities are present", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["bash", "git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "git"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+
+      expect(graph.stages.length).toBeGreaterThan(0);
+      expect(graph.stages.some(s => s.type === "setup")).toBe(true);
+    });
+
+    it("should include verification stages from capability verification steps", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["git"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+
+      const verifyStages = graph.stages.filter(s => s.type === "verify");
+      expect(verifyStages.length).toBeGreaterThan(0);
+    });
+
+    it("should include risk stages from capability risk declarations", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["bash"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+
+      expect(graph.stages.some(s => s.id.includes("risk") || s.description.toLowerCase().includes("risk"))).toBe(true);
+    });
+
+    it("should add human-approval stage when human-approval capability is required", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow with approval",
+        inputs: {},
+        requiredTools: ["bash", "human-approval"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "human-approval"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+
+      expect(graph.stages.some(s => s.type === "approval")).toBe(true);
+    });
+
+    it("should handle missing capabilities gracefully", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["bash", "nonexistent"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "nonexistent"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+
+      expect(graph.stages.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("backward compatibility", () => {
+    it("should still build patch-validation graph without capabilities", () => {
+      const intent: IntentIR = {
+        family: "patch-validation",
+        goal: "Validate patch",
+        inputs: {
+          repoPath: "/repo",
+          baselineRef: "main",
+          candidateBranch: "fix",
+          reproduceCommands: ["npm run fail"],
+          verificationCommands: ["npm test"],
+          reviewInstructions: "Check"
+        },
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: ["npm test"]
+      };
+
+      const graph = buildTaskGraph(intent);
+
+      expect(graph.family).toBe("patch-validation");
+      expect(graph.stages.map(s => s.type)).toEqual([
+        "setup", "reproduce", "apply", "verify", "review"
+      ]);
+    });
+
+    it("should still build pr-review-merge graph without capabilities", () => {
+      const intent: IntentIR = {
+        family: "pr-review-merge",
+        goal: "Review and merge PR",
+        inputs: {
+          repoPath: "/repo",
+          sourceBranch: "feature",
+          targetBranch: "main",
+          reviewInstructions: "Check",
+          verificationCommands: ["npm test"]
+        },
+        requiredTools: ["git"],
+        humanCheckpoints: [],
+        verificationTargets: ["npm test"]
+      };
+
+      const graph = buildTaskGraph(intent);
+
+      expect(graph.family).toBe("pr-review-merge");
+      expect(graph.stages.map(s => s.type)).toEqual([
+        "setup", "review", "verify", "merge"
+      ]);
+    });
+  });
+
+  describe("risk analysis with capabilities", () => {
+    it("should lower risk when all capabilities are available", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run workflow",
+        inputs: {},
+        requiredTools: ["bash", "git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "git"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+      const risks = analyzeRisks(graph, registry);
+
+      expect(risks.overallRisk).toBe("low");
+      expect(risks.capabilityRisk).toBeDefined();
+      expect(risks.capabilityRisk?.allAvailable).toBe(true);
+    });
+
+    it("should escalate risk when capabilities are missing", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run workflow",
+        inputs: {},
+        requiredTools: ["bash", "missing-tool"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "missing-tool"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+      const risks = analyzeRisks(graph, registry);
+
+      expect(risks.capabilityRisk).toBeDefined();
+      expect(risks.capabilityRisk?.allAvailable).toBe(false);
+      expect(risks.capabilityRisk?.missing).toContain("missing-tool");
+    });
+
+    it("should incorporate capability risk declarations", () => {
+      const registry = createRegistry();
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run workflow",
+        inputs: {},
+        requiredTools: ["bash"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash"]
+      };
+
+      const graph = buildTaskGraph(intent, registry);
+      const risks = analyzeRisks(graph, registry);
+
+      expect(risks.capabilityRisk?.riskFactors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("end-to-end capability-driven synthesis", () => {
+    it("should synthesize policy from capability-driven intent", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["bash", "git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "git"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+      const risks = analyzeRisks(graph, registry);
+      const policyResult = synthesizePolicy(graph, risks);
+
+      expect(policyResult.success).toBe(true);
+      if (policyResult.success) {
+        expect(policyResult.policy.workflow).toBe("custom");
+        expect(policyResult.policy.rationale.length).toBeGreaterThan(0);
+      }
+    });
+
+    it("should include capability information in rationale", () => {
+      const intent: IntentIR = {
+        family: "custom",
+        goal: "Run custom workflow",
+        inputs: {},
+        requiredTools: ["bash", "git"],
+        humanCheckpoints: [],
+        verificationTargets: [],
+        capabilities: ["bash", "git"]
+      };
+
+      const registry = createRegistry();
+      const graph = buildTaskGraph(intent, registry);
+      const risks = analyzeRisks(graph, registry);
+      const policyResult = synthesizePolicy(graph, risks);
+
+      expect(policyResult.success).toBe(true);
+      if (policyResult.success) {
+        const hasCapabilityMention = policyResult.policy.rationale.some(
+          r => r.toLowerCase().includes("capability") || r.includes("bash") || r.includes("git")
+        );
+        expect(hasCapabilityMention).toBe(true);
+      }
+    });
+  });
+});