xab 11.0.0 → 13.0.0

package/dist/index.js

@@ -201,7 +201,7 @@ function buildRepoContext(repoPath, config) {
   const docPaths = discoverDocPaths(repoPath);
   return { structure, instructions, docPaths };
 }
-function buildCommitContext(repoPath, repoCtx, config, touchedPaths, commitMessage) {
+function buildCommitContext(repoPath, repoCtx, config, touchedPaths, commitMessage, memoryBlock) {
   const includedFiles = [];
   const sections = [];
   const rs = repoCtx.structure;
@@ -214,6 +214,9 @@ function buildCommitContext(repoPath, repoCtx, config, touchedPaths, commitMessa
     structLines.push(`Packages: ${rs.packages.join(", ")}`);
   sections.push(structLines.join(`
 `));
+  if (memoryBlock) {
+    sections.push(memoryBlock);
+  }
   for (const [name, content] of repoCtx.instructions) {
     sections.push(`--- ${name} ---
 ${content}`);
@@ -476,7 +479,7 @@ async function runStreamedWithProgress(thread, prompt, onProgress, turnOpts) {
               const lines = output.split(`
 `).filter(Boolean);
               for (const line of lines.slice(-3)) {
-                onProgress("exec", `  ${line.slice(0, 120)}`);
+                onProgress("output", `  ${line.slice(0, 120)}`);
               }
             }
           }
@@ -511,8 +514,10 @@ async function runStreamedWithProgress(thread, prompt, onProgress, turnOpts) {
           if (text) {
             const lines = text.split(`
 `).filter(Boolean);
-            for (const line of lines.slice(0, 3)) {
-              onProgress("think", line.slice(0, 150));
+            if (lines[0])
+              onProgress("think", lines[0].slice(0, 150));
+            for (const line of lines.slice(1, 3)) {
+              onProgress("output", `  ${line.slice(0, 150)}`);
             }
           }
           break;
@@ -583,7 +588,18 @@ You are looking at a worktree based on the TARGET branch "${opts.targetBranch}".
    - 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 []`;
+   - If the commit is just normal code changes that only need a deploy+restart, leave opsNotes as []
+8. Record any non-obvious discoveries that would help analyze FUTURE commits:
+   - Path mappings between source and target branches (e.g. "frontend/ in source = apps/frontend/ in target")
+   - Key functions, helpers, or patterns you found (e.g. "betExitValueLocal() is the shared P&L helper")
+   - Architectural facts (e.g. "store exports are at the bottom of fastMarkets.ts")
+   - Only include genuinely useful, non-obvious facts. Do NOT repeat things already in the merge memory or repo docs.
+   - Leave discoveries as [] if nothing new and non-obvious was found.
+9. If merge memory entries were provided in the context above, evaluate each one:
+   - List the KEYS of entries you want to KEEP in keepMemoryKeys
+   - Drop entries that are stale, obvious from repo docs, or no longer relevant
+   - Keep entries that saved you time or would save time on similar future commits
+   - If no memory was provided, return keepMemoryKeys as []`;
   let response;
   if (diffChunks.length > 1) {
     await thread.run(firstPrompt);
@@ -611,7 +627,9 @@ You now have the complete diff. Analyze and produce your structured response.`,
     reasoning: "Could not parse structured output",
     applicationStrategy: "Manual review recommended",
     affectedComponents: [],
-    opsNotes: []
+    opsNotes: [],
+    discoveries: [],
+    keepMemoryKeys: []
   });
 }
 async function applyCommit(opts) {
@@ -776,9 +794,43 @@ var init_codex = __esm(() => {
         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."
+      },
+      discoveries: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["path_mapping", "pattern", "codebase", "architecture", "convention", "warning"],
+              description: "Category of discovery"
+            },
+            key: {
+              type: "string",
+              description: "Short unique key for dedup (e.g. 'frontend_path_prefix', 'pnl_shared_helpers')"
+            },
+            value: { type: "string", description: "The reusable fact (1-2 sentences max)" }
+          },
+          required: ["type", "key", "value"]
+        },
+        description: "Reusable learnings that would help analyze FUTURE commits. Only include genuinely useful, non-obvious facts. Examples: path mappings between source and target ('frontend/' in source = 'apps/frontend/' in target), key shared functions ('betExitValueLocal() is the canonical P&L helper'), architectural patterns ('store exports are at the bottom of the file'), conventions ('pt-BR locale used in all user-facing text'). Leave as [] if nothing non-obvious was discovered."
+      },
+      keepMemoryKeys: {
+        type: "array",
+        items: { type: "string" },
+        description: "From the merge memory provided in context, list the KEYS of entries that are still useful for future commits. Entries whose keys are NOT listed here will be garbage-collected. If no merge memory was provided, return []. Be selective \u2014 only keep entries that are genuinely useful going forward, not stale or obvious facts."
       }
     },
-    required: ["summary", "alreadyInTarget", "reasoning", "applicationStrategy", "affectedComponents", "opsNotes"],
+    required: [
+      "summary",
+      "alreadyInTarget",
+      "reasoning",
+      "applicationStrategy",
+      "affectedComponents",
+      "opsNotes",
+      "discoveries",
+      "keepMemoryKeys"
+    ],
     additionalProperties: false
   };
   applyResultSchema = {
@@ -1198,9 +1250,114 @@ function findResumableRun(baseDir, workBranch) {
 }
 var init_audit = () => {};
 
+// src/memory.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+
+class MergeMemory {
+  entries = [];
+  filePath;
+  maxEntries = 50;
+  constructor(repoPath) {
+    this.filePath = join4(repoPath, ".backmerge", "memory.jsonl");
+    this.load();
+  }
+  load() {
+    if (!existsSync4(this.filePath))
+      return;
+    try {
+      const raw = readFileSync4(this.filePath, "utf-8");
+      this.entries = raw.split(`
+`).filter(Boolean).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((e) => e !== null);
+    } catch {}
+  }
+  save() {
+    const dir = join4(this.filePath, "..");
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(this.filePath, this.entries.map((e) => JSON.stringify(e)).join(`
+`) + `
+`);
+  }
+  get all() {
+    return this.entries;
+  }
+  get count() {
+    return this.entries.length;
+  }
+  addDiscoveries(discoveries, commitHash) {
+    let added = 0;
+    for (const d of discoveries) {
+      const existing = this.entries.find((e) => e.key === d.key);
+      if (existing) {
+        if (existing.value !== d.value) {
+          existing.value = d.value;
+          existing.source = commitHash;
+          existing.ts = new Date().toISOString();
+        }
+        existing.useCount++;
+      } else {
+        this.entries.push({
+          type: d.type,
+          key: d.key,
+          value: d.value,
+          source: commitHash,
+          ts: new Date().toISOString(),
+          useCount: 1
+        });
+        added++;
+      }
+    }
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
+    this.save();
+    return added;
+  }
+  applyGC(kept) {
+    const keptKeys = new Set(kept.map((k) => k.key));
+    const before = this.entries.length;
+    const newEntries = [];
+    for (const k of kept) {
+      const existing = this.entries.find((e) => e.key === k.key);
+      if (existing) {
+        existing.value = k.value;
+        existing.useCount++;
+        newEntries.push(existing);
+      } else {
+        newEntries.push({
+          type: "pattern",
+          key: k.key,
+          value: k.value,
+          source: "gc",
+          ts: new Date().toISOString(),
+          useCount: 1
+        });
+      }
+    }
+    this.entries = newEntries;
+    this.save();
+    return before - this.entries.length;
+  }
+  toPromptBlock() {
+    if (this.entries.length === 0)
+      return "";
+    const lines = this.entries.map((e) => `[${e.type}] ${e.key}: ${e.value}`);
+    return `--- Merge memory (${this.entries.length} learnings from previous commits) ---
+${lines.join(`
+`)}`;
+  }
+}
+var init_memory = () => {};
+
 // src/git.ts
 import simpleGit from "simple-git";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { tmpdir } from "os";
 function createGit(cwd) {
   return simpleGit(cwd);
@@ -1260,7 +1417,7 @@ async function getDescendantCommitsSince(git, since, ref) {
 }
 function generateWorktreePath(repoName) {
   const id = Math.random().toString(36).slice(2, 8);
-  return join4(tmpdir(), `backmerge-${repoName}-${id}`);
+  return join5(tmpdir(), `backmerge-${repoName}-${id}`);
 }
 async function createDetachedWorktree(git, path, ref) {
   await git.raw(["worktree", "add", "--detach", path, ref]);
@@ -1454,6 +1611,10 @@ async function runEngine(opts, cb) {
     for (const l of logs)
       cb.onLog(`  ${l}`, "gray");
   }
+  const memory = new MergeMemory(repoPath);
+  if (memory.count > 0) {
+    cb.onLog(`Merge memory: ${memory.count} entries from previous commits`, "cyan");
+  }
   if (config.promptHints && config.promptHints.length > 0) {
     cb.onLog(`Active hints (${config.promptHints.length}):`, "cyan");
     for (const h of config.promptHints) {
@@ -1547,28 +1708,8 @@ async function runEngine(opts, cb) {
   await createDetachedWorktree(git, wtPath, wbHead);
   cb.onLog(`Eval worktree (detached): ${wtPath}`, "green");
   const wtGit = createGit(wtPath);
-  const runId = `run-${ts}`;
-  const audit = new AuditLog(repoPath, runId);
-  const runMeta = {
-    runId,
-    startedAt: new Date().toISOString(),
-    sourceRef,
-    targetRef,
-    workBranch: wbName,
-    mergeBase,
-    worktreePath: wtPath,
-    totalCandidates: commitsToProcess.length,
-    cherrySkipped: cherrySkipped.size,
-    dryRun,
-    repoPath
-  };
-  audit.runStart(runMeta);
-  for (const [hash, reason] of cherrySkipped) {
-    const c = allSourceCommits.find((x) => x.hash === hash);
-    if (c)
-      audit.cherrySkip(hash, c.message, reason);
-  }
   let resumeFromIndex = 0;
+  let resumedRunId;
   if (opts.resume && effectiveWorkBranch) {
     const resumeInfo = findResumableRun(repoPath, effectiveWorkBranch);
     if (resumeInfo && resumeInfo.lastCommitIndex >= 0) {
@@ -1580,7 +1721,31 @@ async function runEngine(opts, cb) {
       resumeFromIndex = commitsToProcess.findIndex((c) => !prevHashes.has(c.hash));
       if (resumeFromIndex < 0)
         resumeFromIndex = commitsToProcess.length;
-      cb.onLog(`Resuming from commit ${resumeFromIndex + 1}/${commitsToProcess.length} (${resumeInfo.decisions.length} already decided)`, "green");
+      resumedRunId = resumeInfo.runId;
+      cb.onLog(`Resuming run ${resumeInfo.runId} from commit ${resumeFromIndex + 1}/${commitsToProcess.length} (${resumeInfo.decisions.length} already decided)`, "green");
+    }
+  }
+  const runId = resumedRunId ?? `run-${ts}`;
+  const audit = new AuditLog(repoPath, runId);
+  if (!resumedRunId) {
+    const runMeta = {
+      runId,
+      startedAt: new Date().toISOString(),
+      sourceRef,
+      targetRef,
+      workBranch: wbName,
+      mergeBase,
+      worktreePath: wtPath,
+      totalCandidates: commitsToProcess.length,
+      cherrySkipped: cherrySkipped.size,
+      dryRun,
+      repoPath
+    };
+    audit.runStart(runMeta);
+    for (const [hash, reason] of cherrySkipped) {
+      const c = allSourceCommits.find((x) => x.hash === hash);
+      if (c)
+        audit.cherrySkip(hash, c.message, reason);
     }
   }
   const sourceLatestDiff = await getLatestCommitDiff(git, resolvedSource);
@@ -1610,6 +1775,7 @@ async function runEngine(opts, cb) {
       maxAttempts: effectiveMaxAttempts,
       commitPrefix,
       workBranch: wbName,
+      memory,
       workBranchHead: currentBranchHead
     });
     if (decision.kind === "applied" && decision.newCommitHash) {
@@ -1651,7 +1817,7 @@ async function processOneCommit(o) {
   try {
     touchedPaths = await getCommitFiles(o.git, commit.hash);
   } catch {}
-  const commitCtx = buildCommitContext(o.repoPath, o.repoCtx, o.config, touchedPaths, commit.message);
+  const commitCtx = buildCommitContext(o.repoPath, o.repoCtx, o.config, touchedPaths, commit.message, o.memory.toPromptBlock());
   if (commitCtx.includedFiles.length > 0) {
     audit.writeRelevantDocs(commit.hash, 0, commitCtx.includedFiles.join(`
 `));
@@ -1679,6 +1845,19 @@ async function processOneCommit(o) {
     });
     audit.writeAnalysis(commit.hash, 1, analysis);
     cb.onAnalysis(commit, analysis);
+    if (analysis.discoveries && analysis.discoveries.length > 0) {
+      const added = o.memory.addDiscoveries(analysis.discoveries, commit.hash);
+      if (added > 0) {
+        cb.onLog(`Memory: +${added} new discoveries (${o.memory.count} total)`, "cyan");
+      }
+    }
+    if (o.memory.count > 0 && analysis.keepMemoryKeys) {
+      const kept = o.memory.all.filter((e) => analysis.keepMemoryKeys.includes(e.key));
+      const gcCount = o.memory.applyGC(kept.map((e) => ({ key: e.key, value: e.value })));
+      if (gcCount > 0) {
+        cb.onLog(`Memory: GC'd ${gcCount} stale entries (${o.memory.count} remaining)`, "gray");
+      }
+    }
   } catch (e) {
     audit.error("analysis", commit.hash, commit.message, e.message);
     return mkFailed(commit, "analysis", e.message, start);
@@ -1968,6 +2147,7 @@ var init_engine = __esm(() => {
   init_codex();
   init_review();
   init_audit();
+  init_memory();
   init_git();
 });
 
@@ -1977,11 +2157,11 @@ __export(exports_batch, {
   runBatch: () => runBatch
 });
 import chalk from "chalk";
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync5(join6(import.meta.dir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync6(join7(import.meta.dir, "..", "package.json"), "utf-8"));
     return pkg.version ?? "?";
   } catch {
     return "?";
@@ -2059,43 +2239,20 @@ async function runBatch(opts) {
       const subMatch = msg.match(/^\[(\w+)\]\s*(.*)/);
       const sub = subMatch ? subMatch[1] : phase;
       const text = subMatch ? subMatch[2] : msg;
-      let icon;
       switch (sub) {
-        case "read":
-          icon = chalk.cyan("\uD83D\uDCD6");
-          break;
-        case "grep":
-          icon = chalk.cyan("\uD83D\uDD0D");
-          break;
-        case "glob":
-          icon = chalk.cyan("\uD83D\uDCC2");
-          break;
-        case "exec":
-          icon = chalk.yellow("\u26A1");
-          break;
         case "file":
-          icon = chalk.green("\u270F\uFE0F");
+          log(`  ${ts()} \u270F\uFE0F  ${chalk.green(text)}`);
           break;
         case "think":
-          icon = chalk.blue("\uD83D\uDCAD");
-          break;
-        case "tool":
-          icon = chalk.dim("\uD83D\uDD27");
+          log(`  ${ts()} \uD83D\uDCAD ${chalk.blue(text)}`);
           break;
-        case "analyze":
-          icon = chalk.blue("\u25C6");
-          break;
-        case "apply":
-          icon = chalk.green("\u25B8");
-          break;
-        case "review":
-          icon = chalk.magenta("\u25CF");
+        case "read":
+          log(`  ${ts()} \uD83D\uDCD6 ${chalk.dim(text)}`);
           break;
         default:
-          icon = chalk.dim("\xB7");
+          log(`  ${ts()}    ${chalk.dim(text)}`);
           break;
       }
-      log(`  ${ts()} ${icon} ${chalk.dim(text)}`);
     },
     onLog(msg, color) {
       if (jsonl)
@@ -2138,6 +2295,11 @@ async function runBatch(opts) {
       if (analysis.opsNotes.length > 0) {
         log(`  ${chalk.yellow("  ops:")} ${analysis.opsNotes.join("; ")}`);
       }
+      if (analysis.discoveries && analysis.discoveries.length > 0) {
+        for (const d of analysis.discoveries) {
+          log(`  ${chalk.cyan(`  \uD83D\uDCA1 [${d.type}] ${d.key}:`)} ${d.value}`);
+        }
+      }
     },
     onDecision(commit, decision) {
       if (jsonl)
@@ -2282,12 +2444,12 @@ import { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp, Static, Newline } from "ink";
 import SelectInput from "ink-select-input";
 import Spinner from "ink-spinner";
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
 var XAB_VERSION = (() => {
   try {
-    return JSON.parse(readFileSync4(join5(import.meta.dir, "..", "package.json"), "utf-8")).version ?? "?";
+    return JSON.parse(readFileSync5(join6(import.meta.dir, "..", "package.json"), "utf-8")).version ?? "?";
   } catch {
     return "?";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xab",
-  "version": "11.0.0",
+  "version": "13.0.0",
   "description": "AI-powered curated branch reconciliation engine",
   "type": "module",
   "bin": {
@@ -33,6 +33,6 @@
     "ink-text-input": "^6.0.0",
     "react": "18.3.1",
     "simple-git": "^3.33.0",
-    "xab": "^5.0.0"
+    "xab": "12"
   }
 }