karajan-code 3.12.0 → 3.12.2

package/node_modules/@karajan/core/src/plan-id.js

@@ -1,45 +0,0 @@
-/**
- * Plan + HU ID generation.
- * Globally unique IDs that never collide across plans.
- */
-
-/**
- * Generate a unique plan ID: plan-<YYYYMMDDHHMMSS>-<4-char random>
- */
-export function generatePlanId() {
-  const now = new Date();
-  const ts = now.toISOString().replaceAll(/[-:T]/g, "").replace(/\.\d+Z$/, "");
-  const rand = Math.random().toString(36).slice(2, 6);
-  return `plan-${ts}-${rand}`;
-}
-
-/**
- * Generate a globally unique HU ID scoped to a plan.
- * Format: hu_<planId>_<3-digit sequence>
- * @param {string} planId
- * @param {number} seq - 1-based sequence number
- * @returns {string}
- */
-export function generateHuId(planId, seq) {
-  return `hu_${planId}_${String(seq).padStart(3, "0")}`;
-}
-
-/**
- * Normalise a human-friendly name into a CLI-typeable alias.
- * "Greta App" → "greta-app", "Linux Assistant Orchestrator" → "linux-assistant-orchestrator".
- * Acotado a 60 chars para que no se vuelva tan ilegible como el planId.
- *
- * @param {string|null|undefined} name
- * @returns {string|null} alias o null si name está vacío.
- */
-export function normaliseAlias(name) {
-  if (!name || typeof name !== "string") return null;
-  const slug = name
-    .normalize("NFKD")
-    .replaceAll(/[̀-ͯ]/g, "")        // strip diacritics
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9]+/g, "-")            // non-alphanum → guion
-    .replaceAll(/^-+|-+$/g, "")                // trim guiones extremos
-    .slice(0, 60);
-  return slug || null;
-}

package/node_modules/@karajan/core/src/plan-validation.js

@@ -1,82 +0,0 @@
-// KJC-TSK-0401: validación estructural de cambios en blocked_by desde
-// el board. Se usa antes de persistir un PATCH /api/stories/:id para
-// que el usuario no pueda crear ciclos ni referencias huérfanas. La UI
-// preview la usa para deshabilitar las opciones que romperían el plan.
-
-/**
- * Verifica que `newBlockedBy` para `huId` no rompa la estructura del plan.
- *
- * Reglas:
- *   1. Cada ref en newBlockedBy debe existir como hu.id en el plan.
- *   2. No se permite auto-dependencia (huId ∈ newBlockedBy).
- *   3. Aplicar el cambio NO debe crear un ciclo en el grafo blocked_by.
- *
- * @param {object} plan
- * @param {string} huId
- * @param {string[]} newBlockedBy
- * @returns {{ ok: true } | { ok: false, error: string, cycle?: string[] }}
- */
-export function validateBlockedByChange(plan, huId, newBlockedBy) {
-  if (!plan || !Array.isArray(plan.hus)) {
-    return { ok: false, error: "plan inválido" };
-  }
-  const hu = plan.hus.find((h) => h.id === huId);
-  if (!hu) return { ok: false, error: `HU no encontrada: ${huId}` };
-  if (!Array.isArray(newBlockedBy)) {
-    return { ok: false, error: "blocked_by debe ser un array" };
-  }
-  const ids = new Set(plan.hus.map((h) => h.id));
-  for (const ref of newBlockedBy) {
-    if (typeof ref !== "string") {
-      return { ok: false, error: "blocked_by contiene un valor no-string" };
-    }
-    if (ref === huId) {
-      return { ok: false, error: `auto-dependencia no permitida: ${huId}` };
-    }
-    if (!ids.has(ref)) {
-      return { ok: false, error: `HU referenciada inexistente: ${ref}` };
-    }
-  }
-  // Simular el cambio sobre una copia del grafo y buscar ciclos.
-  const graph = new Map();
-  for (const h of plan.hus) {
-    graph.set(h.id, h.id === huId ? [...newBlockedBy] : (Array.isArray(h.blocked_by) ? [...h.blocked_by] : []));
-  }
-  const cycle = findCycleContaining(graph, huId);
-  if (cycle) {
-    return { ok: false, error: `Ciclo detectado: ${cycle.join(" → ")} → ${cycle[0]}`, cycle };
-  }
-  return { ok: true };
-}
-
-/**
- * DFS desde `start` siguiendo aristas blocked_by. Devuelve el primer
- * ciclo encontrado que pase por `start`, o null. La búsqueda no es
- * exhaustiva — basta con detectar UN ciclo para rechazar el cambio.
- *
- * @param {Map<string,string[]>} graph
- * @param {string} start
- * @returns {string[]|null}
- */
-function findCycleContaining(graph, start) {
-  const onStack = new Set();
-  const visited = new Set();
-  const stack = [];
-  function dfs(node) {
-    if (onStack.has(node)) {
-      const idx = stack.indexOf(node);
-      if (idx >= 0) return stack.slice(idx);
-      return [node];
-    }
-    if (visited.has(node)) return null;
-    onStack.add(node); stack.push(node); visited.add(node);
-    for (const dep of graph.get(node) || []) {
-      if (!graph.has(dep)) continue;
-      const found = dfs(dep);
-      if (found) return found;
-    }
-    stack.pop(); onStack.delete(node);
-    return null;
-  }
-  return dfs(start);
-}

package/node_modules/@karajan/core/src/port-check.js

@@ -1,45 +0,0 @@
-/**
- * TCP port availability helpers.
- *
- * Originally lived in packages/hu-board/src/server.js. Moved here so the
- * doctor/preflight subsystem (src/checks/) and hu-board share a single
- * implementation.
- */
-
-import { createServer } from "node:net";
-
-/**
- * Check whether a TCP port is available to bind on localhost.
- *
- * @param {number} port
- * @returns {Promise<boolean>}
- */
-export function isPortAvailable(port) {
-  return new Promise((resolve) => {
-    const server = createServer();
-    server.once("error", () => resolve(false));
-    server.once("listening", () => {
-      server.close();
-      resolve(true);
-    });
-    server.listen(port);
-  });
-}
-
-/**
- * Find the first available port starting from `startPort`.
- *
- * @param {number} startPort       - first port to try
- * @param {number} [maxAttempts=11] - how many consecutive ports to probe
- * @param {(port: number) => void} [onBusy] - called for each busy port seen
- * @returns {Promise<number>}      - resolves with the first free port found
- * @throws {Error} if no port is free within the range
- */
-export async function findAvailablePort(startPort, maxAttempts = 11, onBusy) {
-  for (let i = 0; i < maxAttempts; i++) {
-    const port = startPort + i;
-    if (await isPortAvailable(port)) return port;
-    if (onBusy) onBusy(port);
-  }
-  throw new Error(`No available port found between ${startPort} and ${startPort + maxAttempts - 1}`);
-}

package/node_modules/@karajan/core/src/pricing/index.js

@@ -1,64 +0,0 @@
-/**
- * Model pricing registry (Cost A — KJC-TSK-0512).
- *
- * Static $-per-1M-tokens lookup. The cost-aggregator (Cost B) turns
- * `{tokens_in, tokens_out, model}` events from the orchestrator into
- * USD without calling external pricing APIs at runtime.
- *
- * Unknown models return `null` — the aggregator records the run as
- * `cost: "unknown"` instead of throwing, so a brand-new model id
- * never blocks a kj run.
- */
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REGISTRY_PATH = join(__dirname, "model-pricing.json");
-
-let _cached = null;
-
-function loadRegistry() {
-  if (_cached) return _cached;
-  const raw = readFileSync(REGISTRY_PATH, "utf8");
-  _cached = JSON.parse(raw);
-  return _cached;
-}
-
-/**
- * Look up pricing for a model id.
- *
- * @param {string} modelId — e.g. "claude-opus-4-7", "gpt-4o".
- * @returns {{inputPerMTok:number, outputPerMTok:number, currency:string, source:string, updatedAt:string} | null}
- */
-export function getModelPricing(modelId) {
-  if (typeof modelId !== "string" || modelId.length === 0) return null;
-  const reg = loadRegistry();
-  const entry = reg[modelId];
-  if (!entry || modelId.startsWith("_")) return null;
-  return {
-    inputPerMTok: entry.inputPerMTok,
-    outputPerMTok: entry.outputPerMTok,
-    currency: reg._meta.currency,
-    source: entry.source,
-    updatedAt: reg._meta.updatedAt,
-  };
-}
-
-/**
- * List every known model id (no metadata). Useful for diagnostics
- * and future `kj doctor` checks.
- */
-export function listKnownModels() {
-  const reg = loadRegistry();
-  return Object.keys(reg).filter((k) => !k.startsWith("_"));
-}
-
-/**
- * Reset the in-memory cache. Tests use this to re-read the JSON
- * after mutating it; production code never needs to call it.
- */
-export function _resetCache() {
-  _cached = null;
-}

package/node_modules/@karajan/core/src/pricing/model-pricing.json

@@ -1,28 +0,0 @@
-{
-  "_meta": {
-    "currency": "USD",
-    "unit": "per 1M tokens",
-    "updatedAt": "2026-06-07",
-    "sources": {
-      "anthropic": "https://www.anthropic.com/pricing",
-      "openai": "https://openai.com/api/pricing/",
-      "google": "https://ai.google.dev/pricing"
-    },
-    "notes": "Static registry. Cache-write/cache-read tiers ignored on purpose: aggregator uses input/output averages. Unknown models return null so the pipeline does not break."
-  },
-  "claude-opus-4-7": { "inputPerMTok": 15.00, "outputPerMTok": 75.00, "source": "anthropic" },
-  "claude-opus-4-6": { "inputPerMTok": 15.00, "outputPerMTok": 75.00, "source": "anthropic" },
-  "claude-sonnet-4-6": { "inputPerMTok": 3.00, "outputPerMTok": 15.00, "source": "anthropic" },
-  "claude-haiku-4-5": { "inputPerMTok": 1.00, "outputPerMTok": 5.00, "source": "anthropic" },
-  "claude-haiku-4-5-20251001": { "inputPerMTok": 1.00, "outputPerMTok": 5.00, "source": "anthropic" },
-  "gpt-4o": { "inputPerMTok": 2.50, "outputPerMTok": 10.00, "source": "openai" },
-  "gpt-4o-mini": { "inputPerMTok": 0.15, "outputPerMTok": 0.60, "source": "openai" },
-  "gpt-4.1": { "inputPerMTok": 2.00, "outputPerMTok": 8.00, "source": "openai" },
-  "gpt-4.1-mini": { "inputPerMTok": 0.40, "outputPerMTok": 1.60, "source": "openai" },
-  "o1": { "inputPerMTok": 15.00, "outputPerMTok": 60.00, "source": "openai" },
-  "o1-mini": { "inputPerMTok": 1.10, "outputPerMTok": 4.40, "source": "openai" },
-  "o3-mini": { "inputPerMTok": 1.10, "outputPerMTok": 4.40, "source": "openai" },
-  "gemini-1.5-pro": { "inputPerMTok": 1.25, "outputPerMTok": 5.00, "source": "google" },
-  "gemini-1.5-flash": { "inputPerMTok": 0.075, "outputPerMTok": 0.30, "source": "google" },
-  "gemini-2.0-flash": { "inputPerMTok": 0.10, "outputPerMTok": 0.40, "source": "google" }
-}

package/node_modules/@karajan/core/src/process.js

@@ -1,188 +0,0 @@
-import { execa } from "execa";
-
-const isWin = process.platform === "win32";
-const KILL_SIGNAL = isWin ? "SIGTERM" : "SIGKILL";
-
-function buildSilenceKilledResult(silenceTimeoutMs, stdout, signal) {
-  return {
-    exitCode: 143,
-    stdout,
-    stderr: `Command killed after ${Number(silenceTimeoutMs)}ms without output`,
-    timedOut: true,
-    signal: signal || KILL_SIGNAL
-  };
-}
-
-function setupOutputStreaming(subprocess, onOutput, partialOutputFlushMs) {
-  const flushMs = Number(partialOutputFlushMs) > 0 ? Number(partialOutputFlushMs) : 2000;
-  const streams = {};
-  const makeHandler = (stream) => {
-    const state = { partial: "", dirty: false };
-    streams[stream] = state;
-    return (chunk) => {
-      state.partial += chunk.toString();
-      const lines = state.partial.split(/\r\n|\n|\r/);
-      state.partial = lines.pop() ?? "";
-      state.dirty = state.partial.length > 0;
-      for (const line of lines) {
-        if (line) onOutput({ stream, line });
-      }
-    };
-  };
-
-  const flushPartials = () => {
-    for (const [stream, state] of Object.entries(streams)) {
-      if (!state.dirty || !state.partial) continue;
-      onOutput({ stream, line: state.partial });
-      state.partial = "";
-      state.dirty = false;
-    }
-  };
-
-  if (subprocess.stdout) subprocess.stdout.on("data", makeHandler("stdout"));
-  if (subprocess.stderr) subprocess.stderr.on("data", makeHandler("stderr"));
-  const flushInterval = setInterval(flushPartials, flushMs);
-  flushInterval.unref?.();
-
-  subprocess.finally(() => {
-    flushPartials();
-    clearInterval(flushInterval);
-  });
-}
-
-async function awaitWithTimeout(subprocess, timeout, getStdout) {
-  let timer = null;
-  const timeoutResult = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      try {
-        subprocess.kill(KILL_SIGNAL, { forceKillAfterDelay: 1000 });
-      } catch {
-        // no-op
-      }
-      resolve({
-        exitCode: 143,
-        stdout: getStdout(),
-        stderr: `Command timed out after ${timeout}ms`,
-        timedOut: true,
-        signal: KILL_SIGNAL
-      });
-    }, timeout);
-  });
-
-  const result = await Promise.race([subprocess, timeoutResult]);
-  if (timer) clearTimeout(timer);
-  return result;
-}
-
-export async function runCommand(command, args = [], options = {}) {
-  const { timeout, onOutput, silenceTimeoutMs, partialOutputFlushMs, ...rest } = options;
-  // Detach stdin unless the caller provides input (e.g. Codex uses input: prompt).
-  // Without this, a subprocess prompting for input hangs forever since there is no TTY.
-  if (!rest.stdin && !rest.input) rest.stdin = "ignore";
-  const subprocess = execa(command, args, { reject: false, ...rest });
-
-  let stdoutAccum = "";
-  let stderrAccum = "";
-  let outputSilenceTimer = null;
-  let silenceTimedOut = false;
-
-  function clearSilenceTimer() {
-    if (outputSilenceTimer) {
-      clearTimeout(outputSilenceTimer);
-      outputSilenceTimer = null;
-    }
-  }
-
-  function armSilenceTimer() {
-    const ms = Number(silenceTimeoutMs);
-    if (!Number.isFinite(ms) || ms <= 0 || silenceTimedOut) return;
-    clearSilenceTimer();
-    outputSilenceTimer = setTimeout(() => {
-      silenceTimedOut = true;
-      try {
-        subprocess.kill(KILL_SIGNAL, { forceKillAfterDelay: 1000 });
-      } catch {
-        // no-op
-      }
-    }, ms);
-  }
-
-  if (subprocess.stdout) {
-    subprocess.stdout.on("data", (chunk) => {
-      stdoutAccum += chunk.toString();
-      armSilenceTimer();
-    });
-  }
-  if (subprocess.stderr) {
-    subprocess.stderr.on("data", (chunk) => {
-      stderrAccum += chunk.toString();
-      armSilenceTimer();
-    });
-  }
-
-  if (onOutput) {
-    setupOutputStreaming(subprocess, onOutput, partialOutputFlushMs);
-  }
-  armSilenceTimer();
-
-  try {
-    const result = timeout
-      ? await awaitWithTimeout(subprocess, timeout, () => stdoutAccum)
-      : await subprocess;
-    clearSilenceTimer();
-    if (silenceTimedOut) return buildSilenceKilledResult(silenceTimeoutMs, stdoutAccum);
-    return enrichResult(result, stdoutAccum, stderrAccum);
-  } catch (error) {
-    clearSilenceTimer();
-    if (silenceTimedOut) return buildSilenceKilledResult(silenceTimeoutMs, error?.stdout || stdoutAccum, error?.signal);
-
-    const details = [error?.shortMessage, error?.originalMessage, error?.stderr, error?.stdout, error?.message]
-      .filter(Boolean)
-      .join("\n");
-
-    return {
-      exitCode: 1,
-      stdout: error?.stdout || stdoutAccum,
-      stderr: details || String(error),
-      signal: error?.signal || null
-    };
-  }
-}
-
-function enrichResult(result, stdoutAccum, _stderrAccum) {
-  if (result.timedOut) return result;
-
-  // execa with reject:false RESOLVES (does not throw) on a spawn
-  // failure — ENOENT (binary not in PATH), EACCES, etc. The result
-  // then carries exitCode null/undefined, an empty stderr, and the
-  // real cause only in `code` / `shortMessage`. Surface it: a missing
-  // agent CLI used to fail with a completely empty error message,
-  // leaving the user with "coder failed" and no idea what to install.
-  if (result.failed && result.exitCode == null && !result.signal) {
-    const reason = result.shortMessage || result.message
-      || `spawn failed${result.code ? ` (${result.code})` : ""}`;
-    return {
-      ...result,
-      exitCode: 1,
-      stdout: result.stdout || stdoutAccum,
-      stderr: result.stderr || reason,
-      spawnError: result.code || true,
-    };
-  }
-
-  const killed = result.killed || !!result.signal;
-  const signal = result.signal || null;
-
-  if (killed && !result.stderr) {
-    return {
-      ...result,
-      stdout: result.stdout || stdoutAccum,
-      stderr: signal
-        ? `Process killed by signal ${signal}`
-        : "Process was killed externally",
-      signal
-    };
-  }
-
-  return result;
-}

package/node_modules/@karajan/core/src/run-registry.js

@@ -1,115 +0,0 @@
-/**
- * Run registry — registro persistente de `kj run` activos.
- *
- * KJC-TSK-0396 (extensión): el HU Board necesita ver runs lanzados desde
- * la terminal externa (no solo los lanzados desde el propio board). Para
- * eso, cada `kj run` escribe su PID + planId + huIds + projectDir a un
- * archivo en `~/.karajan/runs/<runId>.json` al arrancar, y lo borra al
- * terminar (success o crash con cleanup vía finally).
- *
- * El board lee ese directorio en startup + cada vez que sirve el endpoint
- * `/api/runs/:planId/active`, descartando los registros con PID muerto
- * (filtrado con `process.kill(pid, 0)`). Resultado: bidireccionalidad
- * total terminal ↔ board.
- *
- * Compartido entre el CLI (src/commands/run.js) y el board
- * (packages/hu-board/src/run-tracker.js) vía `@karajan/core/run-registry`.
- */
-
-import fs from "node:fs";
-import path from "node:path";
-import { writeJsonAtomicSync } from "./atomic-write.js";
-import { getRunsDir } from "./paths.js";
-
-/**
- * Directorio raíz donde viven los registros de run.
- * Delega en `getRunsDir()` (KJC-TSK-0420) — respeta KARAJAN_HOME,
- * KJ_HOME (con warning de deprecación), VITEST tmp y default.
- */
-export function runsDir() {
-  return getRunsDir();
-}
-
-/**
- * Registra un nuevo run en disco. El runId es derivado del PID + timestamp
- * para ser único por proceso.
- *
- * @param {{ pid: number, planId?: string|null, huIds?: string[]|null, projectDir?: string|null, source?: string }} info
- * @returns {string|null} runId o null si la escritura falló (no bloquea al caller).
- */
-export function registerRun(info = {}) {
-  if (!info?.pid) return null;
-  try {
-    fs.mkdirSync(runsDir(), { recursive: true });
-    // Sufijo random para evitar colisiones cuando 2 runs del mismo PID
-    // se registran en el mismo ms (raro en CLI, posible en tests).
-    const runId = `run-${Date.now()}-${info.pid}-${Math.random().toString(36).slice(2, 8)}`;
-    const filePath = path.join(runsDir(), `${runId}.json`);
-    const entry = {
-      runId,
-      pid: info.pid,
-      planId: info.planId || null,
-      huIds: Array.isArray(info.huIds) ? info.huIds : null,
-      projectDir: info.projectDir || null,
-      source: info.source || "cli",
-      startedAt: new Date().toISOString(),
-    };
-    writeJsonAtomicSync(filePath, entry);
-    return runId;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Borra el registro de un run. Idempotente — silencia ENOENT.
- *
- * @param {string} runId
- */
-export function unregisterRun(runId) {
-  if (!runId) return;
-  try {
-    fs.unlinkSync(path.join(runsDir(), `${runId}.json`));
-  } catch {
-    // Idempotente
-  }
-}
-
-/**
- * Lista todos los runs activos en disco, filtrando los con PID muerto.
- * Los muertos se borran del FS (auto-cleanup defensivo).
- *
- * @param {{ planId?: string }} [filter] - si se pasa planId, devuelve solo los runs de ese plan.
- * @returns {Array<{runId, pid, planId, huIds, projectDir, source, startedAt}>}
- */
-export function listActiveRuns(filter = {}) {
-  const dir = runsDir();
-  if (!fs.existsSync(dir)) return [];
-  const out = [];
-  let files;
-  try { files = fs.readdirSync(dir); } catch { return []; }
-  for (const f of files) {
-    if (!f.endsWith(".json")) continue;
-    const filePath = path.join(dir, f);
-    let entry;
-    try { entry = JSON.parse(fs.readFileSync(filePath, "utf8")); }
-    catch { try { fs.unlinkSync(filePath); } catch { /* swallow */ } continue; }
-    if (!isAlive(entry.pid)) {
-      try { fs.unlinkSync(filePath); } catch { /* swallow */ }
-      continue;
-    }
-    if (filter.planId && entry.planId !== filter.planId) continue;
-    out.push(entry);
-  }
-  return out;
-}
-
-/**
- * Verifica si un PID sigue vivo. `process.kill(pid, 0)` NO envía
- * señal — solo lanza ESRCH si el proceso no existe.
- */
-function isAlive(pid) {
-  if (!pid) return false;
-  try { process.kill(pid, 0); return true; }
-  catch (err) { return err.code === "EPERM"; }
-}

package/node_modules/@karajan/core/src/shared-paths.js

@@ -1,41 +0,0 @@
-/**
- * Team-shared HU Board paths — KJC-PRP-0002 / v2.31.0 PR1.
- *
- * The shared root lives INSIDE the project, not in `~/.karajan/`, so a team
- * can commit it to git (or sync via Drive/SyncThing) and share plans + HU
- * stories without each member regenerating them locally.
- *
- *   <projectDir>/.karajan-shared/
- *     plans/<planId>.json     ← `kj plan share <planId>` copies here
- *     hu-stories/<huId>.md    ← reserved for PR2+ (board reads it)
- *
- * Keep the dir name in lockstep with the HU Board sync layer
- * (`packages/hu-board/src/sync.js`) — diverging the constant breaks the
- * watcher silently. One source of truth lives here.
- */
-
-import path from "node:path";
-
-export const SHARED_DIR_NAME = ".karajan-shared";
-
-export function getSharedRoot(projectDir) {
-  return path.join(projectDir, SHARED_DIR_NAME);
-}
-
-export function getSharedPlansDir(projectDir) {
-  return path.join(getSharedRoot(projectDir), "plans");
-}
-
-export function getSharedHuStoriesDir(projectDir) {
-  return path.join(getSharedRoot(projectDir), "hu-stories");
-}
-
-/**
- * Quick check used by callers that decide whether a plan came from local
- * (`~/.karajan/plans/`) or from the shared dir. The HU Board uses this to
- * stamp a `source` column on each record so the UI can render a 🌐 badge.
- */
-export function isSharedPath(p) {
-  if (!p) return false;
-  return p.split(path.sep).includes(SHARED_DIR_NAME);
-}