@mhingston5/lasso 0.1.0

package/src/reference/pr-review-merge.ts

@@ -0,0 +1,155 @@
+import type { HarnessSpec } from "../spec/types.js";
+import {
+  buildHumanApprovedCondition,
+  buildLoadDiffTool,
+  buildMergeSucceededCondition,
+  buildMergeTool,
+  buildPostMergeCheckTool,
+  buildReviewPrompt,
+  buildVerificationPassedCondition,
+  buildVerificationTool,
+  buildVerifyPostMergeTool,
+  prReviewMergeNodeIds,
+} from "./strategies.js";
+import type { LocalPrBundle } from "./types.js";
+
+export function buildPrReviewMergeHarnessSpec(input: LocalPrBundle): HarnessSpec {
+  return {
+    name: "pr-review-merge",
+    executionPolicy: {
+      timeout: 180,
+    },
+    humanPolicy: {
+      defaultTimeout: 300,
+    },
+    observabilityPolicy: {
+      tracing: true,
+      logLevel: "info",
+    },
+    graph: {
+      entryNodeId: prReviewMergeNodeIds.loadPr,
+      nodes: [
+        {
+          id: prReviewMergeNodeIds.loadPr,
+          label: "Load PR context",
+          kind: "tool",
+          ...buildLoadDiffTool(input),
+        },
+        {
+          id: prReviewMergeNodeIds.reviewPr,
+          kind: "llm",
+          provider: "anthropic",
+          model: "claude-sonnet",
+          prompt: buildReviewPrompt(input),
+        },
+        {
+          id: prReviewMergeNodeIds.runVerification,
+          kind: "tool",
+          ...buildVerificationTool(input),
+        },
+        {
+          id: prReviewMergeNodeIds.mergeResults,
+          kind: "merge",
+          waitFor: [prReviewMergeNodeIds.reviewPr, prReviewMergeNodeIds.runVerification],
+        },
+        {
+          id: prReviewMergeNodeIds.gateMerge,
+          kind: "condition",
+          condition: buildVerificationPassedCondition(),
+          thenNodeId: prReviewMergeNodeIds.humanApprove,
+          elseNodeId: prReviewMergeNodeIds.rejectVerification,
+        },
+        {
+          id: prReviewMergeNodeIds.humanApprove,
+          kind: "human",
+          prompt: `Approve merge of ${input.sourceBranch} into ${input.targetBranch}?`,
+          interactionType: "approval",
+        },
+        {
+          id: prReviewMergeNodeIds.checkHumanApproval,
+          kind: "condition",
+          condition: buildHumanApprovedCondition(),
+          thenNodeId: prReviewMergeNodeIds.mergeBranch,
+          elseNodeId: prReviewMergeNodeIds.rejectHuman,
+        },
+        {
+          id: prReviewMergeNodeIds.mergeBranch,
+          kind: "tool",
+          ...buildMergeTool(input),
+        },
+        {
+          id: prReviewMergeNodeIds.checkMergeResult,
+          kind: "condition",
+          condition: buildMergeSucceededCondition(),
+          thenNodeId: prReviewMergeNodeIds.postMergeCheck,
+          elseNodeId: prReviewMergeNodeIds.mergeConflict,
+        },
+        {
+          id: prReviewMergeNodeIds.postMergeCheck,
+          kind: "tool",
+          ...buildPostMergeCheckTool(input),
+          retryPolicy: {
+            maxAttempts: 2,
+            backoff: "constant",
+            initialDelay: 0,
+            retryOn: ["transient"],
+          },
+          executionPolicy: {
+            failureClassification: [
+              {
+                pattern: "retryable post-merge failure",
+                category: "transient",
+                retry: true,
+              },
+            ],
+          },
+          verificationPolicy: {
+            rules: [
+              {
+                kind: "tool",
+                checkNodeId: prReviewMergeNodeIds.verifyPostMerge,
+                onFail: "block",
+              },
+            ],
+          },
+        },
+        {
+          id: prReviewMergeNodeIds.verifyPostMerge,
+          kind: "tool",
+          ...buildVerifyPostMergeTool(input),
+        },
+        {
+          id: prReviewMergeNodeIds.completeSuccess,
+          kind: "subworkflow",
+          specRef: prReviewMergeNodeIds.completeSuccess,
+        },
+        {
+          id: prReviewMergeNodeIds.rejectVerification,
+          kind: "subworkflow",
+          specRef: prReviewMergeNodeIds.rejectVerification,
+        },
+        {
+          id: prReviewMergeNodeIds.rejectHuman,
+          kind: "subworkflow",
+          specRef: prReviewMergeNodeIds.rejectHuman,
+        },
+        {
+          id: prReviewMergeNodeIds.mergeConflict,
+          kind: "subworkflow",
+          specRef: prReviewMergeNodeIds.mergeConflict,
+        },
+      ],
+      edges: [
+        { from: prReviewMergeNodeIds.loadPr, to: prReviewMergeNodeIds.reviewPr },
+        { from: prReviewMergeNodeIds.loadPr, to: prReviewMergeNodeIds.runVerification },
+        { from: prReviewMergeNodeIds.reviewPr, to: prReviewMergeNodeIds.mergeResults },
+        { from: prReviewMergeNodeIds.runVerification, to: prReviewMergeNodeIds.mergeResults },
+        { from: prReviewMergeNodeIds.mergeResults, to: prReviewMergeNodeIds.gateMerge },
+        { from: prReviewMergeNodeIds.humanApprove, to: prReviewMergeNodeIds.checkHumanApproval },
+        { from: prReviewMergeNodeIds.mergeBranch, to: prReviewMergeNodeIds.checkMergeResult },
+        { from: prReviewMergeNodeIds.postMergeCheck, to: prReviewMergeNodeIds.verifyPostMerge },
+        { from: prReviewMergeNodeIds.verifyPostMerge, to: prReviewMergeNodeIds.completeSuccess },
+      ],
+    },
+  };
+}

package/src/reference/strategies.ts

@@ -0,0 +1,126 @@
+import type { LocalPrBundle } from "./types.js";
+
+export const prReviewMergeNodeIds = {
+  loadPr: "load-pr",
+  reviewPr: "review-pr",
+  runVerification: "run-verification",
+  mergeResults: "merge-results",
+  gateMerge: "gate-merge",
+  humanApprove: "human-approve",
+  checkHumanApproval: "check-human-approval",
+  mergeBranch: "merge-branch",
+  checkMergeResult: "check-merge-result",
+  postMergeCheck: "post-merge-check",
+  verifyPostMerge: "verify-post-merge",
+  completeSuccess: "complete-success",
+  rejectVerification: "reject-verification",
+  rejectHuman: "reject-human",
+  mergeConflict: "merge-conflict",
+} as const;
+
+export function buildReviewPrompt(bundle: LocalPrBundle): string {
+  return [
+    "Review this local pull request and return JSON with a single boolean field `approved` and a short `summary`.",
+    `Repository: ${bundle.repoPath}`,
+    `Target branch: ${bundle.targetBranch}`,
+    `Source branch: ${bundle.sourceBranch}`,
+    `Instructions: ${bundle.reviewInstructions}`,
+  ].join("\n");
+}
+
+export function buildLoadDiffTool(bundle: LocalPrBundle) {
+  return buildBashTool(
+    [
+      `git checkout ${shellQuote(bundle.sourceBranch)} >/dev/null 2>&1`,
+      `git diff --stat ${shellQuote(`${bundle.targetBranch}...${bundle.sourceBranch}`)}`,
+    ].join("\n"),
+    bundle.repoPath,
+  );
+}
+
+export function buildVerificationTool(bundle: LocalPrBundle) {
+  const lines = [
+    `git checkout ${shellQuote(bundle.sourceBranch)} >/dev/null 2>&1`,
+    ...bundle.verificationCommands.flatMap(command => [
+      `if ! (${command}); then`,
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ passed: false, command }))}`,
+      "  exit 0",
+      "fi",
+    ]),
+    `printf '%s\\n' ${shellQuote(JSON.stringify({ passed: true }))}`,
+  ];
+
+  return buildBashTool(lines.join("\n"), bundle.repoPath);
+}
+
+export function buildMergeTool(bundle: LocalPrBundle) {
+  return buildBashTool(
+    [
+      `git checkout ${shellQuote(bundle.targetBranch)} >/dev/null 2>&1`,
+      `if git merge --no-ff --no-edit ${shellQuote(bundle.sourceBranch)} >/dev/null 2>&1; then`,
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ success: true, conflict: false }))}`,
+      "  exit 0",
+      "fi",
+      "if git status --porcelain | grep -Eq '^(AA|DD|UU|AU|UA|DU|UD) '; then",
+      "  git merge --abort >/dev/null 2>&1 || true",
+      `  printf '%s\\n' ${shellQuote(JSON.stringify({ success: false, conflict: true }))}`,
+      "  exit 0",
+      "fi",
+      `printf '%s\\n' ${shellQuote(JSON.stringify({ success: false, conflict: false }))}`,
+      "exit 1",
+    ].join("\n"),
+    bundle.repoPath,
+  );
+}
+
+export function buildPostMergeCheckTool(bundle: LocalPrBundle) {
+  return buildBashTool(
+    [
+      `git checkout ${shellQuote(bundle.targetBranch)} >/dev/null 2>&1`,
+      "if [ -f .lasso-post-merge-fail ]; then",
+      "  echo 'retryable post-merge failure' >&2",
+      "  exit 1",
+      "fi",
+      `printf '%s\\n' ${shellQuote(JSON.stringify({ passed: true }))}`,
+    ].join("\n"),
+    bundle.repoPath,
+  );
+}
+
+export function buildVerifyPostMergeTool(bundle: LocalPrBundle) {
+  return buildBashTool(
+    [
+      `git checkout ${shellQuote(bundle.targetBranch)} >/dev/null 2>&1`,
+      `printf '%s\\n' ${shellQuote(JSON.stringify({ passed: true }))}`,
+    ].join("\n"),
+    bundle.repoPath,
+  );
+}
+
+export function buildVerificationPassedCondition(): string {
+  return `${prReviewMergeNodeIds.mergeResults}.${prReviewMergeNodeIds.runVerification}.passed`;
+}
+
+export function buildHumanApprovedCondition(): string {
+  return `${prReviewMergeNodeIds.humanApprove}.approved`;
+}
+
+export function buildMergeSucceededCondition(): string {
+  return `${prReviewMergeNodeIds.mergeBranch}.success`;
+}
+
+function buildBashTool(script: string, cwd: string) {
+  return {
+    tool: "bash",
+    args: ["-lc", script],
+    cwd,
+  };
+}
+
+function shellQuote(value: string): string {
+  if (/^[A-Za-z0-9_./:=+-]+$/.test(value)) {
+    return value;
+  }
+
+  return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}

package/src/reference/types.ts

@@ -0,0 +1,33 @@
+export interface LocalPrBundle {
+  repoPath: string;
+  sourceBranch: string;
+  targetBranch: string;
+  reviewInstructions: string;
+  verificationCommands: string[];
+}
+
+export type LocalCandidateSource =
+  | { kind: "branch"; value: string }
+  | { kind: "patchFile"; value: string };
+
+export interface LocalPatchValidationBundle {
+  /** Absolute path to the local repository to validate against */
+  repoPath: string;
+  /**
+   * Git ref to check out as the baseline before applying the candidate.
+   * Precondition: this ref must resolve cleanly in the provided `repoPath`
+   * worktree. A checkout failure is treated as an unrecoverable setup error
+   * and is not routed to any terminal node — the workflow aborts immediately.
+   */
+  baselineRef: string;
+  /** The candidate fix to validate — a branch or a patch file */
+  candidateSource: LocalCandidateSource;
+  /** Commands that reproduce the bug; expected to fail on baseline, pass after fix */
+  reproduceCommands: string[];
+  /** Commands that must still pass after the fix is applied (regression guard) */
+  verificationCommands: string[];
+  /** Instructions for the LLM summary / human review prompt */
+  reviewInstructions: string;
+  /** When true, a human approval gate is inserted before the validated-fix terminal */
+  approvalRequired: boolean;
+}

package/src/replanner/risk-rules.ts

@@ -0,0 +1,161 @@
+import type { LocalPatchValidationBundle, LocalPrBundle } from "../reference/types.js";
+import type {
+  PatchValidationObservedOutcome,
+  PrReviewMergeObservedOutcome,
+  ReplanAbortReason,
+  RiskLevel,
+} from "./types.js";
+
+const HIGH_RISK_KEYWORDS = ["prod", "production", "hotfix", "security", "critical"];
+const MEDIUM_RISK_KEYWORDS = ["regression", "verification", "verify", "customer"];
+
+export interface RiskAssessment {
+  riskLevel: RiskLevel;
+  reasons: string[];
+  warnings: string[];
+}
+
+export function classifyPatchValidationRisk(
+  request: LocalPatchValidationBundle,
+  outcome: PatchValidationObservedOutcome,
+): RiskAssessment {
+  const notes = normalizeNotes(outcome.notes);
+  const highKeywords = collectMatchedKeywords(notes, HIGH_RISK_KEYWORDS);
+  const mediumKeywords = collectMatchedKeywords(notes, MEDIUM_RISK_KEYWORDS);
+  const reasons: string[] = [];
+  const warnings: string[] = [];
+  let riskLevel: RiskLevel = "low";
+
+  if (request.candidateSource.kind === "patchFile") {
+    riskLevel = "high";
+    reasons.push("Patch-file candidates are treated as high risk for adaptive replanning.");
+  }
+
+  if (highKeywords.length > 0) {
+    riskLevel = "high";
+    reasons.push(`Operator notes mention high-risk terms: ${highKeywords.join(", ")}.`);
+  } else if (mediumKeywords.length > 0 && riskLevel === "low") {
+    riskLevel = "medium";
+    reasons.push(`Operator notes mention elevated-risk terms: ${mediumKeywords.join(", ")}.`);
+  }
+
+  if (outcome.terminalNodeId === "rejected") {
+    riskLevel = "high";
+    reasons.push("The previous attempt was explicitly rejected by a human reviewer.");
+  } else if (
+    outcome.terminalNodeId === "not-reproduced"
+    || outcome.terminalNodeId === "apply-failed"
+    || outcome.terminalNodeId === "candidate-failed"
+  ) {
+    riskLevel = escalateRisk(riskLevel, "medium");
+    reasons.push(`The previous attempt ended at \`${outcome.terminalNodeId}\`.`);
+  }
+
+  if (outcome.aborted) {
+    riskLevel = escalateRisk(riskLevel, outcome.abortReason === "manual-stop" ? "high" : "medium");
+    reasons.push(`The previous attempt aborted due to ${describeAbortReason(outcome.abortReason)}.`);
+    if (outcome.abortReason === "unknown") {
+      warnings.push("Abort reason is unknown; operator notes may be needed before retrying safely.");
+    }
+  }
+
+  if (reasons.length === 0) {
+    reasons.push("No elevated risk signals were detected from the previous patch-validation attempt.");
+  }
+
+  return { riskLevel, reasons, warnings };
+}
+
+export function classifyPrReviewMergeRisk(
+  request: LocalPrBundle,
+  outcome: PrReviewMergeObservedOutcome,
+): RiskAssessment {
+  const notes = normalizeNotes(outcome.notes);
+  const highKeywords = collectMatchedKeywords(notes, HIGH_RISK_KEYWORDS);
+  const mediumKeywords = collectMatchedKeywords(notes, MEDIUM_RISK_KEYWORDS);
+  const reasons: string[] = [];
+  const warnings: string[] = [];
+  let riskLevel: RiskLevel = "low";
+
+  if (highKeywords.length > 0) {
+    riskLevel = "high";
+    reasons.push(`Operator notes mention high-risk terms: ${highKeywords.join(", ")}.`);
+  } else if (mediumKeywords.length > 0) {
+    riskLevel = "medium";
+    reasons.push(`Operator notes mention elevated-risk terms: ${mediumKeywords.join(", ")}.`);
+  }
+
+  if (outcome.terminalNodeId === "reject-human") {
+    riskLevel = "high";
+    reasons.push("The previous attempt was explicitly rejected by a human reviewer.");
+  } else if (
+    outcome.terminalNodeId === "reject-verification"
+    || outcome.terminalNodeId === "merge-conflict"
+  ) {
+    riskLevel = escalateRisk(riskLevel, "medium");
+    reasons.push(`The previous attempt ended at \`${outcome.terminalNodeId}\`.`);
+  } else if (outcome.terminalNodeId === "complete-success") {
+    reasons.push("The previous PR review + merge attempt completed successfully.");
+  }
+
+  if (outcome.aborted) {
+    riskLevel = escalateRisk(riskLevel, outcome.abortReason === "manual-stop" ? "high" : "medium");
+    reasons.push(`The previous attempt aborted due to ${describeAbortReason(outcome.abortReason)}.`);
+    if (outcome.abortReason === "retry-exhaustion") {
+      warnings.push("Retry exhaustion usually needs human diagnosis before another merge attempt.");
+    } else if (outcome.abortReason === "unknown") {
+      warnings.push("Abort reason is unknown; operator notes may be needed before retrying safely.");
+    }
+  }
+
+  if (reasons.length === 0) {
+    reasons.push(
+      `No elevated risk signals were detected for merging \`${request.sourceBranch}\` into \`${request.targetBranch}\`.`,
+    );
+  }
+
+  return { riskLevel, reasons, warnings };
+}
+
+export function normalizeNotes(notes?: string[]): string[] {
+  return (notes ?? []).map(note => note.trim()).filter(note => note.length > 0);
+}
+
+export function notesContainAny(notes: string[] | undefined, keywords: string[]): boolean {
+  const normalized = normalizeNotes(notes).map(note => note.toLowerCase());
+  return keywords.some(keyword => normalized.some(note => note.includes(keyword)));
+}
+
+export function describeAbortReason(reason: ReplanAbortReason | undefined): string {
+  switch (reason) {
+    case "setup-failure":
+      return "a setup failure";
+    case "retry-exhaustion":
+      return "retry exhaustion";
+    case "timeout":
+      return "a timeout";
+    case "manual-stop":
+      return "a manual stop";
+    case "unknown":
+    default:
+      return "an unknown abort";
+  }
+}
+
+function collectMatchedKeywords(notes: string[], keywords: string[]): string[] {
+  const loweredNotes = notes.map(note => note.toLowerCase());
+  const matches = new Set<string>();
+
+  for (const keyword of keywords) {
+    if (loweredNotes.some(note => note.includes(keyword))) {
+      matches.add(keyword);
+    }
+  }
+
+  return Array.from(matches);
+}
+
+function escalateRisk(current: RiskLevel, next: RiskLevel): RiskLevel {
+  const order: RiskLevel[] = ["low", "medium", "high"];
+  return order[Math.max(order.indexOf(current), order.indexOf(next))];
+}