xab 3.0.0 → 5.0.0

package/dist/index.js

@@ -531,11 +531,18 @@ ${opts.applicationStrategy}
 - If the target already has a different version of the same logic, merge both intents
 - Preserve the target's existing improvements \u2014 do not regress
 - Create or modify files as needed; delete files if the source commit deleted them
-- After applying, run exactly: git add -A && git commit -m "${commitMsg.replace(/"/g, "\\\"")}"
-- You MUST create exactly ONE commit. Not zero, not two.
 - No conflict markers, dead code, or TODO placeholders
 - If impossible to apply cleanly, explain why in notes
 
+## CRITICAL \u2014 you MUST commit your changes
+After making all file changes, you MUST run these two commands as your FINAL action:
+
+    git add -A
+    git commit -m "${commitMsg.replace(/"/g, "\\\"")}"
+
+If you do not run both commands, your work will be discarded. This is not optional.
+The validation system checks for exactly one new git commit. Zero commits = failure.
+
 Report what you did.`;
   const firstPrompt = `${MERGE_PREAMBLE}
 ${opts.repoContext ? `## Repository context
@@ -605,9 +612,16 @@ ${opts.reviewIssues.map((issue, i) => `${i + 1}. ${issue}`).join(`
 - Read the affected files to understand the current state
 - Fix every issue the reviewer raised
 - Do NOT introduce new problems while fixing
-- After fixing, amend the commit: git add -A && git commit --amend -m "${commitMsg.replace(/"/g, "\\\"")}"
 - The result must be a single clean commit with no issues
 
+## CRITICAL \u2014 you MUST amend the commit after fixing
+After making all fixes, you MUST run these two commands as your FINAL action:
+
+    git add -A
+    git commit --amend -m "${commitMsg.replace(/"/g, "\\\"")}"
+
+If you do not run both commands, your fixes will be discarded. This is not optional.
+
 Report what you fixed.`;
   const turn = await thread.run(prompt, { outputSchema: applyResultSchema });
   return parseJson(turn.finalResponse, {
@@ -784,7 +798,15 @@ You can:
 
 You MUST NOT modify the worktree in any way. No file writes, no git commits, no destructive commands.
 
-Run relevant tests if you can determine the test command from the repo. Your objections will be sent back to the apply agent for fixing, so be specific and actionable.`
+Testing guidelines:
+- Only run tests that work without API keys, secrets, or external service connections
+- Before running a test, check if it needs env vars by reading the test file or relevant .env.example
+- If a test needs keys, only run it if you can see a .env file with those vars already populated
+- Prefer: type-checks (tsc --noEmit), linters (eslint), unit tests, build checks (forge build, go build)
+- Avoid: integration tests hitting external APIs, tests requiring running databases/services
+- If you can't determine whether a test needs keys, skip it \u2014 don't run and fail
+
+Your objections will be sent back to the apply agent for fixing, so be specific and actionable.`
     }
   });
   let resultText = "";
@@ -1151,17 +1173,36 @@ async function validateApply(worktreeGit, beforeHash) {
     errors.push(`Failed to check commits: ${e.message}`);
   }
   const status = await worktreeGit.status();
-  const worktreeClean = status.modified.length === 0 && status.created.length === 0 && status.deleted.length === 0 && status.conflicted.length === 0 && status.not_added.length === 0;
+  const isOurs = (f) => f.startsWith(".backmerge/") || f.startsWith(".backmerge\\");
+  const modified = status.modified.filter((f) => !isOurs(f));
+  const created = status.created.filter((f) => !isOurs(f));
+  const deleted = status.deleted.filter((f) => !isOurs(f));
+  const notAdded = status.not_added.filter((f) => !isOurs(f));
+  const conflicted = status.conflicted.filter((f) => !isOurs(f));
+  const worktreeClean = modified.length === 0 && created.length === 0 && deleted.length === 0 && conflicted.length === 0 && notAdded.length === 0;
+  const dirtyFiles = [];
   if (!worktreeClean) {
     const parts = [];
-    if (status.modified.length)
-      parts.push(`${status.modified.length} modified`);
-    if (status.not_added.length)
-      parts.push(`${status.not_added.length} untracked`);
-    if (status.deleted.length)
-      parts.push(`${status.deleted.length} deleted`);
-    if (status.conflicted.length)
-      parts.push(`${status.conflicted.length} conflicted`);
+    if (modified.length) {
+      parts.push(`${modified.length} modified`);
+      for (const f of modified)
+        dirtyFiles.push(`M ${f}`);
+    }
+    if (notAdded.length) {
+      parts.push(`${notAdded.length} untracked`);
+      for (const f of notAdded)
+        dirtyFiles.push(`? ${f}`);
+    }
+    if (deleted.length) {
+      parts.push(`${deleted.length} deleted`);
+      for (const f of deleted)
+        dirtyFiles.push(`D ${f}`);
+    }
+    if (conflicted.length) {
+      parts.push(`${conflicted.length} conflicted`);
+      for (const f of conflicted)
+        dirtyFiles.push(`C ${f}`);
+    }
     errors.push(`Working tree not clean: ${parts.join(", ")}`);
   }
   const conflictMarkers = [];
@@ -1182,7 +1223,15 @@ async function validateApply(worktreeGit, beforeHash) {
   if (conflictMarkers.length > 0) {
     errors.push(`Conflict markers in: ${conflictMarkers.join(", ")}`);
   }
-  return { valid: errors.length === 0, newCommitHash, newCommitCount, worktreeClean, conflictMarkers, errors };
+  return {
+    valid: errors.length === 0,
+    newCommitHash,
+    newCommitCount,
+    worktreeClean,
+    conflictMarkers,
+    dirtyFiles,
+    errors
+  };
 }
 async function getAppliedDiff(worktreeGit, beforeHash) {
   return worktreeGit.raw(["diff", beforeHash, "HEAD"]);
@@ -1192,7 +1241,7 @@ async function getAppliedDiffStat(worktreeGit, beforeHash) {
 }
 async function resetHard(git, ref) {
   await git.raw(["reset", "--hard", ref]);
-  await git.raw(["clean", "-fd"]);
+  await git.raw(["clean", "-fd", "--exclude=.backmerge"]);
 }
 async function fetchOrigin(git) {
   await git.fetch(["--all", "--prune"]);
@@ -1335,7 +1384,7 @@ async function runEngine(opts, cb) {
   cb.onLog(`Eval worktree (detached): ${wtPath}`, "green");
   const wtGit = createGit(wtPath);
   const runId = `run-${ts}`;
-  const audit = new AuditLog(wtPath, runId);
+  const audit = new AuditLog(repoPath, runId);
   const runMeta = {
     runId,
     startedAt: new Date().toISOString(),
@@ -1538,6 +1587,11 @@ async function processOneCommit(o) {
     const validation = await validateApply(o.wtGit, headBefore);
     if (!validation.valid) {
       cb.onLog(`Validation failed: ${validation.errors.join("; ")}`, "red");
+      if (validation.dirtyFiles.length > 0) {
+        for (const f of validation.dirtyFiles) {
+          cb.onLog(`  ${f}`, "red");
+        }
+      }
       await resetHard(o.wtGit, headBefore);
       if (attempt === o.maxAttempts)
         return mkFailed(commit, "validation", validation.errors.join("; "), start);
@@ -1736,34 +1790,217 @@ var exports_batch = {};
 __export(exports_batch, {
   runBatch: () => runBatch
 });
-function emit(obj) {
+import chalk from "chalk";
+function shortHash2(h) {
+  return h.slice(0, 8);
+}
+function ts() {
+  return chalk.dim(new Date().toISOString().slice(11, 19));
+}
+function progressBar2(current, total, width = 25) {
+  const ratio = Math.min(current / total, 1);
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  return `${chalk.green("\u2588".repeat(filled))}${chalk.dim("\u2591".repeat(empty))} ${current}/${total}`;
+}
+function divider(char = "\u2500", width = 55) {
+  return chalk.dim(char.repeat(width));
+}
+function colorize(color, text) {
+  if (!color)
+    return text;
+  return (colorMap[color] ?? chalk.white)(text);
+}
+function decisionBadge(kind) {
+  switch (kind) {
+    case "applied":
+      return chalk.bgGreen.black.bold(" APPLIED ");
+    case "would_apply":
+      return chalk.bgCyan.black.bold(" WOULD APPLY ");
+    case "already_applied":
+      return chalk.bgBlue.white.bold(" ALREADY APPLIED ");
+    case "skip":
+      return chalk.bgYellow.black.bold(" SKIP ");
+    case "failed":
+      return chalk.bgRed.white.bold(" FAILED ");
+  }
+}
+function analysisBadge(status) {
+  switch (status) {
+    case "yes":
+      return chalk.green.bold("PRESENT");
+    case "no":
+      return chalk.red.bold("MISSING");
+    case "partial":
+      return chalk.yellow.bold("PARTIAL");
+  }
+}
+function log(msg) {
+  process.stderr.write(msg + `
+`);
+}
+function emitJsonl(obj) {
   process.stdout.write(JSON.stringify({ ...obj, ts: new Date().toISOString() }) + `
 `);
 }
 async function runBatch(opts) {
+  const jsonl = opts.jsonl ?? false;
+  const startTime = Date.now();
+  log("");
+  log(`  ${chalk.cyan.bold("xab")} ${chalk.dim("\u2014 curated branch reconciliation")}`);
+  log(`  ${chalk.magenta(opts.sourceRef)} ${chalk.dim("\u2192")} ${chalk.green(opts.targetRef)}`);
+  if (opts.workBranch)
+    log(`  ${chalk.dim("work branch:")} ${chalk.cyan(opts.workBranch)}`);
+  if (opts.dryRun)
+    log(`  ${chalk.yellow.bold("DRY RUN")}`);
+  log(`  ${divider()}`);
+  log("");
   const cb = {
     onLog(msg, color) {
-      emit({ event: "log", msg, color });
+      if (jsonl)
+        emitJsonl({ event: "log", msg, color });
+      if (!msg) {
+        log("");
+        return;
+      }
+      log(`  ${ts()} ${colorize(color, msg)}`);
     },
     onStatus(msg) {
-      emit({ event: "status", msg });
+      if (jsonl)
+        emitJsonl({ event: "status", msg });
+      log(`  ${ts()} ${chalk.dim("\u203A")} ${msg}`);
     },
     onCommitStart(commit, index, total) {
-      emit({ event: "commit_start", hash: commit.hash, message: commit.message, index, total });
+      if (jsonl)
+        emitJsonl({ event: "commit_start", hash: commit.hash, message: commit.message, index, total });
+      log("");
+      log(`  ${divider()}`);
+      log(`  ${progressBar2(index + 1, total)}  ${chalk.yellow(shortHash2(commit.hash))}`);
+      log(`  ${chalk.bold(commit.message)}`);
+      log(`  ${chalk.dim(`by ${commit.author} \xB7 ${commit.date}`)}`);
+      log("");
     },
     onAnalysis(commit, analysis) {
-      emit({ event: "analysis", hash: commit.hash, result: analysis });
+      if (jsonl)
+        emitJsonl({ event: "analysis", hash: commit.hash, result: analysis });
+      log(`  ${ts()} ${chalk.dim("analysis:")} ${analysisBadge(analysis.alreadyInTarget)}`);
+      log(`  ${chalk.dim("  summary:")} ${analysis.summary}`);
+      if (analysis.reasoning) {
+        log(`  ${chalk.dim("  reasoning:")} ${analysis.reasoning}`);
+      }
+      if (analysis.applicationStrategy && analysis.alreadyInTarget !== "yes") {
+        log(`  ${chalk.dim("  strategy:")} ${analysis.applicationStrategy}`);
+      }
+      if (analysis.affectedComponents.length > 0) {
+        log(`  ${chalk.dim("  components:")} ${analysis.affectedComponents.join(", ")}`);
+      }
+      if (analysis.opsNotes.length > 0) {
+        log(`  ${chalk.yellow("  ops:")} ${analysis.opsNotes.join("; ")}`);
+      }
     },
     onDecision(commit, decision) {
-      emit({ event: "decision", hash: commit.hash, kind: decision.kind, reason: decision.reason });
+      if (jsonl)
+        emitJsonl({
+          event: "decision",
+          hash: commit.hash,
+          kind: decision.kind,
+          reason: decision.reason,
+          opsNotes: decision.opsNotes
+        });
+      const duration = chalk.dim(`${(decision.durationMs / 1000).toFixed(1)}s`);
+      log(`  ${ts()} ${decisionBadge(decision.kind)} ${duration}`);
+      if (decision.newCommitHash) {
+        log(`  ${chalk.dim("  commit:")} ${decision.newCommitHash.slice(0, 8)}`);
+      }
+      if (decision.kind === "failed" && decision.error) {
+        log(`  ${chalk.red(`  error: ${decision.error}`)}`);
+      }
+      if (decision.reason && decision.kind !== "failed") {
+        log(`  ${chalk.dim("  reason:")} ${decision.reason}`);
+      }
+      if (decision.filesChanged && decision.filesChanged.length > 0) {
+        for (const f of decision.filesChanged) {
+          log(`  ${chalk.dim(`  \xB7 ${f}`)}`);
+        }
+      }
+      if (decision.opsNotes && decision.opsNotes.length > 0) {
+        for (const note of decision.opsNotes) {
+          log(`  ${chalk.yellow(`  ops: ${note}`)}`);
+        }
+      }
     },
     onReview(commit, review) {
-      emit({ event: "review", hash: commit.hash, approved: review.approved, issues: review.issues });
+      if (jsonl)
+        emitJsonl({ event: "review", hash: commit.hash, approved: review.approved, issues: review.issues });
+      const badge = review.approved ? chalk.bgGreen.black.bold(" REVIEW OK ") : chalk.bgRed.white.bold(" REVIEW REJECTED ");
+      log(`  ${ts()} ${badge} ${chalk.dim(`confidence: ${review.confidence}`)}`);
+      if (!review.approved && review.issues.length > 0) {
+        for (const issue of review.issues.slice(0, 3)) {
+          log(`  ${chalk.red(`  \xB7 ${issue.slice(0, 120)}`)}`);
+        }
+        if (review.issues.length > 3) {
+          log(`  ${chalk.dim(`  ...and ${review.issues.length - 3} more issues`)}`);
+        }
+      }
     }
   };
+  let result;
   try {
-    const result = await runEngine(opts, cb);
-    emit({
+    result = await runEngine(opts, cb);
+  } catch (e) {
+    if (jsonl)
+      emitJsonl({ event: "fatal", error: e.message });
+    log("");
+    log(`  ${chalk.bgRed.white.bold(" FATAL ")} ${e.message}`);
+    log("");
+    return 1;
+  }
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+  const { summary } = result;
+  log("");
+  log(`  ${divider("\u2550")}`);
+  log(`  ${chalk.bold("Run complete")} ${chalk.dim(`in ${elapsed}s`)}`);
+  log("");
+  const counters = [
+    summary.applied > 0 && `${chalk.green.bold(`${summary.applied}`)} applied`,
+    summary.wouldApply > 0 && `${chalk.cyan.bold(`${summary.wouldApply}`)} would apply`,
+    summary.alreadyApplied > 0 && `${chalk.blue.bold(`${summary.alreadyApplied}`)} already applied`,
+    summary.skipped > 0 && `${chalk.yellow.bold(`${summary.skipped}`)} skipped`,
+    summary.cherrySkipped > 0 && `${chalk.cyan(`${summary.cherrySkipped}`)} cherry-skipped`,
+    summary.failed > 0 && `${chalk.red.bold(`${summary.failed}`)} failed`
+  ].filter(Boolean);
+  log(`  ${counters.join(chalk.dim(" \xB7 "))}`);
+  if (result.worktreePath)
+    log(`  ${chalk.dim("worktree:")} ${result.worktreePath}`);
+  if (result.workBranch)
+    log(`  ${chalk.dim("branch:")}   ${result.workBranch}`);
+  if (result.auditDir)
+    log(`  ${chalk.dim("audit:")}    ${result.auditDir}`);
+  if (result.opsNotes.length > 0) {
+    log("");
+    log(`  ${chalk.yellow.bold("OPERATOR NOTES")}`);
+    log(`  ${chalk.yellow(divider("\u2500", 40))}`);
+    for (const entry of result.opsNotes) {
+      log(`  ${chalk.yellow(shortHash2(entry.commitHash))} ${entry.commitMessage}`);
+      for (const note of entry.notes) {
+        log(`    ${chalk.yellow("\u2192")} ${note}`);
+      }
+    }
+  }
+  const failed = result.decisions.filter((d) => d.kind === "failed");
+  if (failed.length > 0) {
+    log("");
+    log(`  ${chalk.red.bold("FAILED COMMITS")}`);
+    log(`  ${chalk.red(divider("\u2500", 40))}`);
+    for (const d of failed) {
+      log(`  ${chalk.red(shortHash2(d.commitHash))} ${d.commitMessage}`);
+      log(`    ${chalk.dim("phase:")} ${d.failedPhase ?? "?"} ${chalk.dim("error:")} ${d.error?.slice(0, 100) ?? "?"}`);
+    }
+  }
+  log(`  ${divider("\u2550")}`);
+  log("");
+  if (jsonl) {
+    emitJsonl({
       event: "done",
       summary: result.summary,
       worktree: result.worktreePath,
@@ -1771,17 +2008,24 @@ async function runBatch(opts) {
       auditDir: result.auditDir,
       opsNotes: result.opsNotes
     });
-    const { summary } = result;
-    if (summary.failed > 0)
-      return 2;
-    return 0;
-  } catch (e) {
-    emit({ event: "fatal", error: e.message });
-    return 1;
   }
+  if (summary.failed > 0)
+    return 2;
+  return 0;
 }
+var colorMap;
 var init_batch = __esm(() => {
   init_engine();
+  colorMap = {
+    red: chalk.red,
+    green: chalk.green,
+    yellow: chalk.yellow,
+    blue: chalk.blue,
+    magenta: chalk.magenta,
+    cyan: chalk.cyan,
+    gray: chalk.gray,
+    white: chalk.white
+  };
 });
 
 // index.ts
@@ -2548,6 +2792,7 @@ var startAfter = "";
 var limit = 0;
 var configPath = "";
 var batch = false;
+var jsonl = false;
 var resume = true;
 var showHelp = false;
 for (let i = 0;i < args.length; i++) {
@@ -2556,7 +2801,10 @@ for (let i = 0;i < args.length; i++) {
     showHelp = true;
   else if (arg === "--batch" || arg === "-b")
     batch = true;
-  else if (arg === "--dry-run")
+  else if (arg === "--jsonl") {
+    batch = true;
+    jsonl = true;
+  } else if (arg === "--dry-run")
     dryRun = true;
   else if (arg === "--list-only")
     listOnly = true;
@@ -2694,7 +2942,8 @@ if (batch || listOnly) {
     repoPath: resolvedPath,
     sourceRef,
     targetRef,
-    ...engineOpts
+    ...engineOpts,
+    jsonl
   });
   process.exit(exitCode);
 } else {

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "xab",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "description": "AI-powered curated branch reconciliation engine",
   "type": "module",
   "bin": {
     "xab": "dist/index.js"
   },
-  "private":false,
+  "private": false,
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "bun build index.ts --outdir dist --target bun --format esm --external @anthropic-ai/claude-agent-sdk --external @openai/codex-sdk --external simple-git --external ink --external ink-select-input --external ink-spinner --external ink-text-input --external react",
+    "build": "bun build index.ts --outdir dist --target bun --format esm --external @anthropic-ai/claude-agent-sdk --external @openai/codex-sdk --external simple-git --external ink --external ink-select-input --external ink-spinner --external ink-text-input --external react --external chalk",
     "prepublishOnly": "bun run build",
     "start": "bun run index.ts",
     "dev": "bun run --watch index.ts"
@@ -26,6 +26,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.85",
     "@openai/codex-sdk": "^0.117.0",
+    "chalk": "^5.6.2",
     "ink": "^5.2.1",
     "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",