karajan-code 2.7.3 → 2.8.0

package/src/commands/plan.js

@@ -1,291 +1,14 @@
-import { createAgent } from "../agents/index.js";
-import { assertAgentsAvailable } from "../agents/availability.js";
-import { resolveRole } from "../config.js";
-import { buildPlannerPrompt } from "../prompts/planner.js";
-import { parseMaybeJsonString } from "../review/parser.js";
-
-// ---- Formatting helpers ----
-
-function formatPlan(plan) {
-  const lines = [];
-  if (plan.approach) lines.push("## Approach", plan.approach, "");
-  if (plan.steps?.length) {
-    lines.push("## Steps");
-    for (let i = 0; i < plan.steps.length; i++) {
-      const step = plan.steps[i];
-      const commit = step.commit ? ` → \`${step.commit}\`` : "";
-      lines.push(`${i + 1}. ${step.description}${commit}`);
-    }
-    lines.push("");
-  }
-  if (plan.risks?.length) {
-    lines.push("## Risks");
-    for (const risk of plan.risks) lines.push(`- ${risk}`);
-    lines.push("");
-  }
-  if (plan.outOfScope?.length) {
-    lines.push("## Out of scope");
-    for (const item of plan.outOfScope) lines.push(`- ${item}`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-function formatHuTable(hus) {
-  if (!hus?.length) return "  (no HUs)";
-  const lines = [];
-  const maxTitle = Math.min(50, Math.max(...hus.map(h => h.title?.length || 0)));
-  lines.push(`  ${"ID".padEnd(30)} ${"Title".padEnd(maxTitle)} ${"Type".padEnd(10)} ${"Status".padEnd(10)} Deps`);
-  lines.push(`  ${"─".repeat(30)} ${"─".repeat(maxTitle)} ${"─".repeat(10)} ${"─".repeat(10)} ${"─".repeat(15)}`);
-  for (const hu of hus) {
-    const title = (hu.title || "").slice(0, maxTitle).padEnd(maxTitle);
-    const deps = (hu.blocked_by || []).join(", ") || "—";
-    lines.push(`  ${hu.id.padEnd(30)} ${title} ${(hu.task_type || "sw").padEnd(10)} ${(hu.status || "?").padEnd(10)} ${deps}`);
-  }
-  return lines.join("\n");
-}
-
-// ---- Subcommand handlers ----
-
-/**
- * kj plan "task" — generate plan + HUs
- */
-export async function planGenerateCommand({ task, config, logger, json, context }) {
-  const { withCliRunLog } = await import("../utils/cli-run-log.js");
-  return withCliRunLog("plan", { projectDir: config?.projectDir, logger }, async ({ runLog }) => {
-    return planGenerateImpl({ task, config, logger, json, context, runLog });
-  });
-}
-
-async function planGenerateImpl({ task, config, logger, json, context, runLog }) {
-  const plannerRole = resolveRole(config, "planner");
-  await assertAgentsAvailable([plannerRole.provider]);
-  runLog.logText(`[planner] provider=${plannerRole.provider}`);
-
-  const planner = createAgent(plannerRole.provider, config, logger);
-  const prompt = buildPlannerPrompt({ task, context });
-  const silenceTimeoutMs = Number(config?.session?.max_agent_silence_minutes) > 0
-    ? Math.round(Number(config.session.max_agent_silence_minutes) * 60 * 1000)
-    : undefined;
-  const timeoutMs = Number(config?.session?.max_planner_minutes) > 0
-    ? Math.round(Number(config.session.max_planner_minutes) * 60 * 1000)
-    : undefined;
-  const result = await planner.runTask({ prompt, role: "planner", silenceTimeoutMs, timeoutMs });
-
-  if (!result.ok) throw new Error(result.error || result.output || "Planner failed");
-
-  const parsed = parseMaybeJsonString(result.output);
-
-  // Create v2 plan with HUs from planner steps
-  const { createPlanV2 } = await import("../plan/plan-schema.js");
-  const { addHu } = await import("../plan/plan-hu-ops.js");
-  const { savePlan } = await import("../plan/plan-store.js");
-  const { deriveProjectName, classifyTaskType } = await import("../hu/auto-generator.js");
-
-  const projectDir = config.projectDir || process.cwd();
-  const plan = createPlanV2(task);
-  plan.name = deriveProjectName(task);
-  plan.approach = parsed?.approach || (typeof parsed === "string" ? parsed : (typeof result.output === "string" ? result.output : null));
-  plan.risks = parsed?.risks || [];
-  plan.outOfScope = parsed?.outOfScope || [];
-
-  // Convert planner steps → HUs
-  const steps = parsed?.steps || [];
-  let prevId = null;
-  for (const step of steps) {
-    const desc = typeof step === "string" ? step : step.description || step.title || JSON.stringify(step);
-    const hu = addHu(plan, {
-      title: desc.slice(0, 80),
-      task_type: classifyTaskType(desc),
-      scope: desc,
-      blocked_by: prevId ? [prevId] : [],
-      acceptance_tests: [
-        "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL"
-      ]
-    });
-    prevId = hu.id;
-  }
-
-  const planId = await savePlan(projectDir, plan);
-
-  runLog.logText(`[planner] finished — hus=${plan.hus.length} plan=${planId}`);
-
-  if (json) {
-    console.log(JSON.stringify(plan, null, 2));
-    return { ok: true };
-  }
-
-  if (parsed?.approach) {
-    console.log(formatPlan(parsed));
-  } else if (plan.approach) {
-    console.log(plan.approach);
-  }
-  console.log(`\n## HUs (${plan.hus.length})`);
-  console.log(formatHuTable(plan.hus));
-  console.log(`\nPlan saved: ${planId} (${plan.hus.length} HUs, status: ${plan.status})`);
-  console.log(`Review:  kj plan show ${planId}`);
-  console.log(`Approve: kj plan ready ${planId}`);
-  console.log(`Execute: kj run --plan ${planId} "${task.slice(0, 40)}..."`);
-  return { ok: true };
-}
-
-/**
- * kj plan list
- */
-export async function planListCommand({ config }) {
-  const { listPlans } = await import("../plan/plan-store.js");
-  const projectDir = config.projectDir || process.cwd();
-  const plans = await listPlans(projectDir);
-
-  if (plans.length === 0) {
-    console.log("No plans found. Create one with: kj plan \"your task\"");
-    return;
-  }
-
-  console.log(`Plans for ${projectDir}:\n`);
-  for (const p of plans) {
-    const husInfo = p.huCount > 0 ? ` (${p.huCount} HUs)` : "";
-    const status = p.status !== "draft" ? ` [${p.status}]` : "";
-    console.log(`  ${p.planId}  ${(p.name || p.task || "").slice(0, 50)}${husInfo}${status}`);
-    console.log(`    Created: ${p.createdAt}`);
-  }
-}
-
-/**
- * kj plan show <planId>
- */
-export async function planShowCommand({ config, planId }) {
-  const { loadPlan } = await import("../plan/plan-store.js");
-  const projectDir = config.projectDir || process.cwd();
-  const plan = await loadPlan(projectDir, planId);
-
-  if (!plan) {
-    console.error(`Plan not found: ${planId}`);
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(`Plan: ${plan.planId}`);
-  console.log(`Task: ${plan.task}`);
-  console.log(`Name: ${plan.name || "—"}`);
-  console.log(`Status: ${plan.status}`);
-  console.log(`Version: ${plan.version}`);
-  console.log(`Created: ${plan.createdAt}`);
-
-  if (plan.approach) {
-    console.log(`\n## Approach\n${plan.approach}`);
-  }
-
-  if (plan.hus?.length > 0) {
-    console.log(`\n## HUs (${plan.hus.length})`);
-    console.log(formatHuTable(plan.hus));
-  } else {
-    console.log("\nNo HUs defined. Add with: kj plan add-hu " + planId);
-  }
-}
-
-/**
- * kj plan ready <planId>
- */
-export async function planReadyCommand({ config, planId }) {
-  const { loadPlan, savePlan } = await import("../plan/plan-store.js");
-  const { certifyAllHus } = await import("../plan/plan-hu-ops.js");
-  const { validatePlan } = await import("../plan/plan-schema.js");
-  const projectDir = config.projectDir || process.cwd();
-
-  const plan = await loadPlan(projectDir, planId);
-  if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
-
-  const validation = validatePlan(plan);
-  if (!validation.valid) {
-    console.error("Plan validation failed:");
-    for (const err of validation.errors) console.error(`  - ${err}`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (plan.hus.length === 0) {
-    console.error("Cannot approve a plan with 0 HUs.");
-    process.exitCode = 1;
-    return;
-  }
-
-  const count = certifyAllHus(plan);
-  await savePlan(projectDir, plan);
-  console.log(`✅ ${count} HUs certified. Plan status: ready`);
-  console.log(`Execute: kj run --plan ${planId} "${(plan.task || "").slice(0, 40)}..."`);
-}
-
-/**
- * kj plan validate <planId>
- */
-export async function planValidateCommand({ config, planId }) {
-  const { loadPlan } = await import("../plan/plan-store.js");
-  const { validatePlan } = await import("../plan/plan-schema.js");
-  const projectDir = config.projectDir || process.cwd();
-
-  const plan = await loadPlan(projectDir, planId);
-  if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
-
-  const result = validatePlan(plan);
-  if (result.valid) {
-    console.log(`✅ Plan ${planId} is valid (${plan.hus.length} HUs, status: ${plan.status})`);
-  } else {
-    console.error(`❌ Plan ${planId} has ${result.errors.length} error(s):`);
-    for (const err of result.errors) console.error(`  - ${err}`);
-    process.exitCode = 1;
-  }
-}
-
-/**
- * kj plan delete <planId>
- */
-export async function planDeleteCommand({ config, planId }) {
-  const { deletePlan } = await import("../plan/plan-store.js");
-  const projectDir = config.projectDir || process.cwd();
-  const ok = await deletePlan(projectDir, planId);
-  console.log(ok ? `Deleted: ${planId}` : `Not found: ${planId}`);
-}
-
-/**
- * kj plan add-hu <planId> --title "..." --type sw --deps hu_xxx
- */
-export async function planAddHuCommand({ config, planId, title, type, deps, scope }) {
-  const { loadPlan, savePlan } = await import("../plan/plan-store.js");
-  const { addHu } = await import("../plan/plan-hu-ops.js");
-  const projectDir = config.projectDir || process.cwd();
-
-  const plan = await loadPlan(projectDir, planId);
-  if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
-
-  const hu = addHu(plan, {
-    title: title || "New HU",
-    task_type: type || "sw",
-    scope: scope || null,
-    blocked_by: deps ? deps.split(",").map(d => d.trim()) : []
-  });
-
-  await savePlan(projectDir, plan);
-  console.log(`Added: ${hu.id} — ${hu.title}`);
-}
-
-/**
- * kj plan remove-hu <planId> <huId>
- */
-export async function planRemoveHuCommand({ config, planId, huId }) {
-  const { loadPlan, savePlan } = await import("../plan/plan-store.js");
-  const { removeHu } = await import("../plan/plan-hu-ops.js");
-  const projectDir = config.projectDir || process.cwd();
-
-  const plan = await loadPlan(projectDir, planId);
-  if (!plan) { console.error(`Plan not found: ${planId}`); process.exitCode = 1; return; }
-
-  const ok = removeHu(plan, huId);
-  if (!ok) { console.error(`HU not found: ${huId}`); process.exitCode = 1; return; }
-
-  await savePlan(projectDir, plan);
-  console.log(`Removed: ${huId}`);
-}
-
-// Keep backward compat — old callers import planCommand
-export const planCommand = planGenerateCommand;
+// Thin shim. The plan command was split into one file per sub-command
+// under `./plan/`. This file remains so existing callers that import
+// `./commands/plan.js` (src/cli.js, tests) keep working without churn.
+export {
+  planGenerateCommand,
+  planListCommand,
+  planShowCommand,
+  planReadyCommand,
+  planValidateCommand,
+  planDeleteCommand,
+  planAddHuCommand,
+  planRemoveHuCommand,
+  planCommand,
+} from "./plan/index.js";

package/src/commands/researcher.js

@@ -1,6 +1,7 @@
 import { createAgent } from "../agents/index.js";
 import { assertAgentsAvailable } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
+import { createCliProgressReporter } from "../utils/cli-progress.js";
 
 const SUBAGENT_PREAMBLE = [
   "IMPORTANT: You are running as a Karajan sub-agent.",
@@ -29,8 +30,12 @@ export async function researcherCommand({ task, config, logger }) {
 
     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" });
+    const progress = createCliProgressReporter({ role: "researcher" });
+    let result;
+    try {
+      result = await agent.runTask({ prompt, onOutput: progress.onOutput, role: "researcher" });
+      progress.finish(result.ok ? "done" : "failed");
+    } catch (err) { progress.finish("failed"); throw err; }
 
     if (!result.ok) {
       throw new Error(result.error || result.output || "Researcher failed");

package/src/commands/resume.js

@@ -4,8 +4,31 @@ import { resumeFlow } from "../orchestrator.js";
 import { createActivityLog } from "../activity-log.js";
 import { printEvent } from "../utils/display/event-handlers.js";
 
-function createCliAskQuestion() {
+function createCliAskQuestion(opts = {}) {
+  const { sessionId = null } = opts;
   return async (question, context) => {
+    // Mirror the run.js logic: route to the board via the file-based
+    // bridge when there's no TTY; otherwise prompt the local terminal.
+    const stdinReadable = process.stdin && process.stdin.readable !== false;
+    const isInteractive = Boolean(process.stdin?.isTTY) && stdinReadable;
+    if (!isInteractive) {
+      const { askThroughBoard } = await import("../utils/board-prompt-bridge.js");
+      console.log(`\n\u2753 ${question}`);
+      if (context?.detail) {
+        console.log(`   Context: ${JSON.stringify(context.detail, null, 2)}`);
+      }
+      console.log(
+        "\n[non-interactive] Routing the prompt to the HU Board.\n"
+        + "  Open http://localhost:4000 \u2014 a modal will appear asking for your answer."
+      );
+      try {
+        return await askThroughBoard({ sessionId, question, context });
+      } catch (err) {
+        console.log(`\n[prompt-bridge] ${err.message} \u2014 stopping the session.`);
+        return null;
+      }
+    }
+
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
       console.log(`\n\u2753 ${question}`);

package/src/commands/review.js

@@ -5,6 +5,7 @@ import { buildReviewerPrompt } from "../prompts/reviewer.js";
 import { resolveRole } from "../config.js";
 import { resolveReviewProfile } from "../review/profiles.js";
 import { withCliRunLog } from "../utils/cli-run-log.js";
+import { createCliProgressReporter } from "../utils/cli-progress.js";
 
 export async function reviewCommand({ task, config, logger, baseRef }) {
   return withCliRunLog("review", { projectDir: config?.projectDir, logger }, async ({ runLog }) => {
@@ -36,8 +37,12 @@ export async function reviewCommand({ task, config, logger, baseRef }) {
   const { rules } = await resolveReviewProfile({ mode: config.review_mode, projectDir: process.cwd() });
 
   const prompt = await buildReviewerPrompt({ task, diff, reviewRules: rules, mode: config.review_mode });
-  const onOutput = ({ line }) => process.stdout.write(`${line}\n`);
-  const result = await reviewer.reviewTask({ prompt, onOutput, role: "reviewer" });
+  const progress = createCliProgressReporter({ role: "reviewer" });
+  let result;
+  try {
+    result = await reviewer.reviewTask({ prompt, onOutput: progress.onOutput, role: "reviewer" });
+    progress.finish(result.ok ? "done" : "failed");
+  } catch (err) { progress.finish("failed"); throw err; }
   if (!result.ok) {
     if (result.error) logger.error(result.error);
     throw new Error(result.error || result.output || `Reviewer failed (exit ${result.exitCode})`);

package/src/commands/run.js

@@ -8,9 +8,39 @@ import { printHeader } from "../utils/display/header.js";
 import { printEvent } from "../utils/display/event-handlers.js";
 import { resolveRole } from "../config.js";
 import { parseCardId } from "../planning-game/adapter.js";
+import { confirmCwd } from "../utils/cwd-confirm.js";
 
-function createCliAskQuestion() {
+function createCliAskQuestion(opts = {}) {
+  const { sessionId = null } = opts;
   return async (question, context) => {
+    // Two paths:
+    //   - Interactive TTY: prompt via readline (the developer's terminal).
+    //   - No TTY (board's \u25b6 Run plan with stdio=ignore, CI, etc.): publish
+    //     the prompt through the file-based bridge so the HU Board can
+    //     surface it as a modal. The runner blocks on the bridge until
+    //     the user answers (or times out / kills the run). Pre-v2.7.5
+    //     this path just bailed; now the question actually gets answered.
+    const stdinReadable = process.stdin && process.stdin.readable !== false;
+    const isInteractive = Boolean(process.stdin?.isTTY) && stdinReadable;
+    if (!isInteractive) {
+      const { askThroughBoard } = await import("../utils/board-prompt-bridge.js");
+      console.log(`\n\u2753 ${question}`);
+      if (context?.detail) {
+        console.log(`   Context: ${JSON.stringify(context.detail, null, 2)}`);
+      }
+      console.log(
+        "\n[non-interactive] Routing the prompt to the HU Board.\n"
+        + "  Open http://localhost:4000 \u2014 a modal will appear asking for your answer.\n"
+        + "  This process is now waiting; closing the board does NOT cancel the run."
+      );
+      try {
+        return await askThroughBoard({ sessionId, question, context });
+      } catch (err) {
+        console.log(`\n[prompt-bridge] ${err.message} \u2014 stopping the session.`);
+        return null;
+      }
+    }
+
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
       console.log(`\n\u2753 ${question}`);
@@ -30,6 +60,27 @@ function createCliAskQuestion() {
 }
 
 export async function runCommandHandler({ task, config, logger, flags }) {
+  // PR-F (cwd confirmation): when launching from an interactive
+  // terminal, surface the working directory so the user can abort if
+  // they typed `kj run` from the wrong place. The user's words:
+  // "todas las que lo lancé desde terminal te garantizo que estaba
+  // en la carpeta del proyecto … aún así preguntar por si acaso".
+  //
+  // Skip the prompt when:
+  //   - --yes / -y is set (CI / scripted runs),
+  //   - --json mode is on (machine-readable output, no TTY assumed),
+  //   - stdin is not a TTY (piped, board-spawned subprocess, MCP).
+  const projectDir = config?.projectDir || process.cwd();
+  const canPrompt = process.stdin.isTTY && process.stdout.isTTY
+    && !flags?.yes && !flags?.json;
+  if (canPrompt) {
+    const ok = await confirmCwd(projectDir);
+    if (!ok) {
+      console.log("Aborted by user.");
+      return { ok: false, aborted: true };
+    }
+  }
+
   // Best-effort session cleanup before starting
   try {
     const { cleanupExpiredSessions } = await import("../session-cleanup.js");

package/src/commands/status.js

@@ -3,7 +3,7 @@
  */
 
 import { readRunLog } from "../utils/run-log.js";
-import { loadMostRecentSession } from "../session-store.js";
+import { loadMostRecentSession } from "../session/store.js";
 import { buildDashboard } from "../utils/status-dashboard.js";
 
 

package/src/commands/sync.js

@@ -0,0 +1,75 @@
+/**
+ * `kj sync` — closed-loop drift detection between code and Canvas/plan.
+ * Issue #540 MVP: detection + report only. No --apply yet.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { listPlans, loadPlan } from "../plan/plan-store.js";
+import { classifyDrift, formatDriftReport } from "../sync/detect-drift.js";
+
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage", ".karajan", ".kj", "tmp", ".cache", ".astro", ".next"]);
+
+function listSourceFiles(rootDir, out = []) {
+  for (const e of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    if (e.name.startsWith(".") && !["src", "tests"].includes(e.name)) continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    const p = path.join(rootDir, e.name);
+    if (e.isDirectory()) {
+      listSourceFiles(p, out);
+    } else if (e.isFile()) {
+      try {
+        const s = fs.statSync(p);
+        out.push({
+          path: path.relative(rootDir, p),
+          mtime: s.mtime,
+        });
+      } catch { /* ignore stat errors */ }
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {object} args
+ * @param {object} args.config
+ * @param {object} args.logger
+ * @param {string} [args.planId] — when set, sync against this plan; else use the latest
+ * @param {boolean} [args.json]
+ */
+export async function syncCommand({ config, logger, planId, json }) {
+  const projectDir = config?.projectDir || process.cwd();
+
+  // Resolve which plan to sync against.
+  let plan;
+  if (planId) {
+    plan = await loadPlan(projectDir, planId);
+    if (!plan) throw new Error(`kj sync: plan not found: ${planId}`);
+  } else {
+    const all = await listPlans(projectDir);
+    if (!all || all.length === 0) {
+      throw new Error("kj sync: no plans found for this project. Generate one with `kj plan generate --task-file SPEC.md` (or `--canvas SPEC.canvas.md` for the structured form).");
+    }
+    // Pick the most recent plan by createdAt.
+    plan = await loadPlan(projectDir, all.sort((a, b) =>
+      new Date(b.createdAt || 0) - new Date(a.createdAt || 0))[0].planId);
+  }
+
+  logger.info(`kj sync: comparing ${projectDir} against plan ${plan.planId}`);
+
+  const files = listSourceFiles(projectDir);
+  const report = classifyDrift(plan, files);
+
+  if (json) {
+    console.log(JSON.stringify({
+      planId: plan.planId,
+      projectDir,
+      ...report,
+    }, null, 2));
+  } else {
+    console.log(formatDriftReport(report, plan));
+  }
+
+  // Exit 0 always — drift is informational, not an error. CI users
+  // can opt-in to "exit non-zero on drift" later via a flag.
+}

package/src/commands/triage.js

@@ -1,6 +1,7 @@
 import { createAgent } from "../agents/index.js";
 import { assertAgentsAvailable } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
+import { createCliProgressReporter } from "../utils/cli-progress.js";
 import { buildTriagePrompt } from "../prompts/triage.js";
 import { parseMaybeJsonString } from "../review/parser.js";
 
@@ -43,8 +44,12 @@ export async function triageCommand({ task, config, logger, json }) {
 
     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" });
+    const progress = createCliProgressReporter({ role: "triage" });
+    let result;
+    try {
+      result = await agent.runTask({ prompt, onOutput: progress.onOutput, role: "triage" });
+      progress.finish(result.ok ? "done" : "failed");
+    } catch (err) { progress.finish("failed"); throw err; }
 
     if (!result.ok) {
       throw new Error(result.error || result.output || "Triage failed");

package/src/commands/undo.js

@@ -1,4 +1,4 @@
-import { loadMostRecentSession } from "../session-store.js";
+import { loadMostRecentSession } from "../session/store.js";
 import { runCommand } from "../utils/process.js";
 
 /**