@karajan-family/code 4.68.0 → 4.68.1

package/package.json

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

package/src/cli.js

@@ -14,6 +14,10 @@ import { registerStandby } from "./cli/register-standby.js";
 import { printUpdateNotice } from "./utils/update-check.js";
 import { printWelcomeScreen } from "./utils/welcome.js";
 import { migrateKjToKarajan } from "./utils/home-migration.js";
+import { pinGitDiffFormat } from "./utils/git-diff-format.js";
+
+// KJC-BUG-0408: every git kj runs prints a/ and b/, whatever the user's gitconfig says.
+pinGitDiffFormat();
 
 const PKG_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
 const PKG_VERSION = JSON.parse(readFileSync(PKG_PATH, "utf8")).version;

package/src/git/symlink-targets.js

@@ -0,0 +1,57 @@
+/**
+ * KJC-BUG-0414 (#2606, from #2564): Solomon told the coder to drop a file from the commit as a
+ * mirror of another, but the other was a symlink to it: the link would be committed dangling.
+ * kj names the in-repo targets of the symlinks in a change, and a condition that takes one of
+ * them out of the commit is dropped before it reaches the coder.
+ */
+import { lstatSync, readlinkSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+
+/** The in-repo target of each symlink among `paths` (relative to projectDir). */
+export function symlinkTargets(projectDir, paths) {
+  const root = resolve(projectDir);
+  return paths.flatMap((link) => {
+    try {
+      const abs = join(root, link);
+      if (!lstatSync(abs).isSymbolicLink()) return [];
+      const target = relative(root, resolve(dirname(abs), readlinkSync(abs)));
+      const outside = target === ".." || target.startsWith(`..${sep}`) || isAbsolute(target);
+      return target && !outside ? [{ link, target: target.split(sep).join("/") }] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// A `*` matches within one path segment, as in the shell.
+const segmentMatches = (pattern, name) => {
+  const parts = pattern.split("*");
+  if (parts.length === 1) return pattern === name;
+  if (!name.startsWith(parts[0]) || !name.endsWith(parts.at(-1))) return false;
+  let at = parts[0].length;
+  for (const part of parts.slice(1, -1)) {
+    const found = name.indexOf(part, at);
+    if (found < 0) return false;
+    at = found + part.length;
+  }
+  return at <= name.length - parts.at(-1).length;
+};
+const globMatches = (pattern, path) => {
+  const p = pattern.split("/");
+  const t = path.split("/");
+  return p.length === t.length && p.every((seg, i) => segmentMatches(seg, t[i]));
+};
+const REMOVES = /\b(unstage|remove|drop|exclude|delete|restore|reset|revert|rm|untrack|quitar|sacar|eliminar|excluir|borrar)\b/i;
+// Quoted strings are one token (a path may hold spaces); bare tokens lose surrounding punctuation.
+const TOKENS = /"([^"]+)"|'([^']+)'|`([^`]+)`|(\S+)/g;
+const tokensOf = (text) => [...String(text).matchAll(TOKENS)]
+  .map((m) => (m[1] ?? m[2] ?? m[3] ?? m[4]).replace(/^[([{]+/, "").replace(/[)\]}:;,]+$/, ""));
+// Named literally anywhere in the text (any character git allows), or by a glob token.
+const names = (condition, target) => String(condition).includes(target) || tokensOf(condition).some((t) => globMatches(t, target));
+
+/** Splits Solomon's conditions: the ones that would take a symlink's target out of the commit go to `dropped`. */
+export function keepSymlinkTargets(conditions, targets) {
+  const takesTargetOut = (condition) => REMOVES.test(condition) && targets.some(({ target }) => names(condition, target));
+  const dropped = targets.length ? conditions.filter(takesTargetOut) : [];
+  return { kept: conditions.filter((c) => !dropped.includes(c)), dropped };
+}

package/src/mcp/server.js

@@ -7,6 +7,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { tools } from "./tools.js";
 import { handleToolCall, responseText, enrichedFailPayload } from "./server-handlers.js";
+import { pinGitDiffFormat } from "../utils/git-diff-format.js";
+
+// KJC-BUG-0408: every git the MCP server runs prints a/ and b/, whatever the user's gitconfig says.
+pinGitDiffFormat();
 
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PKG_PATH = path.resolve(MODULE_DIR, "../../package.json");

package/src/orchestrator/solomon-escalation.js

@@ -3,12 +3,35 @@ import { addCheckpoint, pauseSession, saveSession } from "../session/store.js";
 import { setSuggestions } from "../session/mutators.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
 import { msg, getLang } from "../utils/messages.js";
+import { listPendingPaths } from "../utils/git.js";
+import { keepSymlinkTargets, symlinkTargets } from "../git/symlink-targets.js";
 
 /**
  * @typedef {import("../types/solomon.js").Conflict} Conflict
  * @typedef {import("../types/solomon.js").SolomonResult} SolomonResult
  */
 
+// KJC-BUG-0414 (#2606): the symlinks among the pending paths, so Solomon never advises taking a
+// link's target out of the commit. Unlistable is said, and Solomon goes on without the fact.
+async function changeSymlinks(config, logger) {
+  const projectDir = config.projectDir || process.cwd();
+  try {
+    return symlinkTargets(projectDir, await listPendingPaths(projectDir));
+  } catch (err) {
+    logger.warn(`Solomon: the change's symlinks could not be listed (${err.message})`);
+    return [];
+  }
+}
+
+function dropSymlinkTargetConditions(ruling, symlinks, logger) {
+  const conditions = ruling?.result?.conditions;
+  if (!Array.isArray(conditions) || symlinks.length === 0) return;
+  const { kept, dropped } = keepSymlinkTargets(conditions, symlinks);
+  if (dropped.length === 0) return;
+  ruling.result.conditions = kept;
+  logger.warn(`Solomon: dropped ${dropped.length} condition(s) that took a symlink's target out of the commit: ${dropped.join(" | ")}`);
+}
+
 /**
  * Architectural invariant (DO NOT BREAK):
  * `invokeSolomon` MUST NOT be called directly from stages, rules or agent
@@ -147,12 +170,15 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
   try {
     // Inject Solomon's own history so it doesn't repeat failed strategies
     const solomonHistory = extractSolomonHistory(session);
+    const symlinks = await changeSymlinks(config, logger);
     const enrichedConflict = {
       ...conflict,
       ...(pendingSuggestions && { hostSuggestions: pendingSuggestions }),
-      ...(solomonHistory.length > 0 && { previousSolomonRulings: solomonHistory })
+      ...(solomonHistory.length > 0 && { previousSolomonRulings: solomonHistory }),
+      ...(symlinks.length > 0 && { symlinkTargets: symlinks })
     };
     ruling = await solomon.run({ conflict: enrichedConflict });
+    dropSymlinkTargetConditions(ruling, symlinks, logger);
   } catch (err) {
     logger.warn(`Solomon threw: ${err.message}`);
     return escalateToHuman({

package/src/privacy/diff-scope.js

@@ -50,6 +50,9 @@ export function splitAddedByFile(diff) {
       out.push(current);
       continue;
     }
+    // KJC-BUG-0408: a file header in another shape (mnemonic or no prefix) would leave its lines
+    // unscanned and the gate passing. A diff that cannot be read fails closed.
+    if (line.startsWith("diff --git ")) throw new Error(`cannot read the file headers of this diff (${line}): refusing to scan it as empty`);
     if (!current) continue;
     // `+++ b/x` is the header, not content; `+` alone is an added blank line.
     if (line.startsWith("+") && !line.startsWith("+++")) current.lines.push(line.slice(1));

package/src/roles/solomon-role.js

@@ -144,6 +144,12 @@ function buildPrompt({ conflict, task, instructions }) {
     sections.push(`## Blocking issues\n${issueList}`);
   }
 
+  // KJC-BUG-0414 (#2606): taking a symlink's target out of the commit leaves the link dangling.
+  if (conflict?.symlinkTargets?.length) {
+    const links = conflict.symlinkTargets.map(({ link, target }) => `- ${link} -> ${target}`).join("\n");
+    sections.push(`## Symlinks in this change\n${links}\nEach target stays in the commit: never propose unstaging, removing or restoring it, or the link is committed dangling.`);
+  }
+
   if (task) {
     sections.push(`## Original task\n${task}`);
   }

package/src/utils/git-diff-format.js

@@ -0,0 +1,40 @@
+/**
+ * KJC-BUG-0408 (#2560): kj reads the diffs git prints for it (privacy, sonar, review, guards),
+ * and every parser expects `a/` and `b/`. A user's diff.mnemonicPrefix (c/, i/, w/), noprefix or
+ * srcPrefix changed those headers: the suite went red on that machine and the privacy gate saw
+ * no file and passed. kj pins the format of the git it runs through the environment (the
+ * GIT_CONFIG_COUNT protocol, git >= 2.31), so every child inherits it and no parser depends on
+ * the user's gitconfig. The pins are appended after whatever config the environment carries.
+ */
+
+// KJC-BUG-0415 (#2622): a verdict binds to the hash of the diff text, so every option that
+// changes that text is pinned to git's default too, or the hash kj review --staged records on a
+// machine with diff.algorithm=histogram is not the one CI recomputes.
+const PINS = [
+  ["diff.mnemonicPrefix", "false"],
+  ["diff.noprefix", "false"],
+  ["diff.srcPrefix", "a/"],
+  ["diff.dstPrefix", "b/"],
+  ["diff.algorithm", "myers"],
+  ["diff.context", "3"],
+  ["diff.interHunkContext", "0"],
+  ["diff.indentHeuristic", "true"],
+  ["diff.suppressBlankEmpty", "false"],
+  ["diff.renames", "true"],
+  ["diff.relative", "false"],
+  ["color.diff", "false"],
+];
+const PINNED = "KJ_GIT_DIFF_PINNED";
+
+/** Pin git's diff headers to a/ and b/ for every git that inherits `env`; idempotent. */
+export function pinGitDiffFormat(env = process.env) {
+  if (env[PINNED]) return env;
+  const count = Number.parseInt(env.GIT_CONFIG_COUNT ?? "0", 10) || 0;
+  PINS.forEach(([key, value], i) => {
+    env[`GIT_CONFIG_KEY_${count + i}`] = key;
+    env[`GIT_CONFIG_VALUE_${count + i}`] = value;
+  });
+  env.GIT_CONFIG_COUNT = String(count + PINS.length);
+  env[PINNED] = "1";
+  return env;
+}