@karajan-family/code 4.21.0

package/src/utils/git.js

@@ -0,0 +1,279 @@
+import { runCommand } from "./process.js";
+import { getRunContext } from "./run-context.js";
+
+/**
+ * Module-scoped runner — legacy back-compat for callers outside a
+ * `withRunContext` scope (CLI bootstrap, checks/system.js). When running
+ * inside a pipeline, `getRunContext()?.runner` takes precedence and
+ * provides per-run isolation (TSK-0338). When neither is set we fall
+ * back to the bare `runCommand`.
+ *
+ * @type {((command: string, args?: string[], options?: object) => Promise<object>)|null}
+ */
+let _runner = null;
+
+/**
+ * Set the module-scope runner. Retained for back-compat: concurrent
+ * `runFlow` invocations should rely on `withRunContext` for isolation,
+ * not on this setter (the setter is process-wide and would cause the
+ * exact cross-run contamination TSK-0338 eliminates).
+ */
+export function setRunner(runner) {
+  _runner = runner;
+}
+
+function run(command, args, ...rest) {
+  const ctxRunner = getRunContext()?.runner;
+  return (ctxRunner || _runner || runCommand)(command, args, ...rest);
+}
+
+function slugifyTask(task) {
+  return String(task)
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9]+/g, "-")
+    .replaceAll(/(^-+)|(-+$)/g, "")
+    .slice(0, 40);
+}
+
+async function runGit(args, options = {}) {
+  const res = await run("git", args, options);
+  if (res.exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed: ${res.stderr || res.stdout}`);
+  }
+  return res.stdout.trim();
+}
+
+export async function ensureGitRepo() {
+  const res = await run("git", ["rev-parse", "--is-inside-work-tree"]);
+  return res.exitCode === 0 && res.stdout.trim() === "true";
+}
+
+export async function currentBranch() {
+  return runGit(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+
+export async function hasCommits() {
+  const res = await run("git", ["rev-parse", "HEAD"]);
+  return res.exitCode === 0;
+}
+
+export async function fetchBase(baseBranch) {
+  await runGit(["fetch", "origin", baseBranch]);
+}
+
+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}>>}
+ */
+/**
+ * List the file paths changed in the range `fromSha..toRef`. Used by the
+ * plan-adherence metric (KJC-TSK-0376) to score whether the coder's
+ * file changes fall within any HU's declared scope.
+ *
+ * Returns a deduplicated array of file paths, oldest commit's files
+ * first. Defensive: returns [] on missing `fromSha`, non-zero git exit,
+ * or thrown error — consistent with `listCommitsBetween`'s contract.
+ *
+ * @param {string|null|undefined} fromSha
+ * @param {string} [toRef="HEAD"]
+ * @returns {Promise<string[]>}
+ */
+export async function listFilesChangedSince(fromSha, toRef = "HEAD") {
+  if (!fromSha) return [];
+  const result = await run(
+    "git",
+    ["diff", "--name-only", `${fromSha}..${toRef}`],
+  ).catch(() => null);
+  if (!result || result.exitCode !== 0) return [];
+  const lines = String(result.stdout || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return Array.from(new Set(lines));
+}
+
+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}`);
+  if (local === remote) return { synced: true, rebased: false };
+
+  if (!autoRebase) {
+    throw new Error(
+      `Base branch '${baseBranch}' is behind origin/${baseBranch}. Re-run with auto-rebase enabled or rebase manually.`
+    );
+  }
+
+  await runGit(["rebase", `origin/${baseBranch}`]);
+  return { synced: true, rebased: true };
+}
+
+export async function ensureBranchUpToDateWithBase({ branch, baseBranch, autoRebase }) {
+  const mergeBase = await runGit(["merge-base", branch, `origin/${baseBranch}`]);
+  const remoteBase = await revParse(`origin/${baseBranch}`);
+  if (mergeBase === remoteBase) return { upToDate: true, rebased: false };
+
+  if (!autoRebase) {
+    throw new Error(
+      `Base branch '${baseBranch}' advanced during run. Re-run with auto-rebase enabled or rebase '${branch}' manually.`
+    );
+  }
+
+  await runGit(["rebase", `origin/${baseBranch}`]);
+  return { upToDate: true, rebased: true };
+}
+
+export async function createBranch(branchName) {
+  await runGit(["checkout", "-b", branchName]);
+}
+
+export function buildBranchName(prefix, task) {
+  const stamp = new Date().toISOString().replaceAll(/[:.]/g, "-").slice(0, 16);
+  return `${prefix}${slugifyTask(task) || "task"}-${stamp}`;
+}
+
+export async function hasChanges(cwd = null) {
+  const status = await runGit(["status", "--porcelain"], cwd ? { cwd } : {});
+  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, cwd = null, { beforeCommit = null } = {}) {
+  const opts = cwd ? { cwd } : {};
+  await runGit(["add", "-A"], opts);
+  const changed = await hasChanges(cwd);
+  if (!changed) return { committed: false };
+  // ENV-F1 (KJC-TSK-0643): runs between staging and committing — the only
+  // window where the staged diff is exactly what the commit will contain
+  // (used to stamp the pipeline's review verdict for the v4 gate).
+  if (beforeCommit) await beforeCommit();
+  try {
+    await runGit(["commit", "-m", message], opts);
+  } 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"], opts);
+  const [hash, commitMessage] = raw.split("\x1f");
+  return { committed: true, commit: { hash, message: commitMessage } };
+}
+
+/**
+ * KJC-BUG-0112: whether the repo has an `origin` remote. The quickstart
+ * scenario (fresh folder + git init) has none — post-approval push/PR
+ * automation must skip instead of failing and escalating to Solomon.
+ */
+export async function hasRemote(cwd = null) {
+  const res = await run("git", ["remote", "get-url", "origin"], cwd ? { cwd } : {});
+  return res.exitCode === 0;
+}
+
+export async function pushBranch(branch, cwd = null) {
+  await runGit(["push", "-u", "origin", branch], cwd ? { cwd } : {});
+}
+
+export async function createPullRequest({ baseBranch, branch, title, body, cwd = null }) {
+  const args = ["pr", "create", "--base", baseBranch, "--head", branch, "--title", title, "--body", body];
+  const res = await runCommand("gh", args, cwd ? { cwd } : {});
+  if (res.exitCode !== 0) {
+    throw new Error(`gh ${args.join(" ")} failed: ${res.stderr || res.stdout}`);
+  }
+  return res.stdout.trim();
+}

package/src/utils/home-migration.js

@@ -0,0 +1,87 @@
+// One-shot ~/.kj/ → ~/.karajan/ home consolidation (PR 2 of KJC-PCS-0047).
+// Idempotent via `<target>/.kj-migrated.json`. Tarball backup under
+// `<target>/backup/`. `plans/`, `standby/`, `worktrees/` are moved
+// wholesale; `runs/` is merged with `.karajan/` winning on conflict.
+// Cross-device safe. Non-fatal: CLI bootstrap wraps in try/catch.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { execa } from "execa";
+
+const MARKER = ".kj-migrated.json";
+const MOVE_DIRS = ["plans", "standby", "worktrees"];
+
+async function readdirOrNull(dir) {
+  try { return await fs.readdir(dir); } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+async function moveChildren(src, dst, { mergeMode = false } = {}) {
+  const children = await readdirOrNull(src);
+  if (!children?.length) return 0;
+  await fs.mkdir(dst, { recursive: true });
+  let n = 0;
+  for (const c of children) {
+    const dstChild = path.join(dst, c);
+    if (mergeMode) {
+      try { await fs.access(dstChild); continue; } catch { /* no conflict */ }
+    }
+    const srcChild = path.join(src, c);
+    try { await fs.rename(srcChild, dstChild); } catch (err) {
+      if (err.code !== "EXDEV") throw err;
+      await fs.cp(srcChild, dstChild, { recursive: true });
+      await fs.rm(srcChild, { recursive: true, force: true });
+    }
+    n += 1;
+  }
+  await fs.rm(src, { recursive: true, force: true }).catch(() => {});
+  return n;
+}
+
+export async function migrateKjToKarajan({ dryRun = false, force = false } = {}) {
+  // VITEST guard — tests setting KJ_HOME would otherwise migrate against
+  // the developer's real HOME. Migrator's own tests pass `force: true`.
+  if (process.env.VITEST && !force) return { migrated: false, reason: "vitest-skip" };
+
+  const sourceDir = process.env.KJ_HOME || path.join(os.homedir(), ".kj");
+  const targetDir = process.env.KARAJAN_HOME || path.join(os.homedir(), ".karajan");
+
+  if (path.resolve(sourceDir) === path.resolve(targetDir)) {
+    return { migrated: false, reason: "same-path" };
+  }
+  const entries = await readdirOrNull(sourceDir);
+  if (!entries) return { migrated: false, reason: "source-missing" };
+  if (entries.length === 0) return { migrated: false, reason: "source-empty" };
+
+  await fs.mkdir(targetDir, { recursive: true });
+  const markerPath = path.join(targetDir, MARKER);
+  try { await fs.access(markerPath); return { migrated: false, reason: "already-migrated" }; }
+  catch { /* not present — proceed */ }
+
+  if (dryRun) return { migrated: false, reason: "dry-run", sourceDir, targetDir };
+
+  const backupDir = path.join(targetDir, "backup");
+  await fs.mkdir(backupDir, { recursive: true });
+  const ts = new Date().toISOString().replaceAll(/[:.]/g, "-");
+  const backupPath = path.join(backupDir, `kj-pre-migration-${ts}.tar.gz`);
+  await execa("tar", ["-czf", backupPath, "-C", path.dirname(sourceDir), path.basename(sourceDir)]);
+
+  const counts = {};
+  for (const sub of MOVE_DIRS) {
+    counts[sub] = await moveChildren(path.join(sourceDir, sub), path.join(targetDir, sub));
+  }
+  counts.runs = await moveChildren(path.join(sourceDir, "runs"), path.join(targetDir, "runs"), { mergeMode: true });
+
+  const marker = { version: 1, migrated_at: new Date().toISOString(), items_moved: counts, backup_path: backupPath, source_dir: sourceDir, target_dir: targetDir };
+  await fs.writeFile(markerPath, JSON.stringify(marker, null, 2));
+
+  const summary = Object.entries(counts).filter(([, n]) => n > 0).map(([k, n]) => `${n} ${k}`).join(" + ");
+  if (summary) {
+    // eslint-disable-next-line no-console
+    console.warn(`\x1b[33m[warn]\x1b[0m Migrated ${summary} from ${sourceDir} to ${targetDir} (backup: ${backupPath})`);
+  }
+  return { migrated: true, counts, backupPath, marker };
+}

package/src/utils/injection-guard.js

@@ -0,0 +1,186 @@
+/**
+ * Prompt-injection guard for AI-reviewed diffs and PR content.
+ *
+ * Scans text for patterns commonly used to hijack LLM instructions:
+ * directive overrides, role reassignment, invisible Unicode, and
+ * suspiciously large comment blocks that could hide payloads.
+ *
+ * @module utils/injection-guard
+ */
+
+/** Phrases that attempt to override system/reviewer instructions. */
+const DIRECTIVE_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|rules?|prompts?|guidelines?)/i,
+  /disregard\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|rules?|prompts?)/i,
+  /forget\s+(all\s+)?(previous|prior|your)\s+(instructions?|rules?|context)/i,
+  /override\s+(the\s+)?(system|reviewer|review)\s+(prompt|instructions?|rules?)/i,
+  /do\s+not\s+follow\s+(the\s+)?(above|previous|system)\s+(instructions?|rules?)/i,
+  /new\s+instructions?\s*:/i,
+  /system\s*:\s*you\s+are/i,
+  /\bact\s+as\s+(a\s+)?(different|new|my|an?\s+)/i,
+  /you\s+are\s+now\s+(a\s+)?/i,
+  /from\s+now\s+on\s*(,|\s)?\s*you\s+(will|should|must|are)/i,
+  /pretend\s+(you\s+are|to\s+be)/i,
+  /respond\s+(only\s+)?with\s+["']?approved["']?/i,
+  /always\s+(return|respond|output)\s+.*approved/i,
+  /set\s+approved\s*[=:]\s*true/i,
+  /\bapproved["']?\s*:\s*true\b.*ignore/i,
+  /output\s+the\s+following\s+json/i,
+  /return\s+this\s+exact\s+(json|response|output)/i,
+];
+
+/** Unicode categories that can hide or disguise content. */
+const UNICODE_PATTERNS = [
+  /[\u200B-\u200F]/,   // zero-width spaces, LTR/RTL marks
+  /[\u202A-\u202E]/,   // bidi embedding/override
+  /[\u2066-\u2069]/,   // bidi isolate
+  /[\uFEFF]/,          // BOM mid-text
+  /[\u00AD]{3,}/,      // repeated soft hyphens
+  /[\u2060-\u2064]/,   // invisible operators
+  /[\u{E0000}-\u{E007F}]/u, // tag characters
+];
+
+/** Maximum comment block size (chars) before flagging. */
+const MAX_COMMENT_BLOCK = 2000;
+
+/**
+ * Comment block patterns for common languages.
+ * Each regex captures the full block content.
+ */
+const COMMENT_BLOCK_RE = [
+  /\/\*[\s\S]{0,20000}?\*\//g,        // C-style /* ... */
+  /<!--[\s\S]{0,20000}?-->/g,         // HTML <!-- ... -->
+  /"""\s*[\s\S]{0,20000}?\s*"""/g,    // Python docstrings
+  /'''\s*[\s\S]{0,20000}?\s*'''/g,    // Python docstrings (single)
+  /=begin[\s\S]{0,20000}?=end/g,      // Ruby block comments
+];
+
+/**
+ * @typedef {Object} InjectionFinding
+ * @property {"directive"|"unicode"|"comment_block"} type
+ * @property {string} pattern  - short label of what matched
+ * @property {string} snippet  - excerpt of the offending text (max 120 chars)
+ * @property {number} [line]   - approximate line number (1-based)
+ */
+
+/**
+ * @typedef {Object} GuardResult
+ * @property {boolean} clean        - true if no threats detected
+ * @property {InjectionFinding[]} findings
+ * @property {string} summary       - human-readable one-liner
+ */
+
+/**
+ * Scan a text (diff, PR description, comment) for prompt-injection signals.
+ *
+ * @param {string} text - content to scan
+ * @param {Object} [opts]
+ * @param {number} [opts.maxCommentBlock=2000] - flag comment blocks larger than this
+ * @returns {GuardResult}
+ */
+export function scanForInjection(text, opts = {}) {
+  if (!text || typeof text !== "string") {
+    return { clean: true, findings: [], summary: "Nothing to scan" };
+  }
+
+  const maxBlock = opts.maxCommentBlock ?? MAX_COMMENT_BLOCK;
+  /** @type {InjectionFinding[]} */
+  const findings = [];
+
+  // 1. Directive patterns
+  for (const re of DIRECTIVE_PATTERNS) {
+    const match = re.exec(text);
+    if (match) {
+      findings.push({
+        type: "directive",
+        pattern: re.source.slice(0, 60),
+        snippet: excerpt(text, match.index),
+        line: lineAt(text, match.index),
+      });
+    }
+  }
+
+  // 2. Invisible Unicode
+  for (const re of UNICODE_PATTERNS) {
+    const match = re.exec(text);
+    if (match) {
+      const charCode = match[0].codePointAt(0).toString(16).toUpperCase();
+      findings.push({
+        type: "unicode",
+        pattern: `U+${charCode}`,
+        snippet: excerpt(text, match.index),
+        line: lineAt(text, match.index),
+      });
+    }
+  }
+
+  // 3. Oversized comment blocks
+  for (const re of COMMENT_BLOCK_RE) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      if (m[0].length > maxBlock) {
+        findings.push({
+          type: "comment_block",
+          pattern: `block ${m[0].length} chars (max ${maxBlock})`,
+          snippet: excerpt(text, m.index),
+          line: lineAt(text, m.index),
+        });
+      }
+    }
+  }
+
+  const clean = findings.length === 0;
+  const summary = clean
+    ? "No injection patterns detected"
+    : `${findings.length} potential injection(s): ${[...new Set(findings.map((f) => f.type))].join(", ")}`;
+
+  return { clean, findings, summary };
+}
+
+/**
+ * Scan a git diff, focusing only on added lines (lines starting with +).
+ * Removed lines cannot inject into the AI prompt.
+ *
+ * @param {string} diff - unified diff content
+ * @param {Object} [opts]
+ * @returns {GuardResult}
+ */
+export function scanDiff(diff, opts = {}) {
+  if (!diff) return { clean: true, findings: [], summary: "Empty diff" };
+
+  // Split diff into per-file chunks to avoid false positives from
+  // concatenated added-lines across unrelated files.
+  const files = diff.split(/^diff --git /m).filter(Boolean);
+
+  const allFindings = [];
+  for (const fileChunk of files) {
+    const addedLines = fileChunk
+      .split("\n")
+      .filter((l) => l.startsWith("+") && !l.startsWith("+++"))
+      .map((l) => l.slice(1))
+      .join("\n");
+
+    if (!addedLines) continue;
+    const result = scanForInjection(addedLines, opts);
+    if (!result.clean) allFindings.push(...result.findings);
+  }
+
+  const clean = allFindings.length === 0;
+  return {
+    clean,
+    findings: allFindings,
+    summary: clean ? "No injection patterns detected" : `${allFindings.length} injection pattern(s) detected across diff`
+  };
+}
+
+// --- Helpers ---
+
+function excerpt(text, index) {
+  const start = Math.max(0, index - 20);
+  const end = Math.min(text.length, index + 100);
+  return text.slice(start, end).replaceAll(/\n/g, "\\n").slice(0, 120);
+}
+
+function lineAt(text, index) {
+  return text.slice(0, index).split("\n").length;
+}