karajan-code 1.18.0 → 1.20.0

package/package.json

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

package/src/agents/index.js

@@ -2,6 +2,7 @@ import { ClaudeAgent } from "./claude-agent.js";
 import { CodexAgent } from "./codex-agent.js";
 import { GeminiAgent } from "./gemini-agent.js";
 import { AiderAgent } from "./aider-agent.js";
+import { OpenCodeAgent } from "./opencode-agent.js";
 
 const agentRegistry = new Map();
 
@@ -38,3 +39,4 @@ registerAgent("claude", ClaudeAgent, { bin: "claude", installUrl: "https://docs.
 registerAgent("codex", CodexAgent, { bin: "codex", installUrl: "https://developers.openai.com/codex/cli" });
 registerAgent("gemini", GeminiAgent, { bin: "gemini", installUrl: "https://github.com/google-gemini/gemini-cli" });
 registerAgent("aider", AiderAgent, { bin: "aider", installUrl: "https://aider.chat/docs/install.html" });
+registerAgent("opencode", OpenCodeAgent, { bin: "opencode", installUrl: "https://opencode.ai" });

package/src/agents/model-registry.js

@@ -60,3 +60,4 @@ registerModel("gemini", { provider: "google", pricing: { input_per_million: 1.25
 registerModel("gemini/pro", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
 registerModel("gemini/flash", { provider: "google", pricing: { input_per_million: 0.075, output_per_million: 0.3 } });
 registerModel("aider", { provider: "aider", pricing: { input_per_million: 3, output_per_million: 15 } });
+registerModel("opencode", { provider: "opencode", pricing: { input_per_million: 0, output_per_million: 0 } });

package/src/agents/opencode-agent.js

@@ -0,0 +1,33 @@
+import { BaseAgent } from "./base-agent.js";
+import { runCommand } from "../utils/process.js";
+import { resolveBin } from "./resolve-bin.js";
+
+export class OpenCodeAgent extends BaseAgent {
+  async runTask(task) {
+    const role = task.role || "coder";
+    const args = ["run"];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    args.push(task.prompt);
+    const res = await runCommand(resolveBin("opencode"), args, {
+      onOutput: task.onOutput,
+      silenceTimeoutMs: task.silenceTimeoutMs,
+      timeout: task.timeoutMs
+    });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+
+  async reviewTask(task) {
+    const role = task.role || "reviewer";
+    const args = ["run", "--format", "json"];
+    const model = this.getRoleModel(role);
+    if (model) args.push("--model", model);
+    args.push(task.prompt);
+    const res = await runCommand(resolveBin("opencode"), args, {
+      onOutput: task.onOutput,
+      silenceTimeoutMs: task.silenceTimeoutMs,
+      timeout: task.timeoutMs
+    });
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+  }
+}

package/src/cli.js

@@ -18,6 +18,10 @@ import { resumeCommand } from "./commands/resume.js";
 import { sonarCommand, sonarOpenCommand } from "./commands/sonar.js";
 import { rolesCommand } from "./commands/roles.js";
 import { agentsCommand } from "./commands/agents.js";
+import { discoverCommand } from "./commands/discover.js";
+import { triageCommand } from "./commands/triage.js";
+import { researcherCommand } from "./commands/researcher.js";
+import { architectCommand } from "./commands/architect.js";
 
 const PKG_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
 const PKG_VERSION = JSON.parse(readFileSync(PKG_PATH, "utf8")).version;
@@ -191,6 +195,59 @@ program
     });
   });
 
+program
+  .command("discover")
+  .description("Analyze task for gaps, ambiguities and missing info")
+  .argument("<task>")
+  .option("--mode <name>", "Discovery mode: gaps|momtest|wendel|classify|jtbd", "gaps")
+  .option("--discover <name>", "Override discover agent")
+  .option("--discover-model <name>", "Override discover model")
+  .option("--json", "Output raw JSON")
+  .action(async (task, flags) => {
+    await withConfig("discover", flags, async ({ config, logger }) => {
+      await discoverCommand({ task, config, logger, mode: flags.mode, json: flags.json });
+    });
+  });
+
+program
+  .command("triage")
+  .description("Classify task complexity and recommend pipeline roles")
+  .argument("<task>")
+  .option("--triage <name>", "Override triage agent")
+  .option("--triage-model <name>", "Override triage model")
+  .option("--json", "Output raw JSON")
+  .action(async (task, flags) => {
+    await withConfig("triage", flags, async ({ config, logger }) => {
+      await triageCommand({ task, config, logger, json: flags.json });
+    });
+  });
+
+program
+  .command("researcher")
+  .description("Research codebase for a task (files, patterns, constraints)")
+  .argument("<task>")
+  .option("--researcher <name>", "Override researcher agent")
+  .option("--researcher-model <name>", "Override researcher model")
+  .action(async (task, flags) => {
+    await withConfig("researcher", flags, async ({ config, logger }) => {
+      await researcherCommand({ task, config, logger });
+    });
+  });
+
+program
+  .command("architect")
+  .description("Design solution architecture (layers, patterns, contracts)")
+  .argument("<task>")
+  .option("--architect <name>", "Override architect agent")
+  .option("--architect-model <name>", "Override architect model")
+  .option("--context <text>", "Additional context (e.g. researcher output)")
+  .option("--json", "Output raw JSON")
+  .action(async (task, flags) => {
+    await withConfig("architect", flags, async ({ config, logger }) => {
+      await architectCommand({ task, config, logger, context: flags.context, json: flags.json });
+    });
+  });
+
 program
   .command("resume")
   .description("Resume a paused session")

package/src/commands/architect.js

@@ -0,0 +1,90 @@
+import { createAgent } from "../agents/index.js";
+import { assertAgentsAvailable } from "../agents/availability.js";
+import { resolveRole } from "../config.js";
+import { buildArchitectPrompt, parseArchitectOutput } from "../prompts/architect.js";
+
+function formatArchitect(result) {
+  const lines = [];
+  lines.push(`## Architecture Design`);
+  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
+
+  const arch = result.architecture;
+  if (arch) {
+    if (arch.type) lines.push(`**Type:** ${arch.type}`, "");
+
+    if (arch.layers?.length) {
+      lines.push("### Layers");
+      for (const l of arch.layers) {
+        if (typeof l === "string") {
+          lines.push(`- ${l}`);
+        } else {
+          lines.push(`- **${l.name}**: ${l.responsibility || ""}`);
+        }
+      }
+      lines.push("");
+    }
+
+    if (arch.patterns?.length) {
+      lines.push("### Patterns");
+      for (const p of arch.patterns) lines.push(`- ${p}`);
+      lines.push("");
+    }
+
+    if (arch.tradeoffs?.length) {
+      lines.push("### Tradeoffs");
+      for (const t of arch.tradeoffs) {
+        lines.push(`- **${t.decision}**: ${t.rationale || ""}`);
+        if (t.alternatives?.length) lines.push(`  Alternatives: ${t.alternatives.join(", ")}`);
+      }
+      lines.push("");
+    }
+
+    if (arch.apiContracts?.length) {
+      lines.push("### API Contracts");
+      for (const c of arch.apiContracts) {
+        lines.push(`- \`${c.method || "GET"} ${c.endpoint}\``);
+      }
+      lines.push("");
+    }
+  }
+
+  if (result.questions?.length) {
+    lines.push("### Clarification Questions");
+    for (const q of result.questions) {
+      lines.push(`- ${q.question || q}`);
+    }
+    lines.push("");
+  }
+
+  if (result.summary) lines.push(`---\n${result.summary}`);
+  return lines.join("\n");
+}
+
+export async function architectCommand({ task, config, logger, context, json }) {
+  const architectRole = resolveRole(config, "architect");
+  await assertAgentsAvailable([architectRole.provider]);
+  logger.info(`Architect (${architectRole.provider}) starting...`);
+
+  const agent = createAgent(architectRole.provider, config, logger);
+  const prompt = buildArchitectPrompt({ task, researchContext: context });
+  const onOutput = ({ line }) => process.stdout.write(`${line}\n`);
+  const result = await agent.runTask({ prompt, onOutput, role: "architect" });
+
+  if (!result.ok) {
+    throw new Error(result.error || result.output || "Architect failed");
+  }
+
+  const parsed = parseArchitectOutput(result.output);
+
+  if (json) {
+    console.log(JSON.stringify(parsed || result.output, null, 2));
+    return;
+  }
+
+  if (parsed?.verdict) {
+    console.log(formatArchitect(parsed));
+  } else {
+    console.log(result.output);
+  }
+  logger.info("Architect completed.");
+}

package/src/commands/discover.js

@@ -0,0 +1,87 @@
+import { createAgent } from "../agents/index.js";
+import { assertAgentsAvailable } from "../agents/availability.js";
+import { resolveRole } from "../config.js";
+import { buildDiscoverPrompt, parseDiscoverOutput } from "../prompts/discover.js";
+import { parseMaybeJsonString } from "../review/parser.js";
+
+function formatDiscover(result, mode) {
+  const lines = [];
+  lines.push(`## Discovery (${mode})`);
+  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
+
+  if (result.gaps?.length) {
+    lines.push("## Gaps");
+    for (const g of result.gaps) {
+      const sev = g.severity ? ` [${g.severity}]` : "";
+      lines.push(`- ${g.description || g}${sev}`);
+      if (g.suggestedQuestion) lines.push(`  → ${g.suggestedQuestion}`);
+    }
+    lines.push("");
+  }
+
+  if (result.momTestQuestions?.length) {
+    lines.push("## Mom Test Questions");
+    for (const q of result.momTestQuestions) {
+      lines.push(`- ${q.question || q}`);
+      if (q.rationale) lines.push(`  _${q.rationale}_`);
+    }
+    lines.push("");
+  }
+
+  if (result.wendelChecklist?.length) {
+    lines.push("## Wendel Checklist");
+    for (const w of result.wendelChecklist) {
+      const icon = w.status === "pass" ? "✓" : w.status === "fail" ? "✗" : "?";
+      lines.push(`- [${icon}] ${w.condition}: ${w.justification || ""}`);
+    }
+    lines.push("");
+  }
+
+  if (result.classification) {
+    lines.push("## Classification");
+    lines.push(`- Type: ${result.classification.type}`);
+    if (result.classification.adoptionRisk) lines.push(`- Adoption risk: ${result.classification.adoptionRisk}`);
+    if (result.classification.frictionEstimate) lines.push(`- Friction: ${result.classification.frictionEstimate}`);
+    lines.push("");
+  }
+
+  if (result.jtbds?.length) {
+    lines.push("## Jobs-to-be-Done");
+    for (const j of result.jtbds) {
+      lines.push(`- **${j.id || ""}**: ${j.functional || j}`);
+    }
+    lines.push("");
+  }
+
+  if (result.summary) lines.push(`---\n${result.summary}`);
+  return lines.join("\n");
+}
+
+export async function discoverCommand({ task, config, logger, mode, json }) {
+  const discoverRole = resolveRole(config, "discover");
+  await assertAgentsAvailable([discoverRole.provider]);
+  logger.info(`Discover (${discoverRole.provider}) starting — mode: ${mode || "gaps"}...`);
+
+  const agent = createAgent(discoverRole.provider, config, logger);
+  const prompt = buildDiscoverPrompt({ task, mode: mode || "gaps" });
+  const onOutput = ({ line }) => process.stdout.write(`${line}\n`);
+  const result = await agent.runTask({ prompt, onOutput, role: "discover" });
+
+  if (!result.ok) {
+    throw new Error(result.error || result.output || "Discover failed");
+  }
+
+  const parsed = parseDiscoverOutput(result.output);
+
+  if (json) {
+    console.log(JSON.stringify(parsed || result.output, null, 2));
+    return;
+  }
+
+  if (parsed?.verdict) {
+    console.log(formatDiscover(parsed, mode || "gaps"));
+  } else {
+    console.log(result.output);
+  }
+  logger.info("Discover completed.");
+}

package/src/commands/researcher.js

@@ -0,0 +1,40 @@
+import { createAgent } from "../agents/index.js";
+import { assertAgentsAvailable } from "../agents/availability.js";
+import { resolveRole } from "../config.js";
+
+const SUBAGENT_PREAMBLE = [
+  "IMPORTANT: You are running as a Karajan sub-agent.",
+  "Do NOT ask about using Karajan, do NOT mention Karajan, do NOT suggest orchestration.",
+  "Do NOT use any MCP tools. Focus only on researching the codebase."
+].join(" ");
+
+function buildResearchPrompt(task) {
+  return [
+    SUBAGENT_PREAMBLE,
+    "Investigate the codebase for the following task.",
+    "Identify affected files, patterns, constraints, prior decisions, risks, and test coverage.",
+    "Return a single valid JSON object with your findings and nothing else.",
+    '{"affected_files":[string],"patterns":[string],"constraints":[string],"prior_decisions":[string],"risks":[string],"test_coverage":string}',
+    `## Task\n${task}`
+  ].join("\n\n");
+}
+
+export async function researcherCommand({ task, config, logger }) {
+  const researcherRole = resolveRole(config, "researcher");
+  await assertAgentsAvailable([researcherRole.provider]);
+  logger.info(`Researcher (${researcherRole.provider}) starting...`);
+
+  const agent = createAgent(researcherRole.provider, config, logger);
+  const prompt = buildResearchPrompt(task);
+  const onOutput = ({ line }) => process.stdout.write(`${line}\n`);
+  const result = await agent.runTask({ prompt, onOutput, role: "researcher" });
+
+  if (!result.ok) {
+    throw new Error(result.error || result.output || "Researcher failed");
+  }
+
+  if (result.output) {
+    console.log(result.output);
+  }
+  logger.info("Researcher completed.");
+}

package/src/commands/triage.js

@@ -0,0 +1,63 @@
+import { createAgent } from "../agents/index.js";
+import { assertAgentsAvailable } from "../agents/availability.js";
+import { resolveRole } from "../config.js";
+import { buildTriagePrompt } from "../prompts/triage.js";
+import { parseMaybeJsonString } from "../review/parser.js";
+
+function formatTriage(result) {
+  const lines = [];
+  lines.push(`## Triage Result`);
+  lines.push(`- **Level:** ${result.level || "unknown"}`);
+  if (result.taskType) lines.push(`- **Task type:** ${result.taskType}`);
+  if (result.reasoning) lines.push(`- **Reasoning:** ${result.reasoning}`);
+  lines.push("");
+
+  if (result.roles?.length) {
+    lines.push("### Recommended Roles");
+    for (const r of result.roles) {
+      lines.push(`- ${r}`);
+    }
+    lines.push("");
+  }
+
+  if (result.shouldDecompose) {
+    lines.push("### Decomposition Suggested");
+    if (result.subtasks?.length) {
+      for (const s of result.subtasks) {
+        lines.push(`- ${typeof s === "string" ? s : s.title || s}`);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export async function triageCommand({ task, config, logger, json }) {
+  const triageRole = resolveRole(config, "triage");
+  await assertAgentsAvailable([triageRole.provider]);
+  logger.info(`Triage (${triageRole.provider}) starting...`);
+
+  const agent = createAgent(triageRole.provider, config, logger);
+  const prompt = buildTriagePrompt({ task });
+  const onOutput = ({ line }) => process.stdout.write(`${line}\n`);
+  const result = await agent.runTask({ prompt, onOutput, role: "triage" });
+
+  if (!result.ok) {
+    throw new Error(result.error || result.output || "Triage failed");
+  }
+
+  const parsed = parseMaybeJsonString(result.output);
+
+  if (json) {
+    console.log(JSON.stringify(parsed || result.output, null, 2));
+    return;
+  }
+
+  if (parsed?.level) {
+    console.log(formatTriage(parsed));
+  } else {
+    console.log(result.output);
+  }
+  logger.info("Triage completed.");
+}

package/src/utils/agent-detect.js

@@ -5,7 +5,8 @@ const KNOWN_AGENTS = [
   { name: "claude", install: "npm install -g @anthropic-ai/claude-code" },
   { name: "codex", install: "npm install -g @openai/codex" },
   { name: "gemini", install: "npm install -g @anthropic-ai/gemini-code (or check Gemini CLI docs)" },
-  { name: "aider", install: "pip install aider-chat" }
+  { name: "aider", install: "pip install aider-chat" },
+  { name: "opencode", install: "curl -fsSL https://opencode.ai/install | bash (or see https://opencode.ai)" }
 ];
 
 export async function checkBinary(name, versionArg = "--version") {