@karajan-family/code 4.21.0

package/packages/hu-board/src/routes/pipeline.js

@@ -0,0 +1,45 @@
+/**
+ * /api/pipeline/* — routes backing the pipeline observability view
+ * (TSK-0325). Reads the session journal on every request; the UI polls
+ * this endpoint every 1-2 s. No WebSocket, no SSE — polling keeps the
+ * surface minimal and test-friendly.
+ */
+
+import { Router } from "express";
+import { listSessions, readJournal } from "../journal-parser.js";
+
+const router = Router();
+
+/**
+ * GET /api/pipeline/sessions
+ * List every session with a journal directory. Most recent first.
+ */
+router.get("/sessions", (_req, res) => {
+  try {
+    const sessions = listSessions().map((s) => ({
+      id: s.id,
+      mtime: new Date(s.mtimeMs).toISOString(),
+    }));
+    res.json({ sessions });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/**
+ * GET /api/pipeline/sessions/:id
+ * Full parsed journal for a given session.
+ */
+router.get("/sessions/:id", (req, res) => {
+  try {
+    const journal = readJournal(req.params.id);
+    if (!journal.exists) {
+      return res.status(404).json({ error: `session "${req.params.id}" not found` });
+    }
+    res.json(journal);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/packages/hu-board/src/routes/rag.js

@@ -0,0 +1,42 @@
+// KJC-TSK-0445 — RAG retrieval-quality dashboard route.
+// GET /api/rag/stats → snapshot of the local rag.db (counts per kind/project,
+// active embedder, db size, last-index timestamp). Missing DB returns an
+// "uninitialized" payload so the dashboard renders an empty state cleanly.
+import { Router } from "express";
+import { existsSync, statSync } from "node:fs";
+import Database from "better-sqlite3";
+import { dbPath } from "karajan-core/vec-store";
+import { readConfig } from "../config-yaml.js";
+
+const router = Router();
+const DIMS = { ollama: 768, openai: 1536, voyage: 1024, cohere: 1024, mistral: 1024, onnx: 384 };
+
+function embedder() {
+  try {
+    const e = (readConfig()?.rag?.embedder) || {};
+    const provider = e.provider || "ollama";
+    return { provider, model: e.model || null, dim: e.dim || DIMS[provider] || null };
+  } catch { return { provider: "ollama", model: null, dim: 768 }; }
+}
+
+router.get("/stats", (_req, res) => {
+  const path = dbPath();
+  if (!existsSync(path)) return res.json({ ok: true, initialized: false, message: "rag.db not initialized — run `kj rag index <dir>` to start indexing.", embedder: embedder() });
+  try {
+    const db = new Database(path, { readonly: true, fileMustExist: true });
+    // KJC-BUG-0068 — readonly handler cannot run the project_slug migration
+    // (KJC-TSK-0438). Legacy DBs created pre-v2.27 lack the column; detect
+    // and fall back so the dashboard renders instead of crashing with 500.
+    const hasProjectSlug = db.prepare("PRAGMA table_info(chunks)").all().some((c) => c.name === "project_slug");
+    const total_chunks = db.prepare("SELECT COUNT(*) AS n FROM chunks").get().n;
+    const by_kind = db.prepare("SELECT kind, COUNT(*) AS n FROM chunks GROUP BY kind").all();
+    const by_project = hasProjectSlug
+      ? db.prepare("SELECT COALESCE(project_slug, '(no slug)') AS project, COUNT(*) AS n FROM chunks GROUP BY project_slug ORDER BY n DESC LIMIT 20").all()
+      : [];
+    const last_indexed = db.prepare("SELECT MAX(created_at) AS ts FROM chunks").get().ts;
+    db.close();
+    res.json({ ok: true, initialized: true, db_path: path, db_size_bytes: statSync(path).size, total_chunks, by_kind, by_project, last_indexed, embedder: embedder(), schema_legacy: !hasProjectSlug });
+  } catch (err) { res.status(500).json({ ok: false, error: String(err.message || err) }); }
+});
+
+export default router;

package/packages/hu-board/src/routes/wiki.js

@@ -0,0 +1,43 @@
+// KJC-TSK-0508 — HU Board Wiki panel route.
+// POST /api/wiki/query → spawns `qmd query --format json` against the local
+// per-project QMD wiki (registered by `kj init` via KJC-TSK-0506). Returns
+// 503 with installable:true so the front renders an "Install QMD" CTA
+// instead of a generic error when the binary is missing.
+import { Router } from "express";
+import { runCommand } from "karajan-core/process";
+
+const router = Router();
+const QMD_NOT_INSTALLED = /command not found|ENOENT|not recognized as/i;
+
+router.post("/query", async (req, res) => {
+  const raw = req.body?.query;
+  const query = typeof raw === "string" ? raw.trim() : "";
+  if (!query) return res.status(400).json({ ok: false, error: "query is required" });
+  const limit = Math.min(Math.max(parseInt(req.body?.limit, 10) || 10, 1), 50);
+  const collection = req.body?.collection ? String(req.body.collection).trim() : null;
+  const fast = req.body?.fast === true;
+
+  const args = ["query", query, "--format", "json", "-n", String(limit)];
+  if (collection) args.push("-c", collection);
+  if (fast) args.push("--no-rerank");
+
+  try {
+    const out = await runCommand("qmd", args, { timeout: 120_000 });
+    if (out.exitCode === 127 || QMD_NOT_INSTALLED.test(out.stderr || "")) {
+      return res.status(503).json({ ok: false, error: "qmd not installed", installable: true });
+    }
+    if (out.exitCode !== 0) {
+      const msg = (out.stderr || out.stdout || `qmd exit ${out.exitCode}`).trim();
+      return res.status(500).json({ ok: false, error: msg });
+    }
+    let results;
+    try { results = JSON.parse(out.stdout || "[]"); }
+    catch { return res.status(500).json({ ok: false, error: "qmd output is not valid JSON" }); }
+    res.json({ ok: true, results, count: Array.isArray(results) ? results.length : 0 });
+  } catch (err) {
+    if (err?.code === "ENOENT") return res.status(503).json({ ok: false, error: "qmd not installed", installable: true });
+    res.status(500).json({ ok: false, error: err?.message || String(err) });
+  }
+});
+
+export default router;

package/packages/hu-board/src/run-tracker.js

@@ -0,0 +1,121 @@
+/**
+ * Run tracker — registro híbrido (memoria + disco) de procesos kj run.
+ *
+ * KJC-TSK-0396: el botón ⏹ Stop del board combina dos fuentes:
+ *
+ * 1. **Memoria** (`runs` Map) — runs lanzados desde el board vía
+ *    `runPlan` en plan-mutations.js. Bajo coste, sin I/O.
+ *
+ * 2. **Disco** (`~/.karajan/runs/<runId>.json` vía run-registry.js) —
+ *    runs lanzados desde la terminal externa (cualquier `kj run`). El
+ *    CLI escribe el registro al arranque y lo borra al final. Esto da
+ *    bidireccionalidad terminal ↔ board.
+ *
+ * `getActiveRuns(planId)` une las dos fuentes y dedupe por PID. Los
+ * registros con PID muerto se filtran automáticamente y los del disco
+ * se borran como cleanup (responsabilidad de run-registry).
+ */
+
+import { listActiveRuns as fsList } from "karajan-core/run-registry";
+
+const runs = new Map();
+let reaperTimer = null;
+
+/**
+ * Registra un run lanzado desde el board (memoria).
+ *
+ * @param {string} planId
+ * @param {{ pid: number, huIds?: string[]|null }} info
+ */
+export function trackRun(planId, info) {
+  if (!planId || !info?.pid) return;
+  const set = runs.get(planId) || new Set();
+  set.add({ pid: info.pid, huIds: info.huIds || null, startedAt: Date.now() });
+  runs.set(planId, set);
+  ensureReaper();
+}
+
+/**
+ * Devuelve los runs activos para un planId. Une memoria + FS y dedupe
+ * por PID. Filtra PIDs muertos.
+ */
+export function getActiveRuns(planId) {
+  const seen = new Set();
+  const out = [];
+  // Memoria
+  const set = runs.get(planId);
+  if (set) {
+    for (const r of set) {
+      if (isAlive(r.pid)) {
+        seen.add(r.pid);
+        out.push({ pid: r.pid, huIds: r.huIds, startedAt: r.startedAt, source: "board" });
+      } else set.delete(r);
+    }
+    if (set.size === 0) runs.delete(planId);
+  }
+  // Disco
+  for (const entry of fsList({ planId })) {
+    if (seen.has(entry.pid)) continue;
+    seen.add(entry.pid);
+    out.push({
+      pid: entry.pid,
+      huIds: entry.huIds,
+      startedAt: entry.startedAt,
+      source: entry.source || "cli",
+      projectDir: entry.projectDir,
+    });
+  }
+  return out;
+}
+
+/**
+ * Igual que getActiveRuns pero para todos los planes (memoria + FS).
+ */
+export function getAllActiveRuns() {
+  const out = {};
+  // Memoria
+  for (const planId of runs.keys()) {
+    const alive = getActiveRuns(planId);
+    if (alive.length > 0) out[planId] = alive;
+  }
+  // FS — añadir planes que solo viven en disco (no se vieron arriba).
+  for (const entry of fsList()) {
+    if (!entry.planId) continue;
+    if (out[entry.planId]) continue;
+    out[entry.planId] = getActiveRuns(entry.planId);
+  }
+  return out;
+}
+
+/**
+ * Quita el registro de un PID de memoria. Los registros FS los limpia
+ * el propio CLI (vía registry.unregisterRun en su finally).
+ */
+export function untrack(planId, pid) {
+  const set = runs.get(planId);
+  if (!set) return;
+  for (const r of set) {
+    if (r.pid === pid) set.delete(r);
+  }
+  if (set.size === 0) runs.delete(planId);
+}
+
+function isAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; }
+  catch (err) { return err.code === "EPERM"; }
+}
+
+/** Test-only reset. */
+export function _resetForTests() {
+  runs.clear();
+  if (reaperTimer) { clearInterval(reaperTimer); reaperTimer = null; }
+}
+
+function ensureReaper() {
+  if (reaperTimer || process.env.VITEST) return;
+  reaperTimer = setInterval(() => {
+    for (const planId of [...runs.keys()]) getActiveRuns(planId);
+  }, 30_000);
+  reaperTimer.unref?.();
+}