xab 2.0.0 → 4.0.0

package/dist/index.js

@@ -473,7 +473,14 @@ You are looking at a worktree based on the TARGET branch "${opts.targetBranch}".
    - "no" = missing
 4. If not fully present, describe a step-by-step strategy for applying cleanly
 5. List which top-level components/directories are affected
-6. Consider: does this change make sense for the target? Is it useful?`;
+6. Consider: does this change make sense for the target? Is it useful?
+7. Check if this commit requires any operator action beyond a normal code deploy:
+   - New environment variables added to .env / .env.example? \u2192 note which ones
+   - Database schema changes or migrations? \u2192 note what to run
+   - New services, containers, or infrastructure to deploy? \u2192 note what
+   - Config files that need manual updates on servers? \u2192 note which
+   - Dependencies on external services being added or removed? \u2192 note what
+   - If the commit is just normal code changes that only need a deploy+restart, leave opsNotes as []`;
   let turn;
   if (diffChunks.length > 1) {
     await thread.run(firstPrompt);
@@ -500,7 +507,8 @@ You now have the complete diff. Analyze and produce your structured response.`,
     alreadyInTarget: "no",
     reasoning: "Could not parse structured output",
     applicationStrategy: "Manual review recommended",
-    affectedComponents: []
+    affectedComponents: [],
+    opsNotes: []
   });
 }
 async function applyCommit(opts) {
@@ -642,9 +650,14 @@ var init_codex = __esm(() => {
         type: "array",
         items: { type: "string" },
         description: "Top-level directories/components affected (e.g. 'api', 'frontend', 'contracts')"
+      },
+      opsNotes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Operator action items ONLY if this commit requires something beyond a standard code deploy+restart. Examples: new env vars to add, database migrations to run, new services to deploy, infrastructure changes, config file updates on servers. Leave as empty array [] if no operator action is needed \u2014 a normal code deploy does NOT count."
       }
     },
-    required: ["summary", "alreadyInTarget", "reasoning", "applicationStrategy", "affectedComponents"],
+    required: ["summary", "alreadyInTarget", "reasoning", "applicationStrategy", "affectedComponents", "opsNotes"],
     additionalProperties: false
   };
   applyResultSchema = {
@@ -771,7 +784,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 = "";
@@ -1138,17 +1159,23 @@ 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;
   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`);
+    if (notAdded.length)
+      parts.push(`${notAdded.length} untracked`);
+    if (deleted.length)
+      parts.push(`${deleted.length} deleted`);
+    if (conflicted.length)
+      parts.push(`${conflicted.length} conflicted`);
     errors.push(`Working tree not clean: ${parts.join(", ")}`);
   }
   const conflictMarkers = [];
@@ -1179,7 +1206,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"]);
@@ -1260,7 +1287,8 @@ async function runEngine(opts, cb) {
       worktreePath: "",
       workBranch: "",
       auditDir: "",
-      commits: []
+      commits: [],
+      opsNotes: []
     };
   }
   cb.onStatus("Detecting already cherry-picked commits...");
@@ -1293,7 +1321,8 @@ async function runEngine(opts, cb) {
       worktreePath: "",
       workBranch: "",
       auditDir: "",
-      commits: commitsToProcess
+      commits: commitsToProcess,
+      opsNotes: []
     };
   }
   const repoName = repoPath.split("/").pop() ?? "repo";
@@ -1320,7 +1349,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(),
@@ -1394,13 +1423,26 @@ async function runEngine(opts, cb) {
     cb.onDecision(commit, decision);
   }
   audit.runEnd(summary, decisions);
+  const opsNotes = decisions.filter((d) => d.opsNotes && d.opsNotes.length > 0).map((d) => ({ commitHash: d.commitHash, commitMessage: d.commitMessage, notes: d.opsNotes }));
+  if (opsNotes.length > 0) {
+    cb.onLog("", "gray");
+    cb.onLog("\u2550\u2550\u2550 OPERATOR NOTES \u2550\u2550\u2550", "yellow");
+    for (const entry of opsNotes) {
+      cb.onLog(`  ${entry.commitHash.slice(0, 8)} ${entry.commitMessage}:`, "yellow");
+      for (const note of entry.notes) {
+        cb.onLog(`    \u2192 ${note}`, "yellow");
+      }
+    }
+    cb.onLog("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550", "yellow");
+  }
   return {
     summary,
     decisions,
     worktreePath: wtPath,
     workBranch: wbName,
     auditDir: audit.runDir,
-    commits: commitsToProcess
+    commits: commitsToProcess,
+    opsNotes
   };
 }
 async function processOneCommit(o) {
@@ -1452,12 +1494,12 @@ async function processOneCommit(o) {
     };
   }
   if (o.dryRun) {
-    const kind = analysis.alreadyInTarget === "partial" ? "would_apply" : "would_apply";
     return {
-      kind,
+      kind: "would_apply",
       commitHash: commit.hash,
       commitMessage: commit.message,
       reason: analysis.applicationStrategy.slice(0, 300),
+      opsNotes: analysis.opsNotes.length > 0 ? analysis.opsNotes : undefined,
       durationMs: Date.now() - start
     };
   }
@@ -1656,6 +1698,7 @@ async function processOneCommit(o) {
       newCommitHash: validation.newCommitHash ?? undefined,
       filesChanged: applyResult.filesChanged,
       reviewApproved: o.review ? true : undefined,
+      opsNotes: analysis.opsNotes.length > 0 ? analysis.opsNotes : undefined,
       durationMs: Date.now() - start
     };
     const invariantErrors = validateDecision(d, headBefore, headAfter, o.dryRun);
@@ -1707,51 +1750,225 @@ 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.slice(0, 120)}`);
+      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.kind === "failed" && decision.error) {
+        log(`  ${chalk.red(`  error: ${decision.error.slice(0, 150)}`)}`);
+      }
+      if (decision.filesChanged && decision.filesChanged.length > 0) {
+        const shown = decision.filesChanged.slice(0, 5).join(", ");
+        const extra = decision.filesChanged.length > 5 ? chalk.dim(` +${decision.filesChanged.length - 5} more`) : "";
+        log(`  ${chalk.dim(`  files: ${shown}`)}${extra}`);
+      }
     },
     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,
       branch: result.workBranch,
-      auditDir: result.auditDir
+      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
@@ -2433,6 +2650,42 @@ function App({ repoPath, engineOpts }) {
               }, undefined, true, undefined, this)
             ]
           }, undefined, true, undefined, this),
+          result.opsNotes.length > 0 && /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            borderStyle: "round",
+            borderColor: "yellow",
+            paddingX: 1,
+            marginTop: 1,
+            children: [
+              /* @__PURE__ */ jsxDEV(Text, {
+                bold: true,
+                color: "yellow",
+                children: "Operator Notes"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV(Newline, {}, undefined, false, undefined, this),
+              result.opsNotes.map((entry) => /* @__PURE__ */ jsxDEV(Box, {
+                flexDirection: "column",
+                children: [
+                  /* @__PURE__ */ jsxDEV(Text, {
+                    color: "yellow",
+                    children: [
+                      entry.commitHash.slice(0, 8),
+                      " ",
+                      entry.commitMessage
+                    ]
+                  }, undefined, true, undefined, this),
+                  entry.notes.map((note, i) => /* @__PURE__ */ jsxDEV(Text, {
+                    color: "yellow",
+                    children: [
+                      " ",
+                      "\u2192 ",
+                      note
+                    ]
+                  }, i, true, undefined, this))
+                ]
+              }, entry.commitHash, true, undefined, this))
+            ]
+          }, undefined, true, undefined, this),
           /* @__PURE__ */ jsxDEV(ActionBar, {
             actions: [{ key: "q", label: "Exit", color: "gray" }]
           }, undefined, false, undefined, this)
@@ -2482,6 +2735,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++) {
@@ -2490,7 +2744,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;
@@ -2628,7 +2885,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": "2.0.0",
+  "version": "4.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",