karajan-code 1.55.0 → 1.56.0

package/package.json

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

package/src/cli.js

@@ -25,6 +25,7 @@ import { architectCommand } from "./commands/architect.js";
 import { auditCommand } from "./commands/audit.js";
 import { boardCommand } from "./commands/board.js";
 import { undoCommand } from "./commands/undo.js";
+import { statusCommand } from "./commands/status.js";
 
 import { printUpdateNotice } from "./utils/update-check.js";
 
@@ -168,6 +169,14 @@ program
     await withConfig("doctor", {}, doctorCommand);
   });
 
+program
+  .command("status")
+  .description("Show pipeline dashboard with HU progress")
+  .option("-n, --lines <n>", "Max log lines to read", "50")
+  .action(async (flags) => {
+    await statusCommand({ lines: Number(flags.lines) });
+  });
+
 program
   .command("report")
   .description("Show latest session report")

package/src/commands/init.js

@@ -12,6 +12,7 @@ import { getInstallCommand } from "../utils/os-detect.js";
 import { detectOsLocale, SUPPORTED_LANGUAGES } from "../utils/locale.js";
 import { detectRtk } from "../utils/rtk-detect.js";
 import { installRtk } from "../utils/rtk-install.js";
+import { detectProjectStack } from "../utils/stack-detect.js";
 
 async function runWizard(config, logger) {
   const agents = await detectAvailableAgents();
@@ -330,6 +331,35 @@ export async function initCommand({ logger, flags = {} }) {
   await ensureCoderRules(coderRulesPath, logger);
   await installSkills(logger, interactive);
 
+  // Auto-detect project stack and preconfigure
+  const stack = await detectProjectStack(process.cwd());
+  if (stack.frameworks.length > 0 || stack.language) {
+    const parts = [];
+    if (stack.frameworks.length > 0) parts.push(stack.frameworks.join(" + "));
+    if (stack.language) parts.push(stack.language);
+    const stackType = stack.isFullstack ? "fullstack" : stack.isFrontend ? "frontend" : stack.isBackend ? "backend" : "unknown";
+    logger.info(`Detected stack: ${parts.join(" / ")} (${stackType})`);
+
+    if (stack.suggestions.impeccable) {
+      config.impeccable = config.impeccable || {};
+      config.impeccable.enabled = true;
+      logger.info("  -> Impeccable design audit enabled (frontend detected)");
+    }
+
+    if (stack.suggestions.skills.length > 0) {
+      logger.info(`  -> Suggested skills: ${stack.suggestions.skills.join(", ")}`);
+    }
+
+    if (stack.language && !configExists) {
+      config.development = config.development || {};
+      config.development.methodology = config.development.methodology || "tdd";
+    }
+
+    await writeConfig(configPath, config);
+  } else {
+    logger.info("No project stack detected — using default configuration.");
+  }
+
   // Check RTK availability — auto-install if missing
   const rtk = await detectRtk();
   if (rtk.available) {

package/src/commands/status.js

@@ -0,0 +1,35 @@
+/**
+ * CLI status command — shows a terminal dashboard of the current pipeline state.
+ */
+
+import { readRunLog } from "../utils/run-log.js";
+import { loadMostRecentSession } from "../session-store.js";
+import { buildDashboard } from "../utils/status-dashboard.js";
+
+/**
+ * Run the `kj status` command: print a human-readable dashboard to stdout.
+ * @param {object} options
+ * @param {number} [options.lines=50] - Max log lines to read.
+ * @param {string} [options.projectDir] - Project directory override.
+ */
+export async function statusCommand({ lines = 50, projectDir } = {}) {
+  const dir = projectDir || process.cwd();
+  const logResult = readRunLog(dir, lines);
+
+  let session = null;
+  try {
+    session = await loadMostRecentSession();
+  } catch { /* no session available */ }
+
+  let stories = [];
+  if (session) {
+    try {
+      const { loadHuBatch } = await import("../hu/store.js");
+      const batch = await loadHuBatch(session.id);
+      if (batch?.stories) stories = batch.stories;
+    } catch { /* no HU batch */ }
+  }
+
+  const dashboard = buildDashboard(session, logResult.lines || [], { stories });
+  console.log(dashboard);
+}

package/src/mcp/handlers/management-handlers.js

@@ -14,6 +14,8 @@ import {
   responseText,
   buildConfig,
 } from "../server-handlers.js";
+import { buildDashboardJson } from "../../utils/status-dashboard.js";
+import { loadMostRecentSession } from "../../session-store.js";
 
 const AGENT_ROLES = new Set(["coder", "reviewer", "tester", "security", "solomon"]);
 
@@ -29,7 +31,26 @@ async function runBootstrapGate(server, a) {
 export async function handleStatus(a, server) {
   const maxLines = a.lines || 50;
   const projectDir = await resolveProjectDir(server, a.projectDir);
-  return readRunLog(projectDir, maxLines);
+  const logResult = readRunLog(projectDir, maxLines);
+
+  // Enrich with dashboard data when possible
+  try {
+    const session = await loadMostRecentSession();
+    const stories = [];
+    if (session) {
+      try {
+        const { loadHuBatch } = await import("../../hu/store.js");
+        const batch = await loadHuBatch(session.id);
+        if (batch?.stories) stories.push(...batch.stories);
+      } catch { /* no HU batch for this session */ }
+    }
+
+    const dashboard = buildDashboardJson(session, logResult.lines || [], { stories });
+    return { ...logResult, dashboard };
+  } catch {
+    // Fallback: return raw log without dashboard
+    return logResult;
+  }
 }
 
 export async function handleAgents(a) {

package/src/utils/stack-detect.js

@@ -0,0 +1,135 @@
+/**
+ * Detects the project technology stack by scanning project files.
+ * Used by `kj init` to auto-configure roles, skills, and settings.
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Frameworks detectable from package.json dependencies.
+ * Maps dependency name -> { name, type } where type is "frontend" | "backend" | "fullstack".
+ */
+const PKG_FRAMEWORKS = {
+  react: { name: "react", type: "frontend" },
+  "react-dom": { name: "react", type: "frontend" },
+  vue: { name: "vue", type: "frontend" },
+  svelte: { name: "svelte", type: "frontend" },
+  "@angular/core": { name: "angular", type: "frontend" },
+  astro: { name: "astro", type: "frontend" },
+  next: { name: "next", type: "fullstack" },
+  nuxt: { name: "nuxt", type: "fullstack" },
+  "solid-js": { name: "solid", type: "frontend" },
+  lit: { name: "lit", type: "frontend" },
+  express: { name: "express", type: "backend" },
+  fastify: { name: "fastify", type: "backend" },
+  "@nestjs/core": { name: "nestjs", type: "backend" },
+  hono: { name: "hono", type: "backend" },
+  koa: { name: "koa", type: "backend" },
+};
+
+/**
+ * Language markers: file presence -> { language, type }.
+ */
+const LANGUAGE_FILE_MARKERS = [
+  { file: "go.mod", language: "go", type: "backend" },
+  { file: "Cargo.toml", language: "rust", type: "backend" },
+  { file: "pom.xml", language: "java", type: "backend" },
+  { file: "build.gradle", language: "java", type: "backend" },
+  { file: "build.gradle.kts", language: "kotlin", type: "backend" },
+  { file: "pyproject.toml", language: "python", type: "backend" },
+  { file: "setup.py", language: "python", type: "backend" },
+  { file: "requirements.txt", language: "python", type: "backend" },
+  { file: "Gemfile", language: "ruby", type: "backend" },
+  { file: "composer.json", language: "php", type: "backend" },
+  { file: "pubspec.yaml", language: "dart", type: "frontend" },
+  { file: "Package.swift", language: "swift", type: "backend" },
+];
+
+/**
+ * Maps framework names to skill names for auto-install suggestions.
+ */
+const FRAMEWORK_TO_SKILL = {
+  react: "react",
+  vue: "vue",
+  svelte: "svelte",
+  angular: "angular",
+  astro: "astro",
+  next: "nextjs",
+  nuxt: "vue",
+  solid: "solid",
+  lit: "lit",
+  express: "express",
+  fastify: "fastify",
+  nestjs: "nestjs",
+};
+
+/**
+ * Detect the project technology stack.
+ * @param {string} projectDir - Absolute path to project root.
+ * @returns {Promise<{frameworks: string[], language: string|null, isFrontend: boolean, isBackend: boolean, isFullstack: boolean, suggestions: {impeccable: boolean, skills: string[]}}>}
+ */
+export async function detectProjectStack(projectDir) {
+  const frameworks = new Set();
+  let language = null;
+  let hasFrontend = false;
+  let hasBackend = false;
+
+  // 1. Scan package.json for known frameworks
+  try {
+    const pkgRaw = await fs.readFile(path.join(projectDir, "package.json"), "utf8");
+    const pkg = JSON.parse(pkgRaw);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (!language) language = "javascript";
+
+    // Check for TypeScript
+    if (allDeps.typescript || allDeps["ts-node"]) {
+      language = "typescript";
+    }
+
+    for (const [dep, info] of Object.entries(PKG_FRAMEWORKS)) {
+      if (allDeps[dep]) {
+        frameworks.add(info.name);
+        if (info.type === "frontend" || info.type === "fullstack") hasFrontend = true;
+        if (info.type === "backend" || info.type === "fullstack") hasBackend = true;
+      }
+    }
+  } catch { /* no package.json or parse error */ }
+
+  // 2. Check language file markers
+  for (const marker of LANGUAGE_FILE_MARKERS) {
+    try {
+      await fs.access(path.join(projectDir, marker.file));
+      if (!language || language === "javascript") {
+        language = marker.language;
+      }
+      if (marker.type === "frontend") hasFrontend = true;
+      if (marker.type === "backend") hasBackend = true;
+    } catch { /* file not found */ }
+  }
+
+  const frameworkList = Array.from(frameworks);
+  const isFullstack = hasFrontend && hasBackend;
+
+  // Build suggestions
+  const skills = [];
+  for (const fw of frameworkList) {
+    const skill = FRAMEWORK_TO_SKILL[fw];
+    if (skill && !skills.includes(skill)) {
+      skills.push(skill);
+    }
+  }
+
+  return {
+    frameworks: frameworkList,
+    language,
+    isFrontend: hasFrontend,
+    isBackend: hasBackend,
+    isFullstack,
+    suggestions: {
+      impeccable: hasFrontend,
+      skills,
+    },
+  };
+}

package/src/utils/status-dashboard.js

@@ -0,0 +1,254 @@
+/**
+ * Status dashboard formatter.
+ * Builds a structured terminal dashboard from session data and run-log lines.
+ */
+
+import { HU_STATUS } from "../hu/store.js";
+
+/**
+ * Status label mapping with visual indicators for terminal output.
+ * @type {Record<string, string>}
+ */
+const STATUS_LABELS = {
+  [HU_STATUS.PENDING]:       "pending",
+  [HU_STATUS.CODING]:        "coding",
+  [HU_STATUS.REVIEWING]:     "reviewing",
+  [HU_STATUS.DONE]:          "done",
+  [HU_STATUS.FAILED]:        "failed",
+  [HU_STATUS.BLOCKED]:       "blocked",
+  [HU_STATUS.CERTIFIED]:     "certified",
+  [HU_STATUS.NEEDS_CONTEXT]: "needs_ctx",
+};
+
+/**
+ * Format a millisecond duration into a human-readable string (e.g. "3m 42s").
+ * @param {number} ms
+ * @returns {string}
+ */
+export function formatDuration(ms) {
+  if (!ms || ms < 0) return "0s";
+  const totalSec = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSec / 3600);
+  const minutes = Math.floor((totalSec % 3600) / 60);
+  const seconds = totalSec % 60;
+
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+  return parts.join(" ");
+}
+
+/**
+ * Parse the current pipeline stage from log lines.
+ * @param {string[]} lines - Raw log lines.
+ * @returns {{ currentStage: string|null, lastEvent: string|null }}
+ */
+export function parseStageFromLog(lines) {
+  let currentStage = null;
+  let lastEvent = null;
+
+  for (const line of lines) {
+    const stageStart = /\[(\w+):start\]/.exec(line);
+    if (stageStart) currentStage = stageStart[1];
+
+    const stageDone = /\[(\w+):done\]|\[(\w+)\] finished/.exec(line);
+    if (stageDone) {
+      const doneName = stageDone[1] || stageDone[2];
+      if (doneName === currentStage) currentStage = "idle";
+    }
+
+    if (line.includes("[standby]") || line.includes("standby")) {
+      currentStage = "standby";
+    }
+
+    if (line.trim()) lastEvent = line.trim();
+  }
+
+  return { currentStage, lastEvent };
+}
+
+/**
+ * Format a single HU line for the dashboard.
+ * @param {object} story - HU story object.
+ * @param {boolean} isCurrent - Whether this is the currently active HU.
+ * @returns {string}
+ */
+function formatHuLine(story, isCurrent) {
+  const id = (story.id || "???").padEnd(12);
+  const rawStatus = story.status || "pending";
+  const label = STATUS_LABELS[rawStatus] || rawStatus;
+  const statusStr = `[${label}]`.padEnd(13);
+  const title = story.title || story.original?.text || "(untitled)";
+  const truncTitle = title.length > 40 ? title.slice(0, 37) + "..." : title;
+
+  let timing = "";
+  if (story.duration_ms) {
+    timing = formatDuration(story.duration_ms);
+  }
+
+  const blockedInfo = story.blocked_by?.length
+    ? ` (needs ${story.blocked_by.join(", ")})`
+    : "";
+
+  const marker = isCurrent ? "  <-- current" : "";
+  const timingStr = timing ? `  ${timing}` : "";
+
+  return `  ${id} ${statusStr} ${truncTitle}${blockedInfo}${timingStr}${marker}`;
+}
+
+/**
+ * Build a terminal dashboard string from session data and log lines.
+ *
+ * @param {object|null} sessionData - Session JSON (from session-store) or null.
+ * @param {string[]} logLines - Raw run-log lines.
+ * @param {object} [options] - Optional overrides.
+ * @param {object[]|null} [options.stories] - HU stories array (from hu batch).
+ * @returns {string}
+ */
+export function buildDashboard(sessionData, logLines, options = {}) {
+  if (!sessionData) {
+    return "No active pipeline";
+  }
+
+  const lines = [];
+  const config = sessionData.config_snapshot || {};
+  const maxIter = config.max_iterations ?? "?";
+  const status = sessionData.status || "unknown";
+
+  // Parse log for current stage info
+  const logInfo = parseStageFromLog(logLines || []);
+
+  // Determine iteration from session or log
+  const iteration = sessionData.reviewer_retry_count != null
+    ? sessionData.reviewer_retry_count + 1
+    : null;
+  const iterFromLog = parseIterationFromLog(logLines || []);
+  const displayIter = iterFromLog || iteration || "?";
+
+  // Pipeline header
+  const statusUpper = status.toUpperCase();
+  lines.push(`Pipeline: ${statusUpper} (iteration ${displayIter}/${maxIter})`);
+
+  // Duration
+  const duration = computeDuration(sessionData);
+  lines.push(`Duration: ${formatDuration(duration)}`);
+
+  // Agent info
+  const coderProvider = config.coder?.provider || config.roles?.coder?.provider || "?";
+  const reviewerProvider = config.reviewer?.provider || config.roles?.reviewer?.provider || "?";
+  lines.push(`Agent: ${coderProvider} (coder) / ${reviewerProvider} (reviewer)`);
+
+  // HU stories section
+  const stories = options.stories || [];
+  if (stories.length > 0) {
+    lines.push("");
+    lines.push("HUs:");
+
+    // Determine which story is currently being worked on
+    const currentStory = stories.find(s =>
+      s.status === HU_STATUS.CODING || s.status === HU_STATUS.REVIEWING
+    );
+
+    for (const story of stories) {
+      const isCurrent = currentStory && story.id === currentStory.id;
+      lines.push(formatHuLine(story, isCurrent));
+    }
+  }
+
+  // Current stage and last event
+  lines.push("");
+  const stage = logInfo.currentStage || "idle";
+  const iterSuffix = displayIter !== "?" ? ` (iteration ${displayIter})` : "";
+  lines.push(`Current stage: ${stage}${iterSuffix}`);
+
+  if (logInfo.lastEvent) {
+    // Truncate last event for display
+    const maxLen = 120;
+    const event = logInfo.lastEvent.length > maxLen
+      ? logInfo.lastEvent.slice(0, maxLen - 3) + "..."
+      : logInfo.lastEvent;
+    lines.push(`Last event: ${event}`);
+  }
+
+  // Errors
+  if (sessionData.deferred_issues?.length) {
+    lines.push("");
+    lines.push(`Deferred issues: ${sessionData.deferred_issues.length}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Build a structured JSON response for MCP consumers.
+ *
+ * @param {object|null} sessionData - Session JSON or null.
+ * @param {string[]} logLines - Raw run-log lines.
+ * @param {object} [options] - Optional overrides.
+ * @param {object[]|null} [options.stories] - HU stories array.
+ * @returns {object}
+ */
+export function buildDashboardJson(sessionData, logLines, options = {}) {
+  if (!sessionData) {
+    return { ok: false, message: "No active pipeline" };
+  }
+
+  const config = sessionData.config_snapshot || {};
+  const logInfo = parseStageFromLog(logLines || []);
+  const iterFromLog = parseIterationFromLog(logLines || []);
+  const iteration = iterFromLog
+    || (sessionData.reviewer_retry_count != null ? sessionData.reviewer_retry_count + 1 : null);
+
+  const stories = (options.stories || []).map(s => ({
+    id: s.id,
+    status: s.status || "pending",
+    title: s.title || s.original?.text || null,
+    blocked_by: s.blocked_by || [],
+    duration_ms: s.duration_ms || null,
+  }));
+
+  return {
+    ok: true,
+    pipeline: {
+      status: sessionData.status || "unknown",
+      iteration: iteration || null,
+      maxIterations: config.max_iterations ?? null,
+      duration_ms: computeDuration(sessionData),
+      coder: config.coder?.provider || config.roles?.coder?.provider || null,
+      reviewer: config.reviewer?.provider || config.roles?.reviewer?.provider || null,
+    },
+    hus: stories,
+    currentStage: logInfo.currentStage || "idle",
+    lastEvent: logInfo.lastEvent || null,
+  };
+}
+
+/**
+ * Parse iteration number from log lines.
+ * @param {string[]} lines
+ * @returns {number|null}
+ */
+function parseIterationFromLog(lines) {
+  let iteration = null;
+  for (const line of lines) {
+    const m = /[Ii]teration\s+(\d+)/.exec(line);
+    if (m) iteration = Number.parseInt(m[1], 10);
+  }
+  return iteration;
+}
+
+/**
+ * Compute pipeline duration in milliseconds from session timestamps.
+ * @param {object} sessionData
+ * @returns {number}
+ */
+function computeDuration(sessionData) {
+  const created = sessionData.created_at;
+  if (!created) return 0;
+  const start = new Date(created).getTime();
+  const now = sessionData.updated_at
+    ? new Date(sessionData.updated_at).getTime()
+    : Date.now();
+  return Math.max(0, now - start);
+}