karajan-code 2.10.1 → 2.11.0

package/src/utils/display/session-summary.js

@@ -26,9 +26,19 @@ function printSessionPlanner(planner) {
   }
 }
 
-function printSessionSonar(sonar) {
+export function printSessionSonar(sonar) {
   if (!sonar) return;
-  const gateLabel = sonar.gateStatus === "OK" ? ANSI.green : ANSI.red;
+  // Three buckets so the banner reads correctly:
+  //   - OK                                 \u2192 green (real pass).
+  //   - SKIPPED / PENDING                  \u2192 gray (informational; sonar
+  //     wasn't gated against, this is NOT a fail). Pre-2026-05-07 N4
+  //     dogfooding these were rendered red, which made a clean run
+  //     look like a sonar failure during the live demo.
+  //   - everything else (ERROR, WARN, ...) \u2192 red (real fail).
+  let gateLabel;
+  if (sonar.gateStatus === "OK") gateLabel = ANSI.green;
+  else if (sonar.gateStatus === "SKIPPED" || sonar.gateStatus === "PENDING") gateLabel = ANSI.gray;
+  else gateLabel = ANSI.red;
   console.log(`  ${ANSI.dim}\ud83d\udd0d Sonar: ${gateLabel}${sonar.gateStatus}${ANSI.reset}${ANSI.dim} (${sonar.openIssues ?? 0} issues)${ANSI.reset}`);
   if (typeof sonar.issuesInitial === "number" || typeof sonar.issuesResolved === "number") {
     const issuesInitial = sonar.issuesInitial ?? sonar.openIssues ?? 0;

package/src/utils/git.js

@@ -65,6 +65,42 @@ export async function revParse(ref) {
   return runGit(["rev-parse", ref]);
 }
 
+/**
+ * List commits in the range `fromSha..toRef`. Used by the post-loop
+ * journal builder to enumerate every commit produced during a `kj run`
+ * — both the coder's own commits AND the post-loop scaffold commit —
+ * so the user-visible summary doesn't lose track of them. Pre-fix the
+ * summary only listed `gitResult.commits` (post-loop only), which made
+ * `kj run "..."` runs look like the coder hadn't committed.
+ *
+ * Returns oldest-first so the list reads in execution order.
+ *
+ * @param {string|null|undefined} fromSha The SHA right BEFORE the run started
+ *   (typically `session.session_start_sha`). Empty/missing → returns [].
+ * @param {string} [toRef="HEAD"]
+ * @returns {Promise<Array<{hash: string, message: string}>>}
+ */
+export async function listCommitsBetween(fromSha, toRef = "HEAD") {
+  if (!fromSha) return [];
+  const result = await run(
+    "git",
+    ["log", "--reverse", "--format=%H%x09%s", `${fromSha}..${toRef}`],
+  ).catch(() => null);
+  if (!result || result.exitCode !== 0) return [];
+  return String(result.stdout || "")
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .map((line) => {
+      const tabIdx = line.indexOf("\t");
+      // Defensive: if git emitted no tab (shouldn't happen with our format)
+      // treat the whole line as the hash and leave the message empty rather
+      // than throw — caller can still render the row.
+      if (tabIdx === -1) return { hash: line, message: "" };
+      return { hash: line.slice(0, tabIdx), message: line.slice(tabIdx + 1) };
+    });
+}
+
 export async function syncBaseBranch({ baseBranch, autoRebase }) {
   const local = await revParse(baseBranch);
   const remote = await revParse(`origin/${baseBranch}`);
@@ -109,11 +145,79 @@ export async function hasChanges() {
   return status.length > 0;
 }
 
+/**
+ * Return the relative paths of every uncommitted change (modified,
+ * untracked, staged, etc.) in the working tree. Each path is the
+ * filename as `git status --porcelain` reports it (after the 2-char
+ * status code + space). Returns an empty array when the tree is clean.
+ *
+ * Used by `finalizeGitAutomation` to decide whether the changes
+ * pending at the end of a pipeline are exclusively Karajan
+ * scaffolding (and thus deserve a `chore:` commit message instead
+ * of inheriting the user task's `feat:`).
+ *
+ * NOTE: bypasses `runGit()` because that helper trims stdout, which
+ * eats the leading space of porcelain lines whose first status char
+ * is " " (e.g. " M .gitignore" → "M .gitignore"). The leading space
+ * is structural here — without it the slice(3) below would crop one
+ * character off the first path.
+ */
+export async function listPendingPaths() {
+  const res = await run("git", ["status", "--porcelain"]);
+  if (res.exitCode !== 0) {
+    throw new Error(`git status --porcelain failed: ${res.stderr || res.stdout}`);
+  }
+  const stdout = res.stdout;
+  if (!stdout) return [];
+  const lines = stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    // Each line is "XY <path>" (XY = 2-char status, space, path).
+    // Renames look like "R  old -> new"; we want the new path.
+    const after = line.slice(3);
+    const arrow = after.indexOf(" -> ");
+    out.push(arrow !== -1 ? after.slice(arrow + 4) : after);
+  }
+  return out;
+}
+
+// Locale-tolerant detection of "git commit refused because the working
+// tree was already clean by the time we ran it". Observed in N4
+// dogfooding (2026-05-07) — `hasChanges()` reported true after `add -A`
+// but `git commit` then failed with the Spanish message "nada para hacer
+// commit, el árbol de trabajo está limpio". The race window is real:
+// post-loop journal writes can finish between hasChanges and commit, and
+// some files come back from `add -A` with no diff vs HEAD even though
+// they show up in `git status --porcelain`. We treat any of those as
+// "no commit needed" rather than escalating to Solomon.
+const NOTHING_TO_COMMIT_PATTERNS = [
+  /nothing to commit/i,
+  /nada para hacer commit/i,         // git in es_ES locale
+  /no hay nada para confirmar/i,     // git in es_ES alt phrasing
+  /aucune modification ajout[ée]e au commit/i, // fr_FR
+  /nichts zu committen/i,            // de_DE
+];
+function isNothingToCommit(message) {
+  const m = String(message || "");
+  return NOTHING_TO_COMMIT_PATTERNS.some((re) => re.test(m));
+}
+
 export async function commitAll(message) {
   await runGit(["add", "-A"]);
   const changed = await hasChanges();
   if (!changed) return { committed: false };
-  await runGit(["commit", "-m", message]);
+  try {
+    await runGit(["commit", "-m", message]);
+  } catch (err) {
+    // `git status --porcelain` and `git commit` disagreed about whether
+    // there was anything to commit. Don't escalate — the only outcome
+    // either way is "no new commit was created", which the caller
+    // already handles via committed=false.
+    if (isNothingToCommit(err?.message)) {
+      return { committed: false };
+    }
+    throw err;
+  }
   const raw = await runGit(["log", "-1", "--pretty=format:%H%x1f%s"]);
   const [hash, commitMessage] = raw.split("\x1f");
   return { committed: true, commit: { hash, message: commitMessage } };