karajan-code 1.7.0 → 1.8.0

package/README.md

@@ -42,6 +42,7 @@ Instead of running one AI agent and manually reviewing its output, `kj` chains a
 - **Interactive checkpoints** — instead of killing long-running tasks, pauses every 5 minutes with a progress report and lets you decide: continue, stop, or adjust the time
 - **Task decomposition** — triage detects when tasks should be split and recommends subtasks; with Planning Game integration, creates linked cards with sequential blocking
 - **Retry with backoff** — automatic recovery from transient API errors (429, 5xx) with exponential backoff and jitter
+- **Pipeline stage tracker** — cumulative progress view during `kj_run` showing which stages are done, running, or pending — both in CLI and via MCP events for real-time host rendering
 - **Planning Game integration** — optionally pair with [Planning Game](https://github.com/AgenteIA-Geniova/planning-game) for agile project management (tasks, sprints, estimation) — like Jira, but open-source and XP-native
 
 > **Best with MCP** — Karajan Code is designed to be used as an MCP server inside your AI agent (Claude, Codex, etc.). The agent sends tasks to `kj_run`, gets real-time progress notifications, and receives structured results — no copy-pasting needed.
@@ -447,7 +448,7 @@ Use `kj roles show <role>` to inspect any template. Create a project override to
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Run 1025+ tests with Vitest
+npm test              # Run 1040+ tests with Vitest
 npm run test:watch    # Watch mode
 npm run validate      # Lint + test
 ```

package/docs/README.es.md

@@ -41,6 +41,7 @@ En lugar de ejecutar un agente de IA y revisar manualmente su output, `kj` encad
 - **Checkpoints interactivos** — en lugar de matar tareas largas, pausa cada 5 minutos con un informe de progreso y te deja decidir: continuar, parar o ajustar el tiempo
 - **Descomposicion de tareas** — triage detecta cuando una tarea debe dividirse y recomienda subtareas; con integracion Planning Game, crea cards vinculadas con bloqueo secuencial
 - **Retry con backoff** — recuperacion automatica ante errores transitorios de API (429, 5xx) con backoff exponencial y jitter
+- **Pipeline stage tracker** — vista de progreso acumulativo durante `kj_run` mostrando que stages estan completadas, en ejecucion o pendientes — tanto en CLI como via eventos MCP para renderizado en tiempo real en el host
 - **Integracion con Planning Game** — combina opcionalmente con [Planning Game](https://github.com/AgenteIA-Geniova/planning-game) para gestion agil de proyectos (tareas, sprints, estimacion) — como Jira, pero open-source y nativo XP
 
 > **Mejor con MCP** — Karajan Code esta disenado para usarse como servidor MCP dentro de tu agente de IA (Claude, Codex, etc.). El agente envia tareas a `kj_run`, recibe notificaciones de progreso en tiempo real, y obtiene resultados estructurados — sin copiar y pegar.
@@ -231,7 +232,7 @@ Usa `kj roles show <rol>` para inspeccionar cualquier template. Crea un override
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Ejecutar 899+ tests con Vitest
+npm test              # Ejecutar 1040+ tests con Vitest
 npm run test:watch    # Modo watch
 npm run validate      # Lint + test
 ```

package/package.json

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

package/src/mcp/progress.js

@@ -21,9 +21,74 @@ export const PROGRESS_STAGES = [
   "solomon:escalate",
   "question",
   "session:end",
-  "dry-run:summary"
+  "dry-run:summary",
+  "pipeline:tracker"
 ];
 
+const PIPELINE_ORDER = [
+  "triage", "researcher", "planner", "coder", "refactorer", "sonar", "reviewer", "tester", "security", "commiter"
+];
+
+export function buildPipelineTracker(config, emitter) {
+  const pipeline = config.pipeline || {};
+
+  const stages = PIPELINE_ORDER
+    .filter(name => {
+      if (name === "coder") return true;
+      if (name === "reviewer") return pipeline.reviewer?.enabled !== false;
+      if (name === "sonar") return pipeline.sonar?.enabled || config.sonarqube?.enabled;
+      return pipeline[name]?.enabled;
+    })
+    .map(name => ({ name, status: "pending", summary: undefined }));
+
+  const findStage = (name) => stages.find(s => s.name === name);
+
+  const emitTracker = () => {
+    emitter.emit("progress", {
+      type: "pipeline:tracker",
+      detail: { stages: stages.map(s => ({ ...s })) }
+    });
+  };
+
+  emitter.on("progress", (event) => {
+    const match = event.type?.match(/^(\w+):(start|end)$/);
+    if (!match) return;
+
+    const [, name, phase] = match;
+    const stage = findStage(name);
+    if (!stage) return;
+
+    if (phase === "start") {
+      stage.status = "running";
+      stage.summary = event.detail?.[name] || stage.summary;
+    } else {
+      stage.status = event.status === "fail" ? "failed" : "done";
+      stage.summary = event.detail?.summary || event.detail?.gateStatus || stage.summary;
+    }
+
+    emitTracker();
+  });
+
+  return { stages };
+}
+
+export function sendTrackerLog(server, stageName, status, summary) {
+  try {
+    server.sendLoggingMessage({
+      level: "info",
+      logger: "karajan",
+      data: {
+        type: "pipeline:tracker",
+        detail: {
+          stages: [{ name: stageName, status, summary: summary || undefined }]
+        }
+      }
+    });
+  } catch {
+    // best-effort
+  }
+}
+
 export function buildProgressHandler(server) {
   return (event) => {
     try {

package/src/mcp/server-handlers.js

@@ -7,7 +7,7 @@ import { EventEmitter } from "node:events";
 import fs from "node:fs/promises";
 import { runKjCommand } from "./run-kj.js";
 import { normalizePlanArgs } from "./tool-arg-normalizers.js";
-import { buildProgressHandler, buildProgressNotifier } from "./progress.js";
+import { buildProgressHandler, buildProgressNotifier, buildPipelineTracker, sendTrackerLog } from "./progress.js";
 import { runFlow, resumeFlow } from "../orchestrator.js";
 import { loadConfig, applyRunOverrides, validateConfig, resolveRole } from "../config.js";
 import { createLogger } from "../utils/logger.js";
@@ -151,6 +151,7 @@ export async function handleRunDirect(a, server, extra) {
   emitter.on("progress", buildProgressHandler(server));
   const progressNotifier = buildProgressNotifier(extra);
   if (progressNotifier) emitter.on("progress", progressNotifier);
+  buildPipelineTracker(config, emitter);
 
   const askQuestion = buildAskQuestion(server);
   const pgTaskId = a.pgTask || null;
@@ -191,12 +192,15 @@ export async function handlePlanDirect(a, server, extra) {
 
   const planner = createAgent(plannerRole.provider, config, logger);
   const prompt = buildPlannerPrompt({ task: a.task, context: a.context });
+  sendTrackerLog(server, "planner", "running", plannerRole.provider);
   const result = await planner.runTask({ prompt, role: "planner" });
 
   if (!result.ok) {
+    sendTrackerLog(server, "planner", "failed");
     throw new Error(result.error || result.output || "Planner failed");
   }
 
+  sendTrackerLog(server, "planner", "done");
   const parsed = parseMaybeJsonString(result.output);
   return { ok: true, plan: parsed || result.output, raw: result.output };
 }
@@ -216,12 +220,15 @@ export async function handleCodeDirect(a, server, extra) {
     } catch { /* no coder rules file */ }
   }
   const prompt = buildCoderPrompt({ task: a.task, coderRules, methodology: config.development?.methodology || "tdd" });
+  sendTrackerLog(server, "coder", "running", coderRole.provider);
   const result = await coder.runTask({ prompt, role: "coder" });
 
   if (!result.ok) {
+    sendTrackerLog(server, "coder", "failed");
     throw new Error(result.error || result.output || `Coder failed (exit ${result.exitCode})`);
   }
 
+  sendTrackerLog(server, "coder", "done");
   return { ok: true, output: result.output, exitCode: result.exitCode };
 }
 
@@ -238,12 +245,15 @@ export async function handleReviewDirect(a, server, extra) {
   const { rules } = await resolveReviewProfile({ mode: config.review_mode, projectDir: process.cwd() });
 
   const prompt = buildReviewerPrompt({ task: a.task, diff, reviewRules: rules, mode: config.review_mode });
+  sendTrackerLog(server, "reviewer", "running", reviewerRole.provider);
   const result = await reviewer.reviewTask({ prompt, role: "reviewer" });
 
   if (!result.ok) {
+    sendTrackerLog(server, "reviewer", "failed");
     throw new Error(result.error || result.output || `Reviewer failed (exit ${result.exitCode})`);
   }
 
+  sendTrackerLog(server, "reviewer", "done");
   const parsed = parseMaybeJsonString(result.output);
   return { ok: true, review: parsed || result.output, raw: result.output };
 }

package/src/utils/display.js

@@ -343,6 +343,26 @@ export function printEvent(event) {
       console.log(`${ANSI.dim}Resume with: kj resume ${event.sessionId} --answer "<response>"${ANSI.reset}`);
       break;
 
+    case "pipeline:tracker": {
+      const trackerStages = event.detail?.stages || [];
+      console.log(`  ${ANSI.dim}\u250c Pipeline${ANSI.reset}`);
+      for (const stage of trackerStages) {
+        let stIcon, stColor;
+        switch (stage.status) {
+          case "done": stIcon = "\u2713"; stColor = ANSI.green; break;
+          case "running": stIcon = "\u25b6"; stColor = ANSI.cyan; break;
+          case "failed": stIcon = "\u2717"; stColor = ANSI.red; break;
+          default: stIcon = "\u00b7"; stColor = ANSI.dim; break;
+        }
+        const suffix = stage.summary
+          ? stage.status === "running" ? ` (${stage.summary})` : ` \u2192 ${stage.summary}`
+          : "";
+        console.log(`  ${ANSI.dim}\u2502${ANSI.reset} ${stColor}${stIcon} ${stage.name}${suffix}${ANSI.reset}`);
+      }
+      console.log(`  ${ANSI.dim}\u2514${ANSI.reset}`);
+      break;
+    }
+
     case "agent:output":
       console.log(`  \u2502 ${ANSI.dim}${event.message}${ANSI.reset}`);
       break;