@mhingston5/lasso 0.1.0

package/src/spec/validate.ts

@@ -0,0 +1,296 @@
+import Ajv from "ajv";
+import { harnessSpecSchema } from "./schema.js";
+import type { HarnessSpec, TaskNode } from "./types.js";
+
+const ajv = new Ajv({ allErrors: true });
+const validateSchema = ajv.compile(harnessSpecSchema);
+
+export type ValidationResult =
+  | { valid: true }
+  | { valid: false; errors: string[] };
+
+export function validateHarnessSpec(spec: HarnessSpec): ValidationResult {
+  const errors: string[] = [];
+
+  // Step 1: Validate against JSON schema
+  const schemaValid = validateSchema(spec);
+  if (!schemaValid && validateSchema.errors) {
+    for (const err of validateSchema.errors) {
+      errors.push(`Schema error at ${err.instancePath || "root"}: ${err.message}`);
+    }
+  }
+
+  // Step 2: Structural validation
+  if (spec.graph) {
+    const nodeIds = new Set<string>();
+    const nodeKinds = new Map<string, string>();
+
+    // Check for duplicate node IDs and collect node metadata
+    for (const node of spec.graph.nodes) {
+      if (node.id) {
+        if (nodeIds.has(node.id)) {
+          errors.push(`Duplicate node ID: ${node.id}`);
+        }
+        nodeIds.add(node.id);
+        nodeKinds.set(node.id, node.kind);
+      }
+    }
+
+    // Validate entry node exists
+    if (spec.graph.entryNodeId && !nodeIds.has(spec.graph.entryNodeId)) {
+      errors.push(`Entry node not found: ${spec.graph.entryNodeId}`);
+    }
+
+    // Validate edge targets exist
+    for (const edge of spec.graph.edges) {
+      if (edge.from && !nodeIds.has(edge.from)) {
+        errors.push(`Edge references nonexistent source node: ${edge.from}`);
+      }
+      if (edge.to && !nodeIds.has(edge.to)) {
+        errors.push(`Edge references nonexistent target node: ${edge.to}`);
+      }
+    }
+
+    // Check for condition node references
+    for (const node of spec.graph.nodes) {
+      if (node.kind === "condition") {
+        const condNode = node as any;
+        if (condNode.thenNodeId) {
+          if (!nodeIds.has(condNode.thenNodeId)) {
+            errors.push(`Condition node ${node.id} references nonexistent thenNodeId: ${condNode.thenNodeId}`);
+          }
+        }
+        if (condNode.elseNodeId) {
+          if (!nodeIds.has(condNode.elseNodeId)) {
+            errors.push(`Condition node ${node.id} references nonexistent elseNodeId: ${condNode.elseNodeId}`);
+          }
+        }
+      }
+    }
+
+    // Check for merge node references
+    for (const node of spec.graph.nodes) {
+      if (node.kind === "merge") {
+        const mergeNode = node as any;
+        if (mergeNode.waitFor) {
+          // Issue 3: Validate waitFor is not empty
+          if (mergeNode.waitFor.length === 0) {
+            errors.push(`Merge node ${node.id} has empty waitFor array`);
+          }
+          for (const waitNodeId of mergeNode.waitFor) {
+            if (!nodeIds.has(waitNodeId)) {
+              errors.push(`Merge node ${node.id} references nonexistent waitFor node: ${waitNodeId}`);
+            }
+          }
+        }
+      }
+    }
+
+    // Issue 2: Validate choice interactions have options
+    for (const node of spec.graph.nodes) {
+      if (node.kind === "human") {
+        const humanNode = node as any;
+        if (humanNode.interactionType === "choice" && (!humanNode.options || humanNode.options.length === 0)) {
+          errors.push(`Human node ${node.id} has interactionType "choice" but missing or empty options`);
+        }
+      }
+    }
+
+    // Issue 1: Proper reachability validation using BFS from entryNodeId
+    const reachableNodes = new Set<string>();
+    const verificationNodes = new Set<string>();
+    
+    // Collect all nodes referenced by verification rules
+    for (const node of spec.graph.nodes) {
+      const nodeAny = node as any;
+      if (nodeAny.verificationPolicy?.rules) {
+        for (const rule of nodeAny.verificationPolicy.rules) {
+          if (rule.checkNodeId) {
+            verificationNodes.add(rule.checkNodeId);
+          }
+        }
+      }
+    }
+    
+    // For condition nodes used as verifiers, also mark their branches as verification nodes
+    // (they're not executed in the normal flow)
+    for (const node of spec.graph.nodes) {
+      if (node.kind === "condition" && verificationNodes.has(node.id)) {
+        const condNode = node as any;
+        if (condNode.thenNodeId) {
+          verificationNodes.add(condNode.thenNodeId);
+        }
+        if (condNode.elseNodeId) {
+          verificationNodes.add(condNode.elseNodeId);
+        }
+      }
+    }
+    
+    if (spec.graph.entryNodeId) {
+      const queue: string[] = [spec.graph.entryNodeId];
+      reachableNodes.add(spec.graph.entryNodeId);
+
+      // Build adjacency map for edges
+      const edgeMap = new Map<string, string[]>();
+      for (const edge of spec.graph.edges) {
+        if (edge.from && edge.to) {
+          if (!edgeMap.has(edge.from)) {
+            edgeMap.set(edge.from, []);
+          }
+          edgeMap.get(edge.from)!.push(edge.to);
+        }
+      }
+
+      // Build condition node map
+      const conditionMap = new Map<string, { thenNodeId: string; elseNodeId: string }>();
+      for (const node of spec.graph.nodes) {
+        if (node.kind === "condition") {
+          const condNode = node as any;
+          conditionMap.set(node.id, {
+            thenNodeId: condNode.thenNodeId,
+            elseNodeId: condNode.elseNodeId
+          });
+        }
+      }
+
+      // BFS traversal
+      while (queue.length > 0) {
+        const current = queue.shift()!;
+
+        // Follow regular edges
+        const targets = edgeMap.get(current) || [];
+        for (const target of targets) {
+          if (!reachableNodes.has(target)) {
+            reachableNodes.add(target);
+            queue.push(target);
+          }
+        }
+
+        // Follow condition branches (only if not used as verification node)
+        if (!verificationNodes.has(current)) {
+          const condBranches = conditionMap.get(current);
+          if (condBranches) {
+            if (condBranches.thenNodeId && !reachableNodes.has(condBranches.thenNodeId)) {
+              reachableNodes.add(condBranches.thenNodeId);
+              queue.push(condBranches.thenNodeId);
+            }
+            if (condBranches.elseNodeId && !reachableNodes.has(condBranches.elseNodeId)) {
+              reachableNodes.add(condBranches.elseNodeId);
+              queue.push(condBranches.elseNodeId);
+            }
+          }
+        }
+      }
+
+      // Check for unreachable nodes (excluding verification nodes)
+      for (const nodeId of nodeIds) {
+        if (!reachableNodes.has(nodeId) && !verificationNodes.has(nodeId)) {
+          errors.push(`Unreachable node: ${nodeId}`);
+        }
+      }
+    }
+
+    // Validate maxSteps is a positive integer
+    if (spec.executionPolicy?.maxSteps !== undefined) {
+      if (!Number.isInteger(spec.executionPolicy.maxSteps) || spec.executionPolicy.maxSteps < 1) {
+        errors.push("executionPolicy.maxSteps must be a positive integer");
+      }
+    }
+
+    // Validate costLimitUsd is a positive number
+    if (spec.executionPolicy?.costLimitUsd !== undefined) {
+      if (typeof spec.executionPolicy.costLimitUsd !== "number" || spec.executionPolicy.costLimitUsd <= 0) {
+        errors.push("executionPolicy.costLimitUsd must be a positive number");
+      }
+    }
+
+    // Validate retry policy is only on supported node kinds
+    const retryableKinds = new Set(["tool", "llm", "subworkflow"]);
+    for (const node of spec.graph.nodes) {
+      const nodeAny = node as any;
+      if (nodeAny.retryPolicy && !retryableKinds.has(node.kind)) {
+        errors.push(`retry policy not supported on node kind "${node.kind}" (node: ${node.id})`);
+      }
+    }
+
+    // Validate verification policy checkNodeId references and kind matching
+    for (const node of spec.graph.nodes) {
+      const nodeAny = node as any;
+      if (nodeAny.verificationPolicy?.rules) {
+        for (const rule of nodeAny.verificationPolicy.rules) {
+          if (rule.checkNodeId && !nodeIds.has(rule.checkNodeId)) {
+            errors.push(`Verification rule in node ${node.id} references nonexistent checkNodeId: ${rule.checkNodeId}`);
+          }
+          // Check for self-reference
+          if (rule.checkNodeId === node.id) {
+            errors.push(`Verification rule in node ${node.id} cannot reference itself`);
+          }
+          
+          // Validate verification rule kind matches verifier node kind
+          if (rule.kind && rule.checkNodeId && nodeIds.has(rule.checkNodeId)) {
+            const verifierKind = nodeKinds.get(rule.checkNodeId);
+            if (rule.kind === "tool" && verifierKind !== "tool") {
+              errors.push(`Verification rule in node ${node.id} has kind "tool" but references verifier ${rule.checkNodeId} of kind "${verifierKind}"`);
+            } else if (rule.kind === "llm" && verifierKind !== "llm") {
+              errors.push(`Verification rule in node ${node.id} has kind "llm" but references verifier ${rule.checkNodeId} of kind "${verifierKind}"`);
+            } else if (rule.kind === "expression" && verifierKind !== "condition") {
+              errors.push(`Verification rule in node ${node.id} has kind "expression" but references verifier ${rule.checkNodeId} of kind "${verifierKind}" (expected "condition")`);
+            }
+          }
+        }
+      }
+    }
+
+    // Check for circular verification dependencies using DFS cycle detection
+    const verificationGraph = new Map<string, Set<string>>();
+    for (const node of spec.graph.nodes) {
+      const nodeAny = node as any;
+      if (nodeAny.verificationPolicy?.rules) {
+        const deps = new Set<string>();
+        for (const rule of nodeAny.verificationPolicy.rules) {
+          if (rule.checkNodeId) {
+            deps.add(rule.checkNodeId);
+          }
+        }
+        verificationGraph.set(node.id, deps);
+      }
+    }
+
+    // Detect cycles of any length using DFS
+    const detectCycle = (start: string, visited: Set<string>, recStack: Set<string>, path: string[]): string[] | null => {
+      visited.add(start);
+      recStack.add(start);
+      path.push(start);
+
+      const deps = verificationGraph.get(start);
+      if (deps) {
+        for (const dep of deps) {
+          if (!visited.has(dep)) {
+            const cycle = detectCycle(dep, visited, recStack, [...path]);
+            if (cycle) return cycle;
+          } else if (recStack.has(dep)) {
+            // Found a cycle
+            const cycleStart = path.indexOf(dep);
+            return [...path.slice(cycleStart), dep];
+          }
+        }
+      }
+
+      recStack.delete(start);
+      return null;
+    };
+
+    const visited = new Set<string>();
+    for (const nodeId of verificationGraph.keys()) {
+      if (!visited.has(nodeId)) {
+        const cycle = detectCycle(nodeId, visited, new Set(), []);
+        if (cycle) {
+          errors.push(`Circular verification dependency detected: ${cycle.join(" -> ")}`);
+          break; // Report first cycle found
+        }
+      }
+    }
+  }
+
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}

package/src/state/snapshots.ts

@@ -0,0 +1,43 @@
+import type { FailureRecord } from "../failures/types.js";
+import type { HarnessState } from "./types.js";
+
+export function createHarnessState(input: unknown): HarnessState {
+  const inputs = input && typeof input === "object" && !Array.isArray(input)
+    ? structuredClone(input as Record<string, unknown>)
+    : {};
+  
+  return {
+    inputs,
+    outputs: {},
+    nodeResults: {},
+    failures: [],
+    metrics: {
+      retries: 0,
+      durationMs: 0,
+    },
+  };
+}
+
+export function addFailure(state: HarnessState, failure: FailureRecord): void {
+  state.failures.push(failure);
+}
+
+export function recordNodeResult(state: HarnessState, nodeId: string, result: unknown): void {
+  state.nodeResults[nodeId] = result;
+}
+
+export function updateMetrics(
+  state: HarnessState,
+  metrics: { retries?: number; durationMs?: number },
+): void {
+  if (metrics.retries !== undefined) {
+    state.metrics.retries = metrics.retries;
+  }
+  if (metrics.durationMs !== undefined) {
+    state.metrics.durationMs = metrics.durationMs;
+  }
+}
+
+export function captureSnapshot(state: HarnessState): HarnessState {
+  return structuredClone(state);
+}

package/src/state/types.ts

@@ -0,0 +1,12 @@
+import type { FailureRecord } from "../failures/types.js";
+
+export interface HarnessState {
+  inputs: Record<string, unknown>;
+  outputs: Record<string, unknown>;
+  nodeResults: Record<string, unknown>;
+  failures: FailureRecord[];
+  metrics: {
+    retries: number;
+    durationMs: number;
+  };
+}

package/src/synthesis/graph-builder.ts

@@ -0,0 +1,267 @@
+import type { IntentIR, IntentStep, SupportedWorkflowFamily } from "./intent-ir.js";
+import type { CapabilityRegistry } from "../capabilities/types.js";
+import type { EnvironmentModel } from "../environment/types.js";
+import { matchCapabilities } from "../capabilities/matcher.js";
+import { analyzeEnvironment } from "../environment/analyzer.js";
+
+export interface TaskGraph {
+  family: SupportedWorkflowFamily;
+  stages: WorkflowStage[];
+  inputs: Record<string, unknown>;
+  goal: string;
+  capabilityMatch?: {
+    matched: string[];
+    missing: string[];
+  };
+  environmentAnalysis?: {
+    missingTools: string[];
+    highRiskConstraints: string[];
+    readinessScore: number;
+    preparatorySteps: string[];
+  };
+}
+
+export interface WorkflowStage {
+  id: string;
+  type: "setup" | "reproduce" | "apply" | "verify" | "review" | "merge" | "approval";
+  dependencies: string[];
+  description: string;
+  requiredInputs: string[];
+}
+
+function stepKindToStageType(kind: IntentStep["kind"]): WorkflowStage["type"] {
+  switch (kind) {
+    case "tool":
+      return "setup";
+    case "llm":
+      return "review";
+    case "human":
+      return "approval";
+    case "condition":
+      return "verify";
+    default:
+      return "setup";
+  }
+}
+
+function buildCapabilityStages(intent: IntentIR, registry: CapabilityRegistry): { stages: WorkflowStage[]; matched: string[]; missing: string[] } {
+  const stages: WorkflowStage[] = [];
+  const requiredTools = intent.capabilities || intent.requiredTools;
+  const { matched, missing } = matchCapabilities(requiredTools, registry);
+
+  if (matched.length === 0) {
+    return { stages: [], matched: [], missing };
+  }
+
+  const setupStageId = "capability-setup";
+  stages.push({
+    id: setupStageId,
+    type: "setup",
+    dependencies: [],
+    description: `Verify required capabilities: ${matched.map(c => c.name).join(", ")}`,
+    requiredInputs: []
+  });
+
+  let prevStageId = setupStageId;
+
+  for (const cap of matched) {
+    if (cap.verification.length > 0) {
+      const verifyStageId = `capability-verify-${cap.id}`;
+      stages.push({
+        id: verifyStageId,
+        type: "verify",
+        dependencies: [prevStageId],
+        description: `Verify ${cap.name}: ${cap.verification.join("; ")}`,
+        requiredInputs: []
+      });
+      prevStageId = verifyStageId;
+    }
+
+    if (cap.risks.length > 0) {
+      const riskStageId = `capability-risk-${cap.id}`;
+      stages.push({
+        id: riskStageId,
+        type: "review",
+        dependencies: [prevStageId],
+        description: `Assess risks for ${cap.name}: ${cap.risks.join("; ")}`,
+        requiredInputs: []
+      });
+      prevStageId = riskStageId;
+    }
+
+    if (cap.kind === "human") {
+      stages.push({
+        id: `capability-approval-${cap.id}`,
+        type: "approval",
+        dependencies: [prevStageId],
+        description: `Human approval required: ${cap.name}`,
+        requiredInputs: []
+      });
+    }
+  }
+
+  return { stages, matched: matched.map(c => c.id), missing };
+}
+
+export function buildTaskGraph(
+  intent: IntentIR,
+  registry?: CapabilityRegistry,
+  environment?: EnvironmentModel
+): TaskGraph {
+  const stages: WorkflowStage[] = [];
+  let capabilityMatch: { matched: string[]; missing: string[] } | undefined;
+  let environmentAnalysis: TaskGraph["environmentAnalysis"];
+
+  if (environment) {
+    const analysis = analyzeEnvironment(environment);
+    const { matchedTools, missingTools, highRiskConstraints, readinessScore, preparatorySteps } = analysis;
+
+    environmentAnalysis = {
+      missingTools,
+      highRiskConstraints,
+      readinessScore,
+      preparatorySteps,
+    };
+
+    if (preparatorySteps.length > 0) {
+      stages.push({
+        id: "environment-prep",
+        type: "setup",
+        dependencies: [],
+        description: `Prepare environment: ${preparatorySteps.join("; ")}`,
+        requiredInputs: [],
+      });
+    }
+  }
+
+  const hasCapabilities = intent.capabilities && intent.capabilities.length > 0;
+  const useCapabilityPath = hasCapabilities && registry;
+
+  if (useCapabilityPath) {
+    const result = buildCapabilityStages(intent, registry);
+    stages.push(...result.stages);
+    capabilityMatch = { matched: result.matched, missing: result.missing };
+  }
+  
+  if (intent.family === "patch-validation" && !useCapabilityPath) {
+    stages.push({
+      id: "setup-baseline",
+      type: "setup",
+      dependencies: [],
+      description: "Check out baseline ref",
+      requiredInputs: ["repoPath", "baselineRef"]
+    });
+    
+    stages.push({
+      id: "reproduce-bug",
+      type: "reproduce",
+      dependencies: ["setup-baseline"],
+      description: "Reproduce the bug on baseline",
+      requiredInputs: ["reproduceCommands"]
+    });
+    
+    stages.push({
+      id: "apply-candidate",
+      type: "apply",
+      dependencies: ["reproduce-bug"],
+      description: "Apply candidate fix",
+      requiredInputs: ["candidateBranch", "patchFilePath"]  // One of these must be present
+    });
+    
+    stages.push({
+      id: "verify-fix",
+      type: "verify",
+      dependencies: ["apply-candidate"],
+      description: "Verify fix resolves issue and passes regression tests",
+      requiredInputs: ["reproduceCommands", "verificationCommands"]
+    });
+    
+    stages.push({
+      id: "review-results",
+      type: "review",
+      dependencies: ["verify-fix"],
+      description: "Review validation results",
+      requiredInputs: ["reviewInstructions"]
+    });
+    
+    if (intent.humanCheckpoints.includes("approval-gate")) {
+      stages.push({
+        id: "approval-gate",
+        type: "approval",
+        dependencies: ["review-results"],
+        description: "Human approval required",
+        requiredInputs: []
+      });
+    }
+  } else if (intent.family === "pr-review-merge" && !useCapabilityPath) {
+    stages.push({
+      id: "setup-pr",
+      type: "setup",
+      dependencies: [],
+      description: "Fetch and checkout PR branches",
+      requiredInputs: ["repoPath", "sourceBranch", "targetBranch"]
+    });
+    
+    stages.push({
+      id: "review-changes",
+      type: "review",
+      dependencies: ["setup-pr"],
+      description: "Review PR changes",
+      requiredInputs: ["reviewInstructions"]
+    });
+    
+    stages.push({
+      id: "verify-tests",
+      type: "verify",
+      dependencies: ["review-changes"],
+      description: "Run verification tests",
+      requiredInputs: ["verificationCommands"]
+    });
+    
+    stages.push({
+      id: "merge-pr",
+      type: "merge",
+      dependencies: ["verify-tests"],
+      description: "Merge PR",
+      requiredInputs: ["sourceBranch", "targetBranch"]
+    });
+  }
+  
+  if (intent.steps && intent.steps.length > 0) {
+    for (let i = 0; i < intent.steps.length; i++) {
+      const step = intent.steps[i];
+      const prevStepId = i > 0 ? intent.steps[i - 1].id : undefined;
+
+      stages.push({
+        id: step.id,
+        type: stepKindToStageType(step.kind),
+        dependencies: prevStepId ? [prevStepId] : [],
+        description: step.label,
+        requiredInputs: []
+      });
+    }
+
+    if (intent.verificationTargets.length > 0) {
+      const lastStepId = intent.steps[intent.steps.length - 1].id;
+
+      for (let i = 0; i < intent.verificationTargets.length; i++) {
+        stages.push({
+          id: `verify-target-${i}`,
+          type: "verify",
+          dependencies: [lastStepId],
+          description: `Verify: ${intent.verificationTargets[i]}`,
+          requiredInputs: []
+        });
+      }
+    }
+  }
+  
+  return {
+    family: intent.family,
+    stages,
+    inputs: intent.inputs,
+    goal: intent.goal,
+    capabilityMatch,
+    environmentAnalysis,
+  };
+}