karajan-code 3.11.0 → 3.12.1

package/package.json

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

package/src/cli/register-meta.js

@@ -304,26 +304,11 @@ export function registerMeta(program, { pkgVersion }) {
     .command("update")
     .description("Update karajan-code to the latest version from npm")
     .action(async () => {
-      // Audit follow-up: was execaCommand (shell parsing). Inputs are
-      // constants today, but the project standard since #555 is execa
-      // with arg arrays (no shell). Migrated for consistency.
-      const { execa } = await import("execa");
-      console.log(`Current version: ${pkgVersion}`);
-      console.log("Checking for updates...");
-      try {
-        const { stdout } = await execa("npm", ["view", "karajan-code", "version"]);
-        const latest = stdout.trim();
-        if (latest === pkgVersion) {
-          console.log(`Already on the latest version (${pkgVersion}).`);
-          return;
-        }
-        console.log(`Updating ${pkgVersion} → ${latest}...`);
-        await execa("npm", ["install", "-g", "karajan-code@latest"], { stdio: "inherit" });
-        console.log(`Updated to ${latest}. Restart Claude to pick up the new MCP server.`);
-      } catch (err) {
-        console.error(`Update failed: ${err.message}`);
-        process.exit(1);
-      }
+      // Output-capturing self-update: npm's deprecation/allow-scripts/funding
+      // warnings are hidden on success and only surfaced when the install fails.
+      const { performSelfUpdate } = await import("../utils/update-check.js");
+      const result = await performSelfUpdate({ currentVersion: pkgVersion });
+      if (!result.ok) process.exit(1);
     });
 
   program

package/src/cli/register-pipeline.js

@@ -226,7 +226,7 @@ export function registerPipeline(program, { pkgVersion }) {
 
   program
     .command("install-tools")
-    .description("Install external audit tools (semgrep, osv-scanner, lighthouse, docker, sonar) using the package manager available on your system")
+    .description("Install the tools kj needs (git, agent CLI: claude+codex) plus the external audit tools (semgrep, osv-scanner, lighthouse, docker, sonar) using the package manager available on your system")
     .option("--only <tools>", "Comma-separated subset (e.g. \"semgrep,osv-scanner\"). Bypasses stack-gating.")
     .option("-y, --yes", "Auto-accept all prompts (non-interactive)")
     .option("--dry-run", "Show what would be installed without running anything")

package/src/commands/install-tools.js

@@ -18,7 +18,7 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { checkBinary } from "../utils/agent-detect.js";
-import { getInstallHint, detectPackageManagers, appliesToStack } from "../utils/install-hints.js";
+import { getInstallHint, detectPackageManagers, appliesToStack, gitInstallPlan } from "../utils/install-hints.js";
 import { detectProjectStack } from "../utils/stack-detect.js";
 import { resolveStandalone } from "../utils/binary-sources.js";
 import { downloadBinary, binDir, runInstallCommand } from "../utils/tool-installer.js";
@@ -26,7 +26,17 @@ import { dockerInstallPlan } from "../utils/docker-install.js";
 
 const execFileAsync = promisify(execFile);
 
-const ALL_TOOLS = ["semgrep", "osv-scanner", "lighthouse", "docker", "sonar"];
+// git and the agent CLI lead the list: both are `kj doctor` *required* tools,
+// so a blank machine wants them before the optional audit tools.
+const ALL_TOOLS = ["git", "agent-cli", "semgrep", "osv-scanner", "lighthouse", "docker", "sonar"];
+
+// The default pipeline is coder=claude, reviewer=codex, so `agent-cli` installs
+// exactly those two. gemini stays out of the default: it is a supported
+// reviewer, not a required one. Both ship as global npm packages.
+const AGENT_CLIS = [
+  { bin: "claude", pkg: "@anthropic-ai/claude-code", url: "https://docs.anthropic.com/en/docs/claude-code" },
+  { bin: "codex", pkg: "@openai/codex", url: "https://github.com/openai/codex" },
+];
 
 function parseOnlyList(raw) {
   if (!raw) return null;
@@ -56,11 +66,100 @@ async function isInstalled(tool) {
   // sonar is a Docker container, not a binary. We check it separately
   // by looking at running containers via `docker ps`.
   if (tool === "sonar") return checkSonarRunning();
+  // agent-cli is "installed" only when BOTH default-pipeline CLIs are present;
+  // a partial install (one of two) still routes to handleAgentCli.
+  if (tool === "agent-cli") {
+    const present = await Promise.all(AGENT_CLIS.map(async (c) => (await checkBinary(c.bin)).ok));
+    return present.every(Boolean);
+  }
   if (tool === "lighthouse") return (await checkBinary("lighthouse")).ok;
   if (tool === "docker") return (await checkBinary("docker")).ok;
   return (await checkBinary(tool)).ok;
 }
 
+/**
+ * Agent-CLI handler. Installs whichever of the default-pipeline CLIs
+ * (coder=claude, reviewer=codex) are missing, via global npm. Opt-in with the
+ * exact command shown first. When npm itself is absent we surface the manual
+ * commands + URLs rather than failing silently.
+ */
+async function handleAgentCli({ available, dryRun, yes, logger }) {
+  const missing = [];
+  for (const cli of AGENT_CLIS) {
+    if (!(await checkBinary(cli.bin)).ok) missing.push(cli);
+  }
+  if (missing.length === 0) return { tool: "agent-cli", action: "already-installed" };
+
+  if (!available.npm) {
+    const commands = missing.map((c) => `npm install -g ${c.pkg}`);
+    logger.warn?.(`✗ agent-cli: npm not found — install manually: ${commands.join(" ; ")}`);
+    return { tool: "agent-cli", action: "manual", reason: "npm not available", missing: missing.map((c) => c.bin), commands, manualUrls: missing.map((c) => c.url) };
+  }
+
+  const installed = [];
+  for (const cli of missing) {
+    const command = `npm install -g ${cli.pkg}`;
+    if (dryRun) {
+      logger.info?.(`▸ ${cli.bin}: would run \`${command}\``);
+      installed.push({ bin: cli.bin, action: "dry-run", command });
+      continue;
+    }
+    const proceed = yes || await promptYesNo(`Install ${cli.bin} with: ${command}?`);
+    if (!proceed) {
+      logger.info?.(`⊘ ${cli.bin}: declined`);
+      installed.push({ bin: cli.bin, action: "declined", command });
+      continue;
+    }
+    logger.info?.(`▸ ${cli.bin}: running \`${command}\`...`);
+    const r = await runInstallCommand(command, { interactive: false });
+    if (r.ok) { logger.info?.(`✓ ${cli.bin}: installed`); installed.push({ bin: cli.bin, action: "installed", command }); }
+    else { const err = r.error || `exit ${r.code}`; logger.warn?.(`✗ ${cli.bin}: install failed (${err})`); installed.push({ bin: cli.bin, action: "failed", command, error: err }); }
+  }
+
+  const action = dryRun ? "dry-run"
+    : installed.some((r) => r.action === "failed") ? "failed"
+    : installed.some((r) => r.action === "installed") ? "installed"
+    : "declined";
+  return { tool: "agent-cli", action, installed };
+}
+
+/**
+ * git handler. git installs through the OS package manager; on Linux that
+ * needs root, so those runs go through the interactive (tty-inherited) path
+ * where sudo prompts the user directly — kj never captures the password. The
+ * exact command is shown first and the install is opt-in, defaulting to NO for
+ * the privileged case. When no package manager matches, we surface the manual
+ * download URL instead of failing silently.
+ */
+async function handleGit({ available, dryRun, yes, logger }) {
+  const plan = gitInstallPlan(available);
+  if (!plan.command) {
+    logger.warn?.(`✗ git: no supported package manager here — install manually: ${plan.manualUrl}`);
+    return { tool: "git", action: "manual", reason: "no supported package manager found", manualUrl: plan.manualUrl };
+  }
+  if (dryRun) {
+    logger.info?.(`▸ git: would run \`${plan.command}\` (manager: ${plan.manager}${plan.needsSudo ? ", needs sudo" : ""})`);
+    return { tool: "git", action: "dry-run", command: plan.command, manager: plan.manager };
+  }
+  if (plan.needsSudo) {
+    logger.warn?.("git: this step needs sudo — you'll be prompted for your password on your own terminal (kj never sees it).");
+  }
+  const proceed = yes || await promptYesNo(`Install git with: ${plan.command}?`, !plan.needsSudo);
+  if (!proceed) {
+    logger.info?.("⊘ git: declined");
+    return { tool: "git", action: "declined", command: plan.command };
+  }
+  logger.info?.(`▸ git: running \`${plan.command}\`...`);
+  const r = await runInstallCommand(plan.command, { interactive: plan.needsSudo });
+  if (r.ok) {
+    logger.info?.(`✓ git: installed via ${plan.manager}`);
+    return { tool: "git", action: "installed", manager: plan.manager };
+  }
+  const err = r.error || `exit ${r.code}`;
+  logger.warn?.(`✗ git: install failed (${err})`);
+  return { tool: "git", action: "failed", command: plan.command, error: err };
+}
+
 async function checkSonarRunning() {
   try {
     const { stdout } = await execFileAsync("docker", ["ps", "--format", "{{.Names}}", "--filter", "name=sonarqube"], { timeout: 5000 });
@@ -236,6 +335,18 @@ export async function installToolsCommand(opts = {}) {
       continue;
     }
 
+    if (tool === "git") {
+      const result = await handleGit({ available, dryRun, yes, logger });
+      results.push(result);
+      continue;
+    }
+
+    if (tool === "agent-cli") {
+      const result = await handleAgentCli({ available, dryRun, yes, logger });
+      results.push(result);
+      continue;
+    }
+
     if (tool === "docker") {
       const result = await handleDocker({ available, dryRun, yes, logger });
       results.push(result);

package/src/utils/install-hints.js

@@ -116,8 +116,36 @@ const MANUAL_URLS = {
   "osv-scanner": "https://google.github.io/osv-scanner/installation/",
   lighthouse: "https://github.com/GoogleChrome/lighthouse#using-the-cli",
   docker: "https://docs.docker.com/get-docker/",
+  git: "https://git-scm.com/downloads",
 };
 
+// git is a `kj doctor` *required* tool. Unlike the audit tools it is installed
+// through the OS package manager, and on Linux that needs root — so the plan
+// carries a `needsSudo` flag and the caller runs those through the interactive
+// (tty-inherited) path, where sudo prompts the user directly and kj never sees
+// the password. brew/scoop/choco install at user scope, no sudo.
+const GIT_CANDIDATES = [
+  { manager: "brew", command: "brew install git", needsSudo: false },
+  { manager: "apt", command: "sudo apt-get install -y git", needsSudo: true },
+  { manager: "dnf", command: "sudo dnf install -y git", needsSudo: true },
+  { manager: "choco", command: "choco install git -y", needsSudo: false },
+  { manager: "scoop", command: "scoop install git", needsSudo: false },
+];
+
+/**
+ * Pick a git install plan for the current machine. Returns a manual plan
+ * (command null + URL) when no supported package manager is present.
+ *
+ * @param {Record<PackageManager, boolean>} available
+ * @returns {{ command: string|null, manager: PackageManager|null, needsSudo: boolean, manualUrl: string }}
+ */
+export function gitInstallPlan(available = {}) {
+  for (const { manager, command, needsSudo } of GIT_CANDIDATES) {
+    if (available[manager]) return { command, manager, needsSudo, manualUrl: MANUAL_URLS.git };
+  }
+  return { command: null, manager: null, needsSudo: false, manualUrl: MANUAL_URLS.git };
+}
+
 /**
  * Tools whose hint depends on the project stack. lighthouse is only
  * relevant for frontend projects; suppressing the hint elsewhere keeps

package/src/utils/update-check.js

@@ -103,6 +103,53 @@ export async function printUpdateNotice(currentVersion) {
   }
 }
 
+/**
+ * Run the npm-channel self-update (`kj update`). Captures npm's output instead
+ * of streaming it: a successful update shows only the progress + result line,
+ * so npm's deprecation / allow-scripts / funding noise — build plumbing, not
+ * actionable for whoever runs the command — never reaches the user. On failure
+ * the captured stdout/stderr IS surfaced, so real errors (native build,
+ * permissions) stay diagnosable — never a silent failure.
+ *
+ * @param {Object} opts
+ * @param {string} opts.currentVersion - version of the running kj
+ * @param {(cmd: string, args: string[]) => Promise<{stdout: string, stderr: string}>} [opts.exec] - injectable runner (defaults to execa)
+ * @param {Console} [opts.logger]
+ * @returns {Promise<{ ok: boolean, alreadyLatest?: boolean, latest?: string }>}
+ */
+export async function performSelfUpdate({ currentVersion, exec, logger = console } = {}) {
+  const run = exec || (async (cmd, args) => (await import("execa")).execa(cmd, args));
+  logger.log(`Current version: ${currentVersion}`);
+  logger.log("Checking for updates...");
+
+  let latest;
+  try {
+    const { stdout } = await run("npm", ["view", PACKAGE_NAME, "version"]);
+    latest = stdout.trim();
+  } catch (err) {
+    logger.error(`Update failed: ${err.shortMessage || err.message}`);
+    return { ok: false };
+  }
+
+  if (latest === currentVersion) {
+    logger.log(`Already on the latest version (${currentVersion}).`);
+    return { ok: true, alreadyLatest: true, latest };
+  }
+
+  logger.log(`Updating ${currentVersion} → ${latest}... (this can take a few minutes)`);
+  try {
+    // No stdio:inherit — capture and drop npm's warnings on the success path.
+    await run("npm", ["install", "-g", `${PACKAGE_NAME}@latest`]);
+    logger.log(`Updated to ${latest}. Restart Claude to pick up the new MCP server.`);
+    return { ok: true, latest };
+  } catch (err) {
+    if (err.stdout) logger.error(err.stdout);
+    if (err.stderr) logger.error(err.stderr);
+    logger.error(`Update failed: ${err.shortMessage || err.message}`);
+    return { ok: false };
+  }
+}
+
 /** Simple semver compare: returns >0 if a > b, <0 if a < b, 0 if equal */
 function compareVersions(a, b) {
   const pa = a.split(".").map(Number);