karajan-code 4.57.2 → 4.57.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "4.57.2",
+  "version": "4.57.3",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/review/diff-batches.js

@@ -20,6 +20,42 @@ export function splitByFile(diff) {
   return parts.map(({ file, lines }) => ({ file, text: lines.join("\n"), changed: changedLines(lines) }));
 }
 
+const HUNK_HEAD = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/;
+
+/**
+ * KJC-BUG-0384: one hunk cut into windows that fit `room` characters with their own
+ * `@@ -old,count +new,count @@` header, so the reviewer reads the right line numbers.
+ * A single line that cannot fit stays alone in a window larger than the room, which
+ * batchDiff leaves out and names; no batch ever exceeds the limit.
+ */
+function splitHunk(lines, budget) {
+  const head = HUNK_HEAD.exec(lines[0]);
+  if (!head) return [lines];
+  // The rewritten header: the original's trailing context plus four line numbers of up to 10 digits.
+  const room = budget - (head[3].length + 50);
+  let oldAt = Number(head[1]);
+  let newAt = Number(head[2]);
+  const windows = [];
+  let cur = [];
+  let size = 0;
+  const flush = () => {
+    const oldCount = cur.filter((l) => l[0] === " " || l[0] === "-").length;
+    const newCount = cur.filter((l) => l[0] === " " || l[0] === "+").length;
+    windows.push([`@@ -${oldAt},${oldCount} +${newAt},${newCount} @@${head[3]}`, ...cur]);
+    oldAt += oldCount;
+    newAt += newCount;
+    cur = [];
+    size = 0;
+  };
+  for (const line of lines.slice(1)) {
+    if (cur.length > 0 && size + line.length + 1 > room) flush();
+    cur.push(line);
+    size += line.length + 1;
+  }
+  if (cur.length > 0) flush();
+  return windows;
+}
+
 const changedLines = (lines) => lines.filter((l) => /^[+-]/.test(l) && !/^(\+\+\+|---) /.test(l)).length;
 
 /**
@@ -69,7 +105,10 @@ function piecesOf(part, limit) {
     hunks.at(-1).push(line);
   }
   const pieces = [];
-  for (const hunk of hunks.map((h) => h.join("\n"))) {
+  // KJC-BUG-0384: a hunk larger than a batch (a new file is one hunk) is cut by lines.
+  const room = limit - header.length - 1;
+  const fitted = hunks.flatMap((h) => (h.join("\n").length > room ? splitHunk(h, room) : [h]));
+  for (const hunk of fitted.map((h) => h.join("\n"))) {
     const last = pieces.at(-1);
     if (last && last.text.length + 1 + hunk.length <= limit) last.text = `${last.text}\n${hunk}`;
     else pieces.push({ file: part.file, text: `${header}\n${hunk}` });

package/src/review/split-advice.js

@@ -31,7 +31,8 @@ function commonPrefix(lists) {
 
 /** The structural path of each file: the segments that tell its responsibility. */
 function keysOf(files) {
-  const javaMain = /(^|\/)src\/main\/(java|kotlin)\/(.+)$/;
+  // KJC-BUG-0383: main and test source sets alike; a Maven PR can live wholly under src/test/java.
+  const javaMain = /(^|\/)src\/(?:main|test)\/(java|kotlin)\/(.+)$/;
   const javaDirs = files.map((f) => javaMain.exec(f.file)).filter(Boolean).map((m) => dirsOf(m[3]));
   // The root package (com/acme/app), never a layer: a PR that only touches pages/ keeps "pages".
   const common = commonPrefix(javaDirs);
@@ -39,12 +40,12 @@ function keysOf(files) {
   const prefix = layerAt === -1 ? common : common.slice(0, layerAt);
   return files.map(({ file }) => {
     if (/(^|\/)src\/(main|test)\/resources\//.test(file)) return ["resources"];
-    if (isTest(file)) return ["tests"];
     const java = javaMain.exec(file);
     if (java) {
       const rest = dirsOf(java[3]).slice(prefix.length);
       return rest.length > 0 ? rest : ["main"];
     }
+    if (isTest(file)) return ["tests"];
     const src = /(^|\/)src\/(.+)$/.exec(file);
     if (src && dirsOf(src[2]).length > 0) return dirsOf(src[2]);
     const dirs = dirsOf(file);
@@ -61,14 +62,22 @@ function group(entries, depth) {
   return [...groups].map(([name, items]) => ({ name, items, lines: items.reduce((n, i) => n + i.changed, 0), depth }));
 }
 
-/** Groups by the first segment, then splits any group over `limit` by its next level. */
+// KJC-BUG-0383: a chunk holding more than this share of the files is split one level down.
+const MAX_FILE_SHARE = 0.6;
+
+/** Groups by the first segment, then splits any group over `limit` or the file share by its next level. */
 function chunksOf(entries, limit) {
   const out = [];
   const pending = group(entries, 1);
   while (pending.length > 0) {
     const g = pending.shift();
     const deeper = g.items.some((i) => i.key.length > g.depth);
-    if (g.lines > limit && deeper) pending.push(...group(g.items, g.depth + 1));
+    const tooBig = g.lines > limit || g.items.length > entries.length * MAX_FILE_SHARE;
+    // Going down only helps when it really splits the group: past a lone subpackage, keep going.
+    let depth = g.depth + 1;
+    let sub = tooBig && deeper ? group(g.items, depth) : [];
+    while (sub.length === 1 && g.items.some((i) => i.key.length > depth)) sub = group(g.items, ++depth);
+    if (sub.length > 1) pending.push(...sub);
     else out.push(g);
   }
   return out;