@mhingston5/lasso 0.1.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@mhingston5/lasso",
+  "description": "Lasso is a local-first workflow compiler for pi-duroxide.",
+  "version": "0.1.0",
+  "author": "Mark Hingston",
+  "repository": "https://github.com/mhingston/lasso",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "pi-duroxide": "0.2.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/capabilities/matcher.ts

@@ -0,0 +1,25 @@
+import type { Capability, CapabilityRegistry } from "./types.js";
+
+export interface CapabilityMatchResult {
+  matched: Capability[];
+  missing: string[];
+}
+
+export function matchCapabilities(
+  requiredTools: string[],
+  registry: CapabilityRegistry
+): CapabilityMatchResult {
+  const matched: Capability[] = [];
+  const missing: string[] = [];
+
+  for (const toolId of requiredTools) {
+    const capability = registry.getCapability(toolId);
+    if (capability) {
+      matched.push(capability);
+    } else {
+      missing.push(toolId);
+    }
+  }
+
+  return { matched, missing };
+}

package/src/capabilities/registry.ts

@@ -0,0 +1,103 @@
+import type { Capability, CapabilityRegistry } from "./types.js";
+
+export class DefaultCapabilityRegistry implements CapabilityRegistry {
+  private capabilities = new Map<string, Capability>();
+
+  constructor() {
+    this.registerDefaults();
+  }
+
+  getCapabilities(): Capability[] {
+    return Array.from(this.capabilities.values());
+  }
+
+  hasCapability(id: string): boolean {
+    return this.capabilities.has(id);
+  }
+
+  getCapability(id: string): Capability | undefined {
+    return this.capabilities.get(id);
+  }
+
+  registerCapability(capability: Capability): void {
+    this.capabilities.set(capability.id, capability);
+  }
+
+  private registerDefaults(): void {
+    this.registerCapability({
+      id: "bash",
+      kind: "tool",
+      name: "Bash Shell",
+      prerequisites: [],
+      risks: [
+        "Executes arbitrary system commands",
+        "Can modify filesystem",
+        "May have elevated permissions"
+      ],
+      verification: [
+        "Verify command output",
+        "Check exit codes"
+      ]
+    });
+
+    this.registerCapability({
+      id: "git",
+      kind: "tool",
+      name: "Git Version Control",
+      prerequisites: ["bash"],
+      risks: [
+        "Modifies repository history",
+        "Can overwrite remote changes"
+      ],
+      verification: [
+        "Verify branch state",
+        "Check commit status"
+      ]
+    });
+
+    this.registerCapability({
+      id: "node",
+      kind: "tool",
+      name: "Node.js Runtime",
+      prerequisites: ["bash"],
+      risks: [
+        "Executes arbitrary JavaScript",
+        "Network access capability"
+      ],
+      verification: [
+        "Verify Node.js version",
+        "Check package installation"
+      ]
+    });
+
+    this.registerCapability({
+      id: "llm-review",
+      kind: "llm",
+      name: "LLM Code Review",
+      prerequisites: [],
+      risks: [
+        "May produce incorrect suggestions",
+        "Non-deterministic outputs"
+      ],
+      verification: [
+        "Verify review completeness",
+        "Check for hallucinated references"
+      ]
+    });
+
+    this.registerCapability({
+      id: "human-approval",
+      kind: "human",
+      name: "Human Approval Gate",
+      prerequisites: [],
+      risks: [
+        "Introduces workflow delay",
+        "Requires human availability"
+      ],
+      verification: [
+        "Confirm approval received",
+        "Verify approver identity"
+      ]
+    });
+  }
+}

package/src/capabilities/types.ts

@@ -0,0 +1,15 @@
+export interface Capability {
+  id: string;
+  kind: "tool" | "llm" | "service" | "human";
+  name: string;
+  prerequisites: string[];
+  risks: string[];
+  verification: string[];
+}
+
+export interface CapabilityRegistry {
+  getCapabilities(): Capability[];
+  hasCapability(id: string): boolean;
+  getCapability(id: string): Capability | undefined;
+  registerCapability(capability: Capability): void;
+}

package/src/cir/lower.ts

@@ -0,0 +1,253 @@
+import { validateHarnessSpec } from "../spec/validate.js";
+import type { ExecutionPolicy, HarnessSpec, TaskNode, VerificationRule } from "../spec/types.js";
+import type {
+  CirExecutionPolicy,
+  CirFailureRoutingHint,
+  CirGlobalPolicies,
+  CirNode,
+  CirTransition,
+  CirVerificationHook,
+  CirWorkflow,
+} from "./types.js";
+
+export function lowerHarnessSpecToCir(spec: HarnessSpec): CirWorkflow {
+  const validation = validateHarnessSpec(spec);
+  if (!validation.valid) {
+    throw new Error(`HarnessSpec validation failed:\n- ${validation.errors.join("\n- ")}`);
+  }
+
+  const conditionNodeIds = new Set(
+    spec.graph.nodes.filter((node): node is Extract<TaskNode, { kind: "condition" }> => node.kind === "condition").map(node => node.id),
+  );
+
+  for (const edge of spec.graph.edges) {
+    if (conditionNodeIds.has(edge.from)) {
+      throw new Error(`Condition node "${edge.from}" cannot declare outgoing graph edges; use thenNodeId/elseNodeId instead`);
+    }
+  }
+
+  const transitions = [
+    ...lowerGraphEdges(spec),
+    ...lowerConditionTransitions(spec),
+  ];
+
+  const nodes = spec.graph.nodes.map((node, index) => lowerNode(spec, node, index, transitions));
+  const globalPolicies = lowerGlobalPolicies(spec);
+
+  return {
+    name: spec.name,
+    entryNodeId: spec.graph.entryNodeId,
+    nodes,
+    transitions,
+    ...(globalPolicies ? { globalPolicies } : {}),
+  };
+}
+
+function lowerGraphEdges(spec: HarnessSpec): CirTransition[] {
+  return spec.graph.edges.map((edge, index) => ({
+    from: edge.from,
+    to: edge.to,
+    when: "success",
+    source: {
+      kind: "graph-edge",
+      specPath: `graph.edges[${index}]`,
+    },
+  }));
+}
+
+function lowerConditionTransitions(spec: HarnessSpec): CirTransition[] {
+  return spec.graph.nodes.flatMap((node, index) => {
+    if (node.kind !== "condition") {
+      return [];
+    }
+
+    return [
+      {
+        from: node.id,
+        to: node.thenNodeId,
+        when: "condition-true" as const,
+        source: {
+          kind: "condition-then" as const,
+          specNodeId: node.id,
+          specPath: `graph.nodes[${index}].thenNodeId`,
+        },
+      },
+      {
+        from: node.id,
+        to: node.elseNodeId,
+        when: "condition-false" as const,
+        source: {
+          kind: "condition-else" as const,
+          specNodeId: node.id,
+          specPath: `graph.nodes[${index}].elseNodeId`,
+        },
+      },
+    ];
+  });
+}
+
+function lowerNode(spec: HarnessSpec, node: TaskNode, index: number, transitions: CirTransition[]): CirNode {
+  const { execution, failureRouting } = resolveNodeExecution(spec.executionPolicy, node.executionPolicy);
+  const verification = lowerVerification(node.verificationPolicy?.rules);
+  const outgoingCount = transitions.filter(transition => transition.from === node.id).length;
+  const resolvedHumanTimeout = node.kind === "human" ? node.timeout ?? spec.humanPolicy?.defaultTimeout : undefined;
+  const baseNode = {
+    id: node.id,
+    kind: node.kind,
+    source: {
+      specNodeId: node.id,
+      specNodeKind: node.kind,
+      specPath: `graph.nodes[${index}]`,
+      ...(node.label ? { label: node.label } : {}),
+    },
+    ...(execution ? { execution } : {}),
+    ...(node.retryPolicy ? { retry: cloneRetryPolicy(node.retryPolicy) } : {}),
+    ...(verification ? { verification } : {}),
+    ...(failureRouting ? { failureRouting } : {}),
+    terminal: outgoingCount === 0,
+  } as const;
+
+  switch (node.kind) {
+    case "tool":
+      return {
+        ...baseNode,
+        kind: "tool",
+        action: {
+          tool: node.tool,
+          args: [...node.args],
+          ...(node.env ? { env: { ...node.env } } : {}),
+          ...(node.cwd ? { cwd: node.cwd } : {}),
+        },
+      };
+    case "llm":
+      return {
+        ...baseNode,
+        kind: "llm",
+        action: {
+          provider: node.provider,
+          model: node.model,
+          prompt: node.prompt,
+          ...(node.system ? { system: node.system } : {}),
+          ...(node.temperature !== undefined ? { temperature: node.temperature } : {}),
+          ...(node.maxTokens !== undefined ? { maxTokens: node.maxTokens } : {}),
+        },
+      };
+    case "human":
+      return {
+        ...baseNode,
+        kind: "human",
+        action: {
+          prompt: node.prompt,
+          interactionType: node.interactionType,
+          ...(node.options ? { options: [...node.options] } : {}),
+          ...(resolvedHumanTimeout !== undefined ? { timeout: resolvedHumanTimeout } : {}),
+        },
+      };
+    case "condition":
+      return {
+        ...baseNode,
+        kind: "condition",
+        action: {
+          conditionExpr: node.condition,
+        },
+      };
+    case "merge":
+      return {
+        ...baseNode,
+        kind: "merge",
+        action: {
+          join: {
+            waitFor: [...node.waitFor],
+            strategy: node.strategy ?? "all",
+          },
+        },
+      };
+    case "subworkflow":
+      return {
+        ...baseNode,
+        kind: "subworkflow",
+        action: {
+          specRef: node.specRef,
+          ...(node.inputs ? { inputs: structuredClone(node.inputs as Record<string, unknown>) } : {}),
+        },
+      };
+  }
+}
+
+function resolveNodeExecution(
+  globalExecutionPolicy: ExecutionPolicy | undefined,
+  nodeExecutionPolicy: ExecutionPolicy | undefined,
+): {
+  execution?: CirExecutionPolicy;
+  failureRouting?: CirFailureRoutingHint[];
+} {
+  if (!globalExecutionPolicy && !nodeExecutionPolicy) {
+    return {};
+  }
+
+  const mergedExecutionPolicy = {
+    ...(globalExecutionPolicy ?? {}),
+    ...(nodeExecutionPolicy ?? {}),
+  };
+  const { failureClassification, ...execution } = mergedExecutionPolicy;
+
+  return {
+    execution: Object.keys(execution).length > 0 ? execution : undefined,
+    failureRouting: failureClassification?.map(classification => ({ ...classification })),
+  };
+}
+
+function lowerVerification(rules: VerificationRule[] | undefined): CirVerificationHook[] | undefined {
+  if (!rules || rules.length === 0) {
+    return undefined;
+  }
+
+  return rules.map(rule => ({
+    kind: rule.kind,
+    checkNodeId: rule.checkNodeId,
+    onFail: rule.onFail,
+    ...(rule.maxAttempts !== undefined ? { maxAttempts: rule.maxAttempts } : {}),
+  }));
+}
+
+function cloneRetryPolicy(retryPolicy: TaskNode["retryPolicy"]): NonNullable<TaskNode["retryPolicy"]> {
+  return {
+    ...retryPolicy,
+    ...(retryPolicy.retryOn ? { retryOn: [...retryPolicy.retryOn] } : {}),
+  };
+}
+
+function lowerGlobalPolicies(spec: HarnessSpec): CirGlobalPolicies | undefined {
+  const globalPolicies: CirGlobalPolicies = {};
+
+  if (spec.executionPolicy) {
+    globalPolicies.execution = {
+      ...spec.executionPolicy,
+      ...(spec.executionPolicy.failureClassification
+        ? {
+            failureClassification: spec.executionPolicy.failureClassification.map(classification => ({ ...classification })),
+          }
+        : {}),
+    };
+  }
+
+  if (spec.humanPolicy) {
+    globalPolicies.human = {
+      ...spec.humanPolicy,
+      ...(spec.humanPolicy.notificationChannels
+        ? { notificationChannels: [...spec.humanPolicy.notificationChannels] }
+        : {}),
+    };
+  }
+
+  if (spec.observabilityPolicy) {
+    globalPolicies.observability = {
+      ...spec.observabilityPolicy,
+      ...(spec.observabilityPolicy.logDestinations
+        ? { logDestinations: [...spec.observabilityPolicy.logDestinations] }
+        : {}),
+    };
+  }
+
+  return Object.keys(globalPolicies).length > 0 ? globalPolicies : undefined;
+}

package/src/cir/optimize.ts

@@ -0,0 +1,251 @@
+import type { CirNode, CirTransition, CirWorkflow } from "./types.js";
+
+export function optimizeCirWorkflow(cir: CirWorkflow): { optimized: CirWorkflow; passes: string[] } {
+  const passes: string[] = [];
+
+  let current = structuredClone(cir);
+
+  const afterDeadNode = eliminateDeadNodes(current);
+  if (afterDeadNode.changed) {
+    passes.push("dead-node-elimination");
+    current = afterDeadNode.workflow;
+  }
+
+  const afterMergeElision = elideSingleBranchMerges(current);
+  if (afterMergeElision.changed) {
+    passes.push("single-branch-merge-elision");
+    current = afterMergeElision.workflow;
+  }
+
+  const afterFusion = fuseAdjacentToolNodes(current);
+  if (afterFusion.changed) {
+    passes.push("adjacent-tool-node-fusion");
+    current = afterFusion.workflow;
+  }
+
+  return { optimized: current, passes };
+}
+
+function eliminateDeadNodes(cir: CirWorkflow): { workflow: CirWorkflow; changed: boolean } {
+  const outgoingMap = new Map<string, CirTransition[]>();
+  for (const t of cir.transitions) {
+    const list = outgoingMap.get(t.from) ?? [];
+    list.push(t);
+    outgoingMap.set(t.from, list);
+  }
+
+  // Collect verification nodes (same logic as validate.ts)
+  const verificationNodes = new Set<string>();
+  for (const node of cir.nodes) {
+    if (node.verification) {
+      for (const hook of node.verification) {
+        verificationNodes.add(hook.checkNodeId);
+      }
+    }
+  }
+
+  const reachable = new Set<string>([cir.entryNodeId]);
+  const queue = [cir.entryNodeId];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    for (const t of outgoingMap.get(current) ?? []) {
+      if (!reachable.has(t.to)) {
+        reachable.add(t.to);
+        queue.push(t.to);
+      }
+    }
+  }
+
+  // Include verification hook targets and transitively reachable nodes
+  for (const id of verificationNodes) {
+    if (!reachable.has(id)) {
+      reachable.add(id);
+      queue.push(id);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    for (const t of outgoingMap.get(current) ?? []) {
+      if (!reachable.has(t.to)) {
+        reachable.add(t.to);
+        queue.push(t.to);
+      }
+    }
+  }
+
+  const filteredNodes = cir.nodes.filter(n => reachable.has(n.id));
+  const filteredTransitions = cir.transitions.filter(t => reachable.has(t.from) && reachable.has(t.to));
+
+  const changed = filteredNodes.length !== cir.nodes.length || filteredTransitions.length !== cir.transitions.length;
+
+  return {
+    workflow: { ...cir, nodes: filteredNodes, transitions: filteredTransitions },
+    changed,
+  };
+}
+
+function elideSingleBranchMerges(cir: CirWorkflow): { workflow: CirWorkflow; changed: boolean } {
+  const incomingMap = new Map<string, CirTransition[]>();
+  for (const t of cir.transitions) {
+    const list = incomingMap.get(t.to) ?? [];
+    list.push(t);
+    incomingMap.set(t.to, list);
+  }
+
+  const outgoingMap = new Map<string, CirTransition[]>();
+  for (const t of cir.transitions) {
+    const list = outgoingMap.get(t.from) ?? [];
+    list.push(t);
+    outgoingMap.set(t.from, list);
+  }
+
+  const mergesToElide = new Set<string>();
+
+  for (const node of cir.nodes) {
+    if (node.kind !== "merge") continue;
+    if (node.action.join.waitFor.length !== 1) continue;
+
+    const incoming = (incomingMap.get(node.id) ?? []).filter(t => t.when === "success");
+    if (incoming.length !== 1) continue;
+    if (incoming[0].from !== node.action.join.waitFor[0]) continue;
+
+    mergesToElide.add(node.id);
+  }
+
+  if (mergesToElide.size === 0) {
+    return { workflow: cir, changed: false };
+  }
+
+  const newNodes = cir.nodes.filter(n => !mergesToElide.has(n.id));
+  const newTransitions: CirTransition[] = [];
+
+  for (const t of cir.transitions) {
+    if (mergesToElide.has(t.from)) {
+      const mergeOutgoing = outgoingMap.get(t.from) ?? [];
+      const mergeIncoming = (incomingMap.get(t.from) ?? []).filter(inc => inc.when === "success");
+      for (const inc of mergeIncoming) {
+        for (const out of mergeOutgoing) {
+          newTransitions.push({
+            from: inc.from,
+            to: out.to,
+            when: out.when,
+            source: inc.source,
+          });
+        }
+      }
+      continue;
+    }
+
+    if (mergesToElide.has(t.to)) {
+      continue;
+    }
+
+    newTransitions.push(t);
+  }
+
+  return { workflow: { ...cir, nodes: newNodes, transitions: newTransitions }, changed: true };
+}
+
+function fuseAdjacentToolNodes(cir: CirWorkflow): { workflow: CirWorkflow; changed: boolean } {
+  const outgoingMap = new Map<string, CirTransition[]>();
+  for (const t of cir.transitions) {
+    const list = outgoingMap.get(t.from) ?? [];
+    list.push(t);
+    outgoingMap.set(t.from, list);
+  }
+
+  const incomingMap = new Map<string, CirTransition[]>();
+  for (const t of cir.transitions) {
+    const list = incomingMap.get(t.to) ?? [];
+    list.push(t);
+    incomingMap.set(t.to, list);
+  }
+
+  const nodeMap = new Map<string, CirNode>();
+  for (const n of cir.nodes) {
+    nodeMap.set(n.id, n);
+  }
+
+  const fusedAway = new Set<string>();
+  const redirects = new Map<string, string>();
+  let changed = false;
+
+  for (const node of cir.nodes) {
+    if (node.kind !== "tool") continue;
+    if (fusedAway.has(node.id)) continue;
+
+    const outgoing = (outgoingMap.get(node.id) ?? []).filter(t => t.when === "success");
+    if (outgoing.length !== 1) continue;
+
+    const nextNode = nodeMap.get(outgoing[0].to);
+    if (!nextNode || nextNode.kind !== "tool") continue;
+    if (fusedAway.has(nextNode.id)) continue;
+
+    if (node.action.tool !== nextNode.action.tool) continue;
+    if (node.action.tool !== "bash" && node.action.tool !== "sh") continue;
+    if (node.action.env !== nextNode.action.env) continue;
+    if (node.retry || nextNode.retry) continue;
+    if (node.verification || nextNode.verification) continue;
+
+    const mergedArgs = [node.action.args.join(" && ") + " && " + nextNode.action.args.join(" && ")];
+    const mergedNode: CirNode = {
+      ...node,
+      action: {
+        ...node.action,
+        args: mergedArgs,
+      },
+      retry: nextNode.retry,
+      verification: nextNode.verification,
+      failureRouting: nextNode.failureRouting,
+      terminal: nextNode.terminal,
+    };
+
+    nodeMap.set(node.id, mergedNode);
+    fusedAway.add(nextNode.id);
+    redirects.set(nextNode.id, node.id);
+    changed = true;
+  }
+
+  if (!changed) {
+    return { workflow: cir, changed: false };
+  }
+
+  const newNodes = cir.nodes
+    .filter(n => !fusedAway.has(n.id))
+    .map(n => {
+      const updated = nodeMap.get(n.id) ?? n;
+      if (updated.kind === "merge") {
+        const newWaitFor = updated.action.join.waitFor.map(id => redirects.get(id) ?? id);
+        if (newWaitFor.some((id, i) => id !== updated.action.join.waitFor[i])) {
+          return {
+            ...updated,
+            action: {
+              ...updated.action,
+              join: { ...updated.action.join, waitFor: newWaitFor },
+            },
+          } as CirNode;
+        }
+      }
+      return updated;
+    });
+
+  const newTransitions = cir.transitions
+    .filter(t => !fusedAway.has(t.from) && !fusedAway.has(t.to))
+    .map(t => ({
+      ...t,
+      from: redirects.get(t.from) ?? t.from,
+      to: redirects.get(t.to) ?? t.to,
+    }));
+
+  const dedupedTransitions: CirTransition[] = [];
+  const seenKeys = new Set<string>();
+  for (const t of newTransitions) {
+    const key = `${t.from}:${t.when}:${t.to}`;
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      dedupedTransitions.push(t);
+    }
+  }
+
+  return { workflow: { ...cir, nodes: newNodes, transitions: dedupedTransitions }, changed: true };
+}