karajan-code 1.2.0

package/scripts/install.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+node scripts/install.js "$@"

package/scripts/postinstall.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * postinstall hook – registers karajan-mcp in Claude Code and Codex
+ * automatically after `npm install`.
+ *
+ * - Non-interactive, silent on success.
+ * - Idempotent: safe to run many times.
+ * - Never fails hard (exits 0 even on error) so `npm install` is not blocked.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = path.resolve(__dirname, "..");
+const REGISTRY_PATH = path.join(os.homedir(), ".karajan", "instances.json");
+
+async function readJson(file) {
+  const raw = await fs.readFile(file, "utf8");
+  return JSON.parse(raw);
+}
+
+async function writeJson(file, obj) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(obj, null, 2)}\n`, "utf8");
+}
+
+function resolveKjHome() {
+  if (process.env.KJ_HOME) return process.env.KJ_HOME;
+  return path.join(ROOT_DIR, ".karajan");
+}
+
+async function resolveKjHomeFromRegistry() {
+  try {
+    const registry = await readJson(REGISTRY_PATH);
+    const names = Object.keys(registry.instances || {});
+    if (names.length > 0) {
+      const first = registry.instances[names.includes("default") ? "default" : names[0]];
+      if (first?.kjHome) return first.kjHome;
+    }
+  } catch {
+    // No registry yet — use default
+  }
+  return resolveKjHome();
+}
+
+async function setupClaudeMcp(kjHome) {
+  const claudeJsonPath = path.join(os.homedir(), ".claude.json");
+  let config = {};
+  try {
+    config = await readJson(claudeJsonPath);
+  } catch {
+    config = {};
+  }
+
+  config.mcpServers = config.mcpServers || {};
+  config.mcpServers["karajan-mcp"] = {
+    type: "stdio",
+    command: "node",
+    args: [path.join(ROOT_DIR, "src", "mcp", "server.js")],
+    cwd: ROOT_DIR,
+    env: { KJ_HOME: kjHome }
+  };
+
+  await writeJson(claudeJsonPath, config);
+}
+
+function upsertCodexMcpBlock(toml, block) {
+  const begin = "# BEGIN karajan-mcp";
+  const end = "# END karajan-mcp";
+  const startIdx = toml.indexOf(begin);
+  const endIdx = toml.indexOf(end);
+  let base = toml;
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    base = `${toml.slice(0, startIdx).trimEnd()}\n\n${toml.slice(endIdx + end.length).trimStart()}`;
+  }
+
+  return `${base.trimEnd()}\n\n${begin}\n${block}\n${end}\n`;
+}
+
+async function setupCodexMcp(kjHome) {
+  const configPath = path.join(os.homedir(), ".codex", "config.toml");
+  let toml = "";
+  try {
+    toml = await fs.readFile(configPath, "utf8");
+  } catch {
+    toml = "";
+  }
+
+  const block = [
+    '[mcp_servers."karajan-mcp"]',
+    'command = "node"',
+    `args = ["${path.join(ROOT_DIR, "src", "mcp", "server.js")}"]`,
+    `cwd = "${ROOT_DIR}"`,
+    '[mcp_servers."karajan-mcp".env]',
+    `KJ_HOME = "${kjHome}"`
+  ].join("\n");
+
+  const updated = upsertCodexMcpBlock(toml, block);
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, updated, "utf8");
+}
+
+async function main() {
+  const kjHome = await resolveKjHomeFromRegistry();
+
+  await setupClaudeMcp(kjHome);
+  await setupCodexMcp(kjHome);
+
+  console.log("karajan-mcp registered in Claude Code and Codex.");
+}
+
+main().catch(() => {
+  // Silent failure — never block npm install
+});

package/scripts/setup-multi-instance.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+INSTALLER="$ROOT_DIR/scripts/install.sh"
+
+if [[ ! -x "$INSTALLER" ]]; then
+  echo "Installer not found: $INSTALLER"
+  exit 1
+fi
+
+echo "Karajan multi-instance setup (personal + pro)"
+echo
+
+read -r -p "Sonar host [http://localhost:9000]: " SONAR_HOST
+SONAR_HOST="${SONAR_HOST:-http://localhost:9000}"
+
+read -r -p "Personal KJ_HOME [$HOME/.karajan-personal]: " PERSONAL_HOME
+PERSONAL_HOME="${PERSONAL_HOME:-$HOME/.karajan-personal}"
+
+read -r -p "Pro KJ_HOME [$HOME/.karajan-pro]: " PRO_HOME
+PRO_HOME="${PRO_HOME:-$HOME/.karajan-pro}"
+
+echo
+read -r -p "Personal Sonar token (KJ_SONAR_TOKEN): " PERSONAL_TOKEN
+read -r -p "Pro Sonar token (KJ_SONAR_TOKEN): " PRO_TOKEN
+
+read -r -p "Coder default [codex]: " CODER
+CODER="${CODER:-codex}"
+
+read -r -p "Reviewer default [claude]: " REVIEWER
+REVIEWER="${REVIEWER:-claude}"
+
+read -r -p "Reviewer fallback [codex]: " REVIEWER_FALLBACK
+REVIEWER_FALLBACK="${REVIEWER_FALLBACK:-codex}"
+
+echo
+echo "Setting up PERSONAL instance..."
+"$INSTALLER" \
+  --non-interactive \
+  --link-global false \
+  --kj-home "$PERSONAL_HOME" \
+  --sonar-host "$SONAR_HOST" \
+  --sonar-token "$PERSONAL_TOKEN" \
+  --coder "$CODER" \
+  --reviewer "$REVIEWER" \
+  --reviewer-fallback "$REVIEWER_FALLBACK" \
+  --setup-mcp-claude false \
+  --setup-mcp-codex false \
+  --run-doctor true
+
+echo
+echo "Setting up PRO instance..."
+"$INSTALLER" \
+  --non-interactive \
+  --link-global false \
+  --kj-home "$PRO_HOME" \
+  --sonar-host "$SONAR_HOST" \
+  --sonar-token "$PRO_TOKEN" \
+  --coder "$CODER" \
+  --reviewer "$REVIEWER" \
+  --reviewer-fallback "$REVIEWER_FALLBACK" \
+  --setup-mcp-claude false \
+  --setup-mcp-codex false \
+  --run-doctor true
+
+CLAUDE_SETTINGS="$HOME/.claude/settings.json"
+CODEX_CONFIG="$HOME/.codex/config.toml"
+SERVER_PATH="$ROOT_DIR/src/mcp/server.js"
+
+mkdir -p "$HOME/.claude" "$HOME/.codex"
+
+if [[ ! -f "$CLAUDE_SETTINGS" ]]; then
+  cat > "$CLAUDE_SETTINGS" <<JSON
+{
+  "mcpServers": {}
+}
+JSON
+fi
+
+node - <<NODE
+const fs = require('fs');
+const p = "$CLAUDE_SETTINGS";
+const serverPath = "$SERVER_PATH";
+const rootDir = "$ROOT_DIR";
+const personalHome = "$PERSONAL_HOME";
+const proHome = "$PRO_HOME";
+const personalToken = "$PERSONAL_TOKEN";
+const proToken = "$PRO_TOKEN";
+let settings = {};
+try { settings = JSON.parse(fs.readFileSync(p, 'utf8')); } catch { settings = {}; }
+settings.mcpServers = settings.mcpServers || {};
+settings.mcpServers['karajan-personal'] = {
+  command: 'node',
+  args: [serverPath],
+  cwd: rootDir,
+  env: { KJ_HOME: personalHome, KJ_SONAR_TOKEN: personalToken }
+};
+settings.mcpServers['karajan-pro'] = {
+  command: 'node',
+  args: [serverPath],
+  cwd: rootDir,
+  env: { KJ_HOME: proHome, KJ_SONAR_TOKEN: proToken }
+};
+fs.writeFileSync(p, JSON.stringify(settings, null, 2) + '\\n');
+NODE
+
+if [[ ! -f "$CODEX_CONFIG" ]]; then
+  touch "$CODEX_CONFIG"
+fi
+
+TMP_CODEX="$(mktemp)"
+cp "$CODEX_CONFIG" "$TMP_CODEX"
+
+sed -i '/# BEGIN karajan-multi/,/# END karajan-multi/d' "$TMP_CODEX"
+cat >> "$TMP_CODEX" <<TOML
+
+# BEGIN karajan-multi
+[mcp_servers."karajan-personal"]
+command = "node"
+args = ["$SERVER_PATH"]
+cwd = "$ROOT_DIR"
+
+[mcp_servers."karajan-personal".env]
+KJ_HOME = "$PERSONAL_HOME"
+KJ_SONAR_TOKEN = "$PERSONAL_TOKEN"
+
+[mcp_servers."karajan-pro"]
+command = "node"
+args = ["$SERVER_PATH"]
+cwd = "$ROOT_DIR"
+
+[mcp_servers."karajan-pro".env]
+KJ_HOME = "$PRO_HOME"
+KJ_SONAR_TOKEN = "$PRO_TOKEN"
+# END karajan-multi
+TOML
+
+mv "$TMP_CODEX" "$CODEX_CONFIG"
+
+echo
+echo "Multi-instance setup completed."
+echo "- Personal KJ_HOME: $PERSONAL_HOME"
+echo "- Pro KJ_HOME: $PRO_HOME"
+echo "- Claude MCP updated: $CLAUDE_SETTINGS"
+echo "- Codex MCP updated: $CODEX_CONFIG"
+echo
+echo "Next steps:"
+echo "1) Restart Claude and Codex."
+echo "2) In each client, use MCP server karajan-personal or karajan-pro."

package/src/activity-log.js

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getSessionRoot } from "./utils/paths.js";
+import { ensureDir } from "./utils/fs.js";
+
+export function createActivityLog(sessionId) {
+  const logPath = path.join(getSessionRoot(), sessionId, "activity.log");
+  let buffer = [];
+  let flushing = false;
+
+  function formatLine(entry) {
+    const ts = entry.timestamp || new Date().toISOString();
+    const lvl = (entry.level || "info").toUpperCase().padEnd(5);
+    const ctx = entry.context
+      ? Object.entries(entry.context)
+          .filter(([, v]) => v !== undefined)
+          .map(([k, v]) => `${k}=${v}`)
+          .join(" ")
+      : "";
+    const ctxStr = ctx ? ` ${ctx}` : "";
+    return `${ts} [${lvl}]${ctxStr} ${entry.message || ""}`;
+  }
+
+  async function flush() {
+    if (flushing || buffer.length === 0) return;
+    flushing = true;
+    const lines = buffer.splice(0);
+    try {
+      await ensureDir(path.dirname(logPath));
+      await fs.appendFile(logPath, lines.join("\n") + "\n", "utf8");
+    } catch {
+      // best-effort: I/O errors do not crash the flow
+    }
+    flushing = false;
+    if (buffer.length > 0) flush();
+  }
+
+  return {
+    write(logEntry) {
+      buffer.push(formatLine(logEntry));
+      flush();
+    },
+    writeEvent(progressEvent) {
+      const entry = {
+        timestamp: progressEvent.timestamp,
+        level: progressEvent.status === "fail" ? "error" : "info",
+        context: {
+          iteration: progressEvent.iteration,
+          stage: progressEvent.stage
+        },
+        message: progressEvent.message || progressEvent.type
+      };
+      this.write(entry);
+    },
+    get path() {
+      return logPath;
+    }
+  };
+}

package/src/agents/aider-agent.js

@@ -0,0 +1,25 @@
+import { BaseAgent } from "./base-agent.js";
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+export class AiderAgent extends BaseAgent {
+  async runTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "coder";
+    const args = ["--yes", "--message", task.prompt];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("aider"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+
+  async reviewTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "reviewer";
+    const args = ["--yes", "--message", task.prompt];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("aider"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/agents/availability.js

@@ -0,0 +1,32 @@
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+const AGENT_META = {
+  codex: { bin: "codex", installUrl: "https://developers.openai.com/codex/cli" },
+  claude: { bin: "claude", installUrl: "https://docs.anthropic.com/en/docs/claude-code" },
+  gemini: { bin: "gemini", installUrl: "https://github.com/google-gemini/gemini-cli" },
+  aider: { bin: "aider", installUrl: "https://aider.chat/docs/install.html" }
+};
+
+export async function assertAgentsAvailable(agentNames = []) {
+  const unique = [...new Set(agentNames.filter(Boolean))];
+  const missing = [];
+
+  for (const name of unique) {
+    const meta = AGENT_META[name];
+    if (!meta) continue;
+    const res = await runCommand(resolveBin(meta.bin), ["--version"]);
+    if (res.exitCode !== 0) {
+      missing.push({ name, ...meta });
+    }
+  }
+
+  if (missing.length === 0) return;
+
+  const lines = ["Missing required AI CLIs for this command:"];
+  for (const m of missing) {
+    lines.push(`- ${m.name}: command '${m.bin}' not found`);
+    lines.push(`  Install: ${m.installUrl}`);
+  }
+  throw new Error(lines.join("\n"));
+}

package/src/agents/base-agent.js

@@ -0,0 +1,27 @@
+export class BaseAgent {
+  constructor(name, config, logger) {
+    this.name = name;
+    this.config = config;
+    this.logger = logger;
+  }
+
+  async runTask(_task) {
+    throw new Error("runTask not implemented");
+  }
+
+  async reviewTask(_task) {
+    throw new Error("reviewTask not implemented");
+  }
+
+  getRoleModel(role) {
+    const roleModel = this.config?.roles?.[role]?.model;
+    if (roleModel) return roleModel;
+    if (role === "reviewer") return this.config?.reviewer_options?.model || null;
+    return this.config?.coder_options?.model || null;
+  }
+
+  isAutoApproveEnabled(role) {
+    if (role === "reviewer") return false;
+    return Boolean(this.config?.coder_options?.auto_approve);
+  }
+}

package/src/agents/claude-agent.js

@@ -0,0 +1,24 @@
+import { BaseAgent } from "./base-agent.js";
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+export class ClaudeAgent extends BaseAgent {
+  async runTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "coder";
+    const args = ["-p", task.prompt];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("claude"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+
+  async reviewTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const args = ["-p", task.prompt, "--output-format", "json"];
+    const model = this.getRoleModel(task.role || "reviewer");
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("claude"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/agents/codex-agent.js

@@ -0,0 +1,27 @@
+import { BaseAgent } from "./base-agent.js";
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+export class CodexAgent extends BaseAgent {
+  async runTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "coder";
+    const args = ["exec"];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    if (this.isAutoApproveEnabled(role)) args.push("--full-auto");
+    args.push(task.prompt);
+    const res = await runCommand(resolveBin("codex"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+
+  async reviewTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const args = ["exec"];
+    const model = this.getRoleModel(task.role || "reviewer");
+    if (model) args.push("--model", model);
+    args.push(task.prompt);
+    const res = await runCommand(resolveBin("codex"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/agents/gemini-agent.js

@@ -0,0 +1,25 @@
+import { BaseAgent } from "./base-agent.js";
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+export class GeminiAgent extends BaseAgent {
+  async runTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "coder";
+    const args = ["-p", task.prompt];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("gemini"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+
+  async reviewTask(task) {
+    const timeout = this.config.session.max_iteration_minutes * 60 * 1000;
+    const role = task.role || "reviewer";
+    const args = ["-p", task.prompt, "--output-format", "json"];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    const res = await runCommand(resolveBin("gemini"), args, { timeout, onOutput: task.onOutput });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/agents/index.js

@@ -0,0 +1,19 @@
+import { ClaudeAgent } from "./claude-agent.js";
+import { CodexAgent } from "./codex-agent.js";
+import { GeminiAgent } from "./gemini-agent.js";
+import { AiderAgent } from "./aider-agent.js";
+
+export function createAgent(agentName, config, logger) {
+  switch (agentName) {
+    case "claude":
+      return new ClaudeAgent(agentName, config, logger);
+    case "codex":
+      return new CodexAgent(agentName, config, logger);
+    case "gemini":
+      return new GeminiAgent(agentName, config, logger);
+    case "aider":
+      return new AiderAgent(agentName, config, logger);
+    default:
+      throw new Error(`Unsupported agent: ${agentName}`);
+  }
+}

package/src/agents/resolve-bin.js

@@ -0,0 +1,60 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execFileSync } from "node:child_process";
+
+const cache = new Map();
+
+const SEARCH_DIRS = [
+  "/opt/node/bin",
+  path.join(os.homedir(), ".npm-global", "bin"),
+  "/usr/local/bin",
+  path.join(os.homedir(), ".local", "bin"),
+];
+
+function getNvmDirs() {
+  const nvmDir = process.env.NVM_DIR || path.join(os.homedir(), ".nvm");
+  const versionsDir = path.join(nvmDir, "versions", "node");
+  try {
+    return readdirSync(versionsDir).map(v => path.join(versionsDir, v, "bin"));
+  } catch {
+    return [];
+  }
+}
+
+export function resolveBin(name) {
+  if (cache.has(name)) return cache.get(name);
+
+  // 1. Try system PATH via `which`
+  try {
+    const resolved = execFileSync("which", [name], {
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (resolved) {
+      cache.set(name, resolved);
+      return resolved;
+    }
+  } catch {
+    /* not in PATH */
+  }
+
+  // 2. Search known directories
+  const dirs = [...SEARCH_DIRS, ...getNvmDirs()];
+  for (const dir of dirs) {
+    const candidate = path.join(dir, name);
+    if (existsSync(candidate)) {
+      cache.set(name, candidate);
+      return candidate;
+    }
+  }
+
+  // 3. Fallback: return name as-is (let execa try PATH)
+  cache.set(name, name);
+  return name;
+}
+
+export function clearBinCache() {
+  cache.clear();
+}