@mhingston5/lasso 0.1.0

package/test/failures/recovery.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, it } from "vitest";
+import {
+  suggestRecovery,
+  type RecoveryPlan,
+  type FailureSignature,
+  type FailureContext,
+} from "../../src/failures/recovery.js";
+
+function makeSignature(
+  cls: FailureSignature["class"],
+  overrides?: Partial<FailureSignature>,
+): FailureSignature {
+  return {
+    class: cls,
+    confidence: 0.9,
+    evidence: ["test evidence"],
+    suggestedRecovery: [],
+    retryable: true,
+    requiresHumanIntervention: false,
+    ...overrides,
+  };
+}
+
+describe("Recovery plans", () => {
+  describe("suggestRecovery", () => {
+    describe("auth failure recovery", () => {
+      it("should generate recovery plan for auth failures", () => {
+        const signature = makeSignature("auth", {
+          retryable: false,
+          requiresHumanIntervention: true,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+
+      it("should include credential refresh step", () => {
+        const signature = makeSignature("auth", {
+          evidence: ["token expired"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/refresh|renew|credential|token|auth/i);
+      });
+
+      it("should have low estimated success rate for auth failures", () => {
+        const signature = makeSignature("auth", {
+          requiresHumanIntervention: true,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.estimatedSuccessRate).toBeLessThan(1);
+      });
+    });
+
+    describe("tool failure recovery", () => {
+      it("should generate recovery plan for tool failures", () => {
+        const signature = makeSignature("tool", {
+          retryable: false,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should include tool installation step for command not found", () => {
+        const signature = makeSignature("tool", {
+          evidence: ["command not found"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/install|availability|check/i);
+      });
+
+      it("should not require human approval for tool failures", () => {
+        const signature = makeSignature("tool");
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(false);
+      });
+    });
+
+    describe("resource failure recovery", () => {
+      it("should generate recovery plan for resource failures", () => {
+        const signature = makeSignature("resource", {
+          retryable: false,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should include cleanup step for disk full", () => {
+        const signature = makeSignature("resource", {
+          evidence: ["disk full"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/cleanup|free|space|disk/i);
+      });
+
+      it("should require human approval for OOM", () => {
+        const signature = makeSignature("resource", {
+          evidence: ["out of memory"],
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+    });
+
+    describe("semantic failure recovery", () => {
+      it("should generate recovery plan for semantic failures", () => {
+        const signature = makeSignature("semantic", {
+          retryable: false,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should include validation step", () => {
+        const signature = makeSignature("semantic", {
+          evidence: ["schema mismatch"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/validat|schema|output|format/i);
+      });
+
+      it("should require human approval for semantic failures", () => {
+        const signature = makeSignature("semantic");
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+    });
+
+    describe("human failure recovery", () => {
+      it("should generate recovery plan for human failures", () => {
+        const signature = makeSignature("human", {
+          requiresHumanIntervention: true,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+
+      it("should include escalation step for rejected", () => {
+        const signature = makeSignature("human", {
+          evidence: ["rejected"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/escalat|review|reconsider|human/i);
+      });
+    });
+
+    describe("environment-drift failure recovery", () => {
+      it("should generate recovery plan for environment-drift failures", () => {
+        const signature = makeSignature("environment-drift", {
+          retryable: false,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should include environment sync step", () => {
+        const signature = makeSignature("environment-drift", {
+          evidence: ["version mismatch"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/sync|install|update|dependenc|version/i);
+      });
+
+      it("should require human approval for environment-drift", () => {
+        const signature = makeSignature("environment-drift");
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+    });
+
+    describe("network failure recovery", () => {
+      it("should generate recovery plan for network failures", () => {
+        const signature = makeSignature("network", {
+          retryable: true,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should include retry with backoff step", () => {
+        const signature = makeSignature("network", {
+          evidence: ["timeout"],
+        });
+        const plan = suggestRecovery(signature);
+        const stepText = plan.steps.map(s => s.action).join(" ").toLowerCase();
+        expect(stepText).toMatch(/retry|backoff|wait/i);
+      });
+
+      it("should not require human approval for retryable network failures", () => {
+        const signature = makeSignature("network", {
+          retryable: true,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(false);
+      });
+    });
+
+    describe("unknown failure recovery", () => {
+      it("should generate recovery plan for unknown failures", () => {
+        const signature = makeSignature("unknown");
+        const plan = suggestRecovery(signature);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should require human approval for unknown failures", () => {
+        const signature = makeSignature("unknown");
+        const plan = suggestRecovery(signature);
+        expect(plan.requiresHumanApproval).toBe(true);
+      });
+
+      it("should have low estimated success rate", () => {
+        const signature = makeSignature("unknown", {
+          confidence: 0.1,
+        });
+        const plan = suggestRecovery(signature);
+        expect(plan.estimatedSuccessRate).toBeLessThan(0.5);
+      });
+    });
+
+    describe("with context", () => {
+      it("should incorporate context into recovery steps", () => {
+        const signature = makeSignature("network", {
+          evidence: ["timeout"],
+        });
+        const ctx: FailureContext = { nodeId: "api-call" };
+        const plan = suggestRecovery(signature, ctx);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+
+      it("should adjust recovery based on attempt number", () => {
+        const signature = makeSignature("network", {
+          retryable: true,
+        });
+        const ctx: FailureContext = { attemptNumber: 5 };
+        const plan = suggestRecovery(signature, ctx);
+        expect(plan.steps.length).toBeGreaterThan(0);
+      });
+    });
+
+    describe("recovery step structure", () => {
+      it("should have description for each step", () => {
+        const signature = makeSignature("tool");
+        const plan = suggestRecovery(signature);
+        plan.steps.forEach(step => {
+          expect(step.description).toBeDefined();
+          expect(typeof step.description).toBe("string");
+        });
+      });
+
+      it("should have action for each step", () => {
+        const signature = makeSignature("auth");
+        const plan = suggestRecovery(signature);
+        plan.steps.forEach(step => {
+          expect(step.action).toBeDefined();
+          expect(typeof step.action).toBe("string");
+        });
+      });
+    });
+
+    describe("estimated success rate", () => {
+      it("should be between 0 and 1", () => {
+        const classes: FailureSignature["class"][] = [
+          "auth",
+          "tool",
+          "resource",
+          "semantic",
+          "human",
+          "environment-drift",
+          "network",
+          "unknown",
+        ];
+
+        classes.forEach(cls => {
+          const signature = makeSignature(cls);
+          const plan = suggestRecovery(signature);
+          expect(plan.estimatedSuccessRate).toBeGreaterThanOrEqual(0);
+          expect(plan.estimatedSuccessRate).toBeLessThanOrEqual(1);
+        });
+      });
+
+      it("should be higher for retryable failures", () => {
+        const retryableSig = makeSignature("network", { retryable: true });
+        const nonRetryableSig = makeSignature("semantic", { retryable: false });
+
+        const retryablePlan = suggestRecovery(retryableSig);
+        const nonRetryablePlan = suggestRecovery(nonRetryableSig);
+
+        expect(retryablePlan.estimatedSuccessRate).toBeGreaterThan(
+          nonRetryablePlan.estimatedSuccessRate,
+        );
+      });
+    });
+  });
+});

package/test/helpers/createFixtureRepo.ts

@@ -0,0 +1,84 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LocalPrBundle } from "../../src/reference/types.js";
+
+export interface FixtureRepoOptions {
+  reviewInstructions?: string;
+  verificationCommands?: string[];
+  createMergeConflict?: boolean;
+  mergeConflictMode?: "both_modified" | "both_added";
+  createPostMergeFailureMarker?: boolean;
+}
+
+export interface FixtureRepo {
+  bundle: LocalPrBundle;
+  cleanup: () => void;
+}
+
+export function createFixtureRepo(options: FixtureRepoOptions = {}): FixtureRepo {
+  const repoPath = mkdtempSync(join(tmpdir(), "lasso-pr-"));
+  const targetBranch = "main";
+  const sourceBranch = "feature/pr-change";
+
+  runGit(repoPath, ["init", "-q"]);
+  runGit(repoPath, ["checkout", "-b", targetBranch]);
+  runGit(repoPath, ["config", "user.name", "Lasso Test"]);
+  runGit(repoPath, ["config", "user.email", "lasso@example.com"]);
+
+  writeFileSync(join(repoPath, "app.txt"), "base\n");
+  runGit(repoPath, ["add", "app.txt"]);
+  runGit(repoPath, ["commit", "-qm", "Initial commit"]);
+
+  runGit(repoPath, ["checkout", "-b", sourceBranch]);
+  if (options.createMergeConflict && options.mergeConflictMode === "both_added") {
+    writeFileSync(join(repoPath, "conflict.txt"), "feature branch version\n");
+  } else {
+    writeFileSync(join(repoPath, "app.txt"), options.createMergeConflict ? "feature branch change\n" : "base\nfeature change\n");
+  }
+
+  if (options.createPostMergeFailureMarker) {
+    writeFileSync(join(repoPath, ".lasso-post-merge-fail"), "retry\n");
+  }
+
+  const filesToAdd = [
+    ...(options.createMergeConflict && options.mergeConflictMode === "both_added" ? ["conflict.txt"] : ["app.txt"]),
+    ...(options.createPostMergeFailureMarker ? [".lasso-post-merge-fail"] : []),
+  ];
+  runGit(repoPath, ["add", ...filesToAdd]);
+  runGit(repoPath, ["commit", "-qm", "Feature change"]);
+
+  if (options.createMergeConflict) {
+    runGit(repoPath, ["checkout", targetBranch]);
+    if (options.mergeConflictMode === "both_added") {
+      writeFileSync(join(repoPath, "conflict.txt"), "main branch version\n");
+      runGit(repoPath, ["add", "conflict.txt"]);
+    } else {
+      writeFileSync(join(repoPath, "app.txt"), "main branch change\n");
+      runGit(repoPath, ["add", "app.txt"]);
+    }
+    runGit(repoPath, ["commit", "-qm", "Conflicting change on main"]);
+    runGit(repoPath, ["checkout", sourceBranch]);
+  }
+
+  return {
+    bundle: {
+      repoPath,
+      sourceBranch,
+      targetBranch,
+      reviewInstructions: options.reviewInstructions ?? "Approve only if verification passes and the diff looks safe.",
+      verificationCommands: options.verificationCommands ?? ['node -e "process.exit(0)"'],
+    },
+    cleanup: () => {
+      rmSync(repoPath, { recursive: true, force: true });
+    },
+  };
+}
+
+function runGit(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+  }).trim();
+}

package/test/helpers/createPatchValidationFixture.ts

@@ -0,0 +1,144 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LocalPatchValidationBundle } from "../../src/reference/types.js";
+
+export interface PatchValidationFixtureOptions {
+  reviewInstructions?: string;
+  /**
+   * When true, add a human approval gate to the bundle and spec.
+   * Defaults to false.
+   */
+  approvalRequired?: boolean;
+  /**
+   * The baseline reproduce command already passes (exits 0), meaning the bug is
+   * not present. Routes the workflow to the `not-reproduced` terminal.
+   */
+  baselineAlwaysPasses?: boolean;
+  /**
+   * Produces a branch or patch-file candidate that cannot be applied cleanly.
+   * Routes to the `apply-failed` terminal.
+   * When combined with `candidateKind: "patchFile"` the patch file is malformed;
+   * when combined with `candidateKind: "branch"` the branch simply does not exist.
+   */
+  applyFailure?: boolean;
+  /**
+   * The fix is applied successfully but the reproduce command still fails after
+   * the candidate is applied. Routes to the `candidate-failed` terminal.
+   */
+  fixDoesNotFixBug?: boolean;
+  /**
+   * The fix resolves the reproduce command but the broader verification commands
+   * fail after the candidate is applied. Routes to the `candidate-failed` terminal.
+   */
+  verificationFailure?: boolean;
+  /**
+   * Which candidate source kind the bundle should expose.
+   * Defaults to "branch".
+   */
+  candidateKind?: "branch" | "patchFile";
+}
+
+export interface PatchValidationFixture {
+  bundle: LocalPatchValidationBundle;
+  /** Absolute path to the generated patch file (only populated for patchFile fixtures). */
+  patchFilePath: string;
+  cleanup: () => void;
+}
+
+const BASELINE_REF = "main";
+const FIX_BRANCH = "fix/bug";
+
+export function createPatchValidationFixture(options: PatchValidationFixtureOptions = {}): PatchValidationFixture {
+  const repoPath = mkdtempSync(join(tmpdir(), "lasso-pv-"));
+  const candidateKind = options.candidateKind ?? "branch";
+
+  runGit(repoPath, ["init", "-q"]);
+  runGit(repoPath, ["checkout", "-b", BASELINE_REF]);
+  runGit(repoPath, ["config", "user.name", "Lasso Test"]);
+  runGit(repoPath, ["config", "user.email", "lasso@example.com"]);
+
+  // reproduce.sh: exits 1 on baseline (bug present) unless baselineAlwaysPasses
+  const baselineReproduceContent = options.baselineAlwaysPasses ? "exit 0\n" : "exit 1\n";
+  writeFileSync(join(repoPath, "reproduce.sh"), baselineReproduceContent);
+  // verify.sh: always passes on baseline
+  writeFileSync(join(repoPath, "verify.sh"), "exit 0\n");
+  runGit(repoPath, ["add", "reproduce.sh", "verify.sh"]);
+  runGit(repoPath, ["commit", "-qm", "Initial commit with known bug"]);
+
+  let patchFilePath: string;
+
+  if (options.baselineAlwaysPasses) {
+    // Workflow routes to not-reproduced before attempting to apply the candidate,
+    // so the candidate source is never exercised. Use a dummy patch path.
+    patchFilePath = join(repoPath, "unused.patch");
+    writeFileSync(patchFilePath, "");
+  } else if (options.applyFailure) {
+    // Do not create a real fix branch. For the patchFile case write a malformed patch.
+    patchFilePath = join(repoPath, "bad.patch");
+    writeFileSync(patchFilePath, "this is not a valid patch\n");
+  } else {
+    runGit(repoPath, ["checkout", "-b", FIX_BRANCH]);
+
+    if (options.fixDoesNotFixBug) {
+      // Cosmetic change only — bug still present after applying
+      writeFileSync(join(repoPath, "reproduce.sh"), "# attempted fix\nexit 1\n");
+      runGit(repoPath, ["add", "reproduce.sh"]);
+    } else if (options.verificationFailure) {
+      // Bug is fixed but verification breaks
+      writeFileSync(join(repoPath, "reproduce.sh"), "exit 0\n");
+      writeFileSync(join(repoPath, "verify.sh"), "exit 1\n");
+      runGit(repoPath, ["add", "reproduce.sh", "verify.sh"]);
+    } else {
+      // Clean fix
+      writeFileSync(join(repoPath, "reproduce.sh"), "exit 0\n");
+      runGit(repoPath, ["add", "reproduce.sh"]);
+    }
+
+    runGit(repoPath, ["commit", "-qm", "Fix: resolve the bug"]);
+
+    // Generate a patch file from the baseline to the fix branch.
+    // NOTE: Do NOT trim the output — git apply requires the trailing newline.
+    const patchContent = execFileSync("git", ["diff", `${BASELINE_REF}..${FIX_BRANCH}`], {
+      cwd: repoPath,
+      encoding: "utf8",
+    });
+    patchFilePath = join(repoPath, "fix.patch");
+    writeFileSync(patchFilePath, patchContent);
+
+    // Return to baseline so the workflow starts clean
+    runGit(repoPath, ["checkout", BASELINE_REF]);
+  }
+
+  const candidateSource =
+    candidateKind === "patchFile"
+      ? ({ kind: "patchFile", value: patchFilePath } as const)
+      : options.applyFailure
+        ? ({ kind: "branch", value: "nonexistent-branch" } as const)
+        : ({ kind: "branch", value: FIX_BRANCH } as const);
+
+  const bundle: LocalPatchValidationBundle = {
+    repoPath,
+    baselineRef: BASELINE_REF,
+    candidateSource,
+    reproduceCommands: ["bash reproduce.sh"],
+    verificationCommands: ["bash verify.sh"],
+    reviewInstructions:
+      options.reviewInstructions ?? "Approve only if the fix is clean and regression-free.",
+    approvalRequired: options.approvalRequired ?? false,
+  };
+
+  return {
+    bundle,
+    patchFilePath,
+    cleanup: () => rmSync(repoPath, { recursive: true, force: true }),
+  };
+}
+
+function runGit(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+  }).trim();
+}