karajan-code 4.70.4 → 5.0.0

package/src/commands/standby.js

@@ -1,117 +0,0 @@
-// KJC-TSK-0414 PR2: comandos kj standby list / kj resume.
-//
-// `kj resume <sessionId>` valida cooldownUntil y, si llegó la hora, re-spawn
-// el comando original capturado en argv. Si cooldown todavía está en el
-// futuro, muestra countdown y aborta. `kj standby list` solo enumera.
-//
-// Estrategia de resume: cada sessionState persiste su argv original (los
-// argumentos con los que se lanzó el `kj` que hibernó). El resume re-spawn
-// EXACTAMENTE ese mismo comando con env preservado. El run reanuda como si
-// fuera un retry — el state interno (HU pendiente, snapshot_sha, etc.) está
-// en el JSON persistido en disco por TSK-0408 + TSK-0414 PR1.
-
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { loadStandby, listPendingStandby, markStandbyDone, acquireStandbyLock } from "../brain/standby-store.js";
-
-const REPO_KJ_CLI = (() => {
-  try {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    return path.join(here, "..", "cli.js");
-  } catch {
-    return null;
-  }
-})();
-
-function formatCountdown(ms) {
-  if (ms <= 0) return "ahora";
-  const s = Math.round(ms / 1000);
-  const h = Math.floor(s / 3600);
-  const m = Math.floor((s % 3600) / 60);
-  const sec = s % 60;
-  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
-}
-
-export async function standbyListCommand({ json } = {}) {
-  const sessions = listPendingStandby();
-  if (json) {
-    console.log(JSON.stringify(sessions, null, 2));
-    return;
-  }
-  if (sessions.length === 0) {
-    console.log("No hay sesiones hibernadas.");
-    return;
-  }
-  console.log(`Sesiones hibernadas (${sessions.length}):`);
-  const now = Date.now();
-  for (const s of sessions) {
-    const ms = new Date(s.cooldownUntil).getTime() - now;
-    const status = ms <= 0 ? "✓ lista para resume" : `⏳ resume en ${formatCountdown(ms)}`;
-    console.log(`  ${s.sessionId}  · ${s.reason || "?"}  · ${status}`);
-    if (s.planId) {
-      const huSuffix = s.huId ? `, HU: ${s.huId}` : "";
-      console.log(`    plan: ${s.planId}${huSuffix}`);
-    }
-  }
-}
-
-/**
- * Re-spawn el comando original capturado en sessionState.argv.
- * Si cooldownUntil > now y force=false → aborta con mensaje.
- */
-export async function resumeCommand({ sessionId, force } = {}) {
-  if (!sessionId) {
-    console.error("kj resume requiere <sessionId>. Usa `kj standby list` para ver pendientes.");
-    process.exitCode = 1;
-    return;
-  }
-  const state = loadStandby(sessionId);
-  if (!state) {
-    console.error(`Sesión no encontrada: ${sessionId}`);
-    process.exitCode = 1;
-    return;
-  }
-  const cooldownMs = new Date(state.cooldownUntil).getTime() - Date.now();
-  if (cooldownMs > 0 && !force) {
-    console.log(`Sesión ${sessionId} todavía en cooldown ${formatCountdown(cooldownMs)} (hasta ${state.cooldownUntil}).`);
-    console.log("Espera o usa `kj resume <sessionId> --force` (no recomendado — la API seguramente seguirá rechazando).");
-    process.exitCode = 0;
-    return;
-  }
-
-  const lock = acquireStandbyLock(sessionId);
-  if (!lock.acquired) {
-    console.log(`Sesión ${sessionId} ya está siendo reanudada por otro proceso.`);
-    process.exitCode = 0;
-    return;
-  }
-
-  try {
-    if (!Array.isArray(state.argv) || state.argv.length === 0) {
-      console.error(`Sesión ${sessionId} sin argv — no se puede re-spawn. Borra manual y relanza.`);
-      process.exitCode = 1;
-      return;
-    }
-    if (!REPO_KJ_CLI) {
-      console.error("No se pudo localizar cli.js. ¿Karajan instalado correctamente?");
-      process.exitCode = 1;
-      return;
-    }
-    console.log(`Reanudando ${sessionId}: kj ${state.argv.join(" ")}`);
-    const child = spawn(process.execPath, [REPO_KJ_CLI, ...state.argv], {
-      cwd: state.cwd || process.cwd(),
-      env: { ...process.env, ...(state.env || {}), KJ_RESUME_FROM: sessionId },
-      stdio: "inherit",
-    });
-    await new Promise((resolve) => {
-      child.on("exit", (code) => {
-        if (code === 0) markStandbyDone(sessionId);
-        process.exitCode = code ?? 0;
-        resolve();
-      });
-    });
-  } finally {
-    lock.release?.();
-  }
-}

package/src/commands/status.js

@@ -1,36 +0,0 @@
-/**
- * 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/commands/triage.js

@@ -1,78 +0,0 @@
-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";
-import { withBrainRecovery } from "../brain/with-brain-recovery.js";
-
-function formatTriage(result) {
-  const lines = [];
-  lines.push(`## Triage Result`);
-  lines.push(`- **Level:** ${result.level || "unknown"}`);
-  if (result.taskType) lines.push(`- **Task type:** ${result.taskType}`);
-  if (result.reasoning) lines.push(`- **Reasoning:** ${result.reasoning}`);
-  lines.push("");
-
-  if (result.roles?.length) {
-    lines.push("### Recommended Roles");
-    for (const r of result.roles) {
-      lines.push(`- ${r}`);
-    }
-    lines.push("");
-  }
-
-  if (result.shouldDecompose) {
-    lines.push("### Decomposition Suggested");
-    if (result.subtasks?.length) {
-      for (const s of result.subtasks) {
-        lines.push(`- ${typeof s === "string" ? s : s.title || s}`);
-      }
-    }
-    lines.push("");
-  }
-
-  return lines.join("\n");
-}
-
-export async function triageCommand({ task, config, logger, json }) {
-  const { withCliRunLog } = await import("../utils/cli-run-log.js");
-  return withCliRunLog("triage", { projectDir: config?.projectDir, logger }, async ({ runLog }) => {
-    const triageRole = resolveRole(config, "triage");
-    await assertAgentsAvailable([triageRole.provider]);
-    logger.info(`Triage (${triageRole.provider}) starting...`);
-    runLog.logText(`[triage] provider=${triageRole.provider}`);
-
-    const agent = createAgent(triageRole.provider, config, logger);
-    const prompt = buildTriagePrompt({ task });
-    const progress = createCliProgressReporter({ role: "triage" });
-    let result;
-    try {
-      result = await withBrainRecovery({
-        agent, taskArgs: { prompt, onOutput: progress.onOutput, role: "triage" },
-        role: "triage", provider: triageRole.provider, logger,
-      });
-      progress.finish(result.ok ? "done" : (result.action || "failed"));
-    } catch (err) { progress.finish("failed"); throw err; }
-
-    if (!result.ok) {
-      throw new Error(result.error || result.output || "Triage failed");
-    }
-
-    const parsed = parseMaybeJsonString(result.output);
-    if (parsed?.level) runLog.logText(`[triage] level=${parsed.level} roles=${(parsed.roles || []).join(",")}`);
-
-    if (json) {
-      console.log(JSON.stringify(parsed || result.output, null, 2));
-      return { ok: true };
-    }
-
-    if (parsed?.level) {
-      console.log(formatTriage(parsed));
-    } else {
-      console.log(result.output);
-    }
-    logger.info("Triage completed.");
-    return { ok: true };
-  });
-}

package/src/commands/undo.js

@@ -1,62 +0,0 @@
-import { loadMostRecentSession } from "../session/store.js";
-import { runCommand } from "../utils/process.js";
-
-/**
- * Revert the last pipeline run by resetting to the pre-pipeline commit.
- * Default: soft reset (keeps changes staged). With --hard: discards all changes.
- */
-export async function undoCommand({ hard = false, logger } = {}) {
-  const session = await loadMostRecentSession();
-  if (!session) {
-    const msg = "No session to undo. No sessions found in the sessions directory.";
-    if (logger) logger.error(msg);
-    return { ok: false, error: msg };
-  }
-
-  const sha = session.session_start_sha;
-  if (!sha) {
-    const msg = `Session ${session.id} has no session_start_sha. Cannot determine the pre-pipeline commit.`;
-    if (logger) logger.error(msg);
-    return { ok: false, error: msg };
-  }
-
-  // Verify the SHA exists in git history
-  const verifyRes = await runCommand("git", ["cat-file", "-t", sha]);
-  if (verifyRes.exitCode !== 0 || verifyRes.stdout.trim() !== "commit") {
-    const msg = `Commit ${sha} not found in git history. It may have been garbage-collected or belong to a different repository.`;
-    if (logger) logger.error(msg);
-    return { ok: false, error: msg };
-  }
-
-  // Check there are commits after the SHA (HEAD is ahead)
-  const logRes = await runCommand("git", ["log", "--oneline", `${sha}..HEAD`]);
-  if (logRes.exitCode !== 0 || !logRes.stdout.trim()) {
-    const msg = `No commits to undo. HEAD is already at or before ${sha.slice(0, 8)}.`;
-    if (logger) logger.warn(msg);
-    return { ok: false, error: msg };
-  }
-
-  const mode = hard ? "--hard" : "--soft";
-  const resetRes = await runCommand("git", ["reset", mode, sha]);
-  if (resetRes.exitCode !== 0) {
-    const msg = `git reset ${mode} ${sha} failed: ${resetRes.stderr || resetRes.stdout}`;
-    if (logger) logger.error(msg);
-    return { ok: false, error: msg };
-  }
-
-  const shortSha = sha.slice(0, 8);
-  const message = hard
-    ? `Reverted to pre-pipeline state (commit ${shortSha}). All changes discarded.`
-    : `Reverted to pre-pipeline state (commit ${shortSha}). Changes are staged. Use \`git diff --cached\` to review.`;
-
-  if (logger) logger.info(message);
-  console.log(message);
-
-  return {
-    ok: true,
-    message,
-    sessionId: session.id,
-    sha,
-    mode: hard ? "hard" : "soft"
-  };
-}

package/src/domains/domain-loader.js

@@ -1,245 +0,0 @@
-/**
- * Domain Knowledge loader.
- * Scans .karajan/domains/ (project-local) and ~/.karajan/domains/ (user-global)
- * for DOMAIN.md files with YAML frontmatter.
- * Project-local domains override user-global domains by directory name.
- */
-
-import { readdir, readFile, mkdir, writeFile, stat } from "node:fs/promises";
-import { join, isAbsolute } from "node:path";
-import yaml from "js-yaml";
-import { getKarajanHome } from "../utils/paths.js";
-
-const DOMAIN_FILE = "DOMAIN.md";
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-
-/**
- * Parse a DOMAIN.md file into a structured DomainFile object.
- * @param {string} filePath — absolute path to the DOMAIN.md file
- * @returns {Promise<DomainFile|null>} parsed domain or null on error
- *
- * @typedef {Object} DomainSection
- * @property {string} heading — section heading (e.g. "Core Concepts")
- * @property {string} content — section body (markdown)
- *
- * @typedef {Object} DomainFile
- * @property {string} name
- * @property {string} description
- * @property {string[]} tags
- * @property {string} version
- * @property {string} author
- * @property {string} visibility — "private" | "public"
- * @property {Array<{type: string, note?: string}>} sources
- * @property {string} content — full markdown body (after frontmatter)
- * @property {DomainSection[]} sections — parsed markdown sections
- * @property {string} filePath — original file path
- * @property {string} [origin] — "project" | "user" (set by loadDomains)
- */
-export async function parseDomainFile(filePath) {
-  let raw;
-  try {
-    raw = await readFile(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-
-  const match = raw.match(FRONTMATTER_RE);
-  if (!match) return null;
-
-  let meta;
-  try {
-    meta = yaml.load(match[1]);
-  } catch {
-    return null;
-  }
-
-  if (!meta || typeof meta !== "object" || !meta.name) return null;
-
-  const content = match[2].trim();
-  const sections = parseSections(content);
-
-  return {
-    name: meta.name,
-    description: meta.description || "",
-    tags: Array.isArray(meta.tags) ? meta.tags : [],
-    version: meta.version || "0.0.0",
-    author: meta.author || "",
-    visibility: meta.visibility || "private",
-    sources: Array.isArray(meta.sources) ? meta.sources : [],
-    content,
-    sections,
-    filePath
-  };
-}
-
-/**
- * Split markdown content into sections by ## headings.
- * @param {string} content
- * @returns {DomainSection[]}
- */
-function parseSections(content) {
-  const sections = [];
-  const lines = content.split("\n");
-  let current = null;
-
-  for (const line of lines) {
-    const headingMatch = line.match(/^##\s+(.+)/);
-    if (headingMatch) {
-      if (current) {
-        current.content = current.content.trim();
-        sections.push(current);
-      }
-      current = { heading: headingMatch[1].trim(), content: "" };
-    } else if (current) {
-      current.content += line + "\n";
-    }
-  }
-
-  if (current) {
-    current.content = current.content.trim();
-    sections.push(current);
-  }
-
-  return sections;
-}
-
-/**
- * Auto-detect project context files (README.md, CLAUDE.md) as lightweight domains.
- * Used as fallback when no explicit .karajan/domains/ are configured.
- *
- * @param {string} projectDir — absolute path to project root
- * @returns {Promise<DomainFile[]>}
- */
-export async function autoDetectDomains(projectDir) {
-  if (!projectDir) return [];
-
-  const candidates = ["README.md", "CLAUDE.md", "docs/README.md"];
-  const detected = [];
-
-  for (const rel of candidates) {
-    const filePath = join(projectDir, rel);
-    let content;
-    try {
-      content = await readFile(filePath, "utf-8");
-    } catch { continue; }
-
-    if (!content || content.trim().length < 20) continue;
-
-    // Truncate to first 4000 chars to avoid bloating context
-    const trimmed = content.length > 4000 ? content.slice(0, 4000) + "\n\n[...truncated]" : content;
-
-    detected.push({
-      name: `auto:${rel}`,
-      description: `Auto-detected from ${rel}`,
-      tags: [],
-      version: "0.0.0",
-      author: "",
-      visibility: "private",
-      sources: [{ type: "auto-detect", note: rel }],
-      content: trimmed,
-      sections: parseSections(trimmed),
-      filePath,
-      origin: "auto-detect"
-    });
-  }
-
-  return detected;
-}
-
-/**
- * Load all domains from project-local and user-global directories.
- * Falls back to auto-detecting README.md/CLAUDE.md when no explicit domains found.
- * Project-local domains override user-global domains when directory names match.
- *
- * @param {string|null} projectDir — absolute path to project root (null = user-global only)
- * @returns {Promise<DomainFile[]>}
- */
-export async function loadDomains(projectDir) {
-  const userDir = join(getKarajanHome(), "domains");
-  const projectDomainDir = projectDir ? join(projectDir, ".karajan", "domains") : null;
-
-  // Load user-global first, then project-local overrides
-  const userDomains = await scanDomainDir(userDir, "user");
-  const projectDomains = projectDomainDir ? await scanDomainDir(projectDomainDir, "project") : [];
-
-  // Build a map keyed by directory name for merge.
-  const merged = new Map();
-
-  for (const { dirName, domain } of userDomains) {
-    merged.set(dirName, domain);
-  }
-  for (const { dirName, domain } of projectDomains) {
-    merged.set(dirName, domain); // project overrides user
-  }
-
-  const explicit = Array.from(merged.values());
-
-  // Fallback: auto-detect README.md, CLAUDE.md when no explicit domains found
-  if (explicit.length === 0 && projectDir) {
-    return autoDetectDomains(projectDir);
-  }
-
-  return explicit;
-}
-
-/**
- * Scan a single domains directory for DOMAIN.md files.
- * @param {string} dir — absolute path to a domains/ directory
- * @param {string} origin — "project" | "user"
- * @returns {Promise<Array<{dirName: string, domain: DomainFile}>>}
- */
-async function scanDomainDir(dir, origin) {
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-
-  const results = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-
-    const domainPath = join(dir, entry.name, DOMAIN_FILE);
-    const domain = await parseDomainFile(domainPath);
-
-    if (domain) {
-      domain.origin = origin;
-      results.push({ dirName: entry.name, domain });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Persist an inline domain (text or file path) to .karajan/domains/inline/DOMAIN.md.
- * If domainInput is a path to an existing .md file, reads its content.
- * Otherwise treats it as inline text.
- *
- * @param {string} domainInput — inline text or absolute path to a .md file
- * @param {string} projectDir — project root
- */
-export async function persistInlineDomain(domainInput, projectDir) {
-  if (!domainInput || !projectDir) return;
-
-  let content = domainInput;
-
-  // If it looks like a file path, try to read it
-  if (isAbsolute(domainInput) && domainInput.endsWith(".md")) {
-    try {
-      const s = await stat(domainInput);
-      if (s.isFile()) {
-        content = await readFile(domainInput, "utf-8");
-      }
-    } catch { /* treat as inline text */ }
-  }
-
-  const domainDir = join(projectDir, ".karajan", "domains", "inline");
-  await mkdir(domainDir, { recursive: true });
-
-  const domainFile = join(domainDir, DOMAIN_FILE);
-  const wrapped = `---\nname: inline-domain\ndescription: Domain knowledge provided via --domain parameter\ntags: []\nversion: "0.0.0"\n---\n\n${content}\n`;
-  await writeFile(domainFile, wrapped, "utf-8");
-}

package/src/domains/domain-registry.js

@@ -1,140 +0,0 @@
-/**
- * Local domain registry.
- * Tracks installed domains in ~/.karajan/domain-registry.json.
- * Provides search and filtering by tags/hints.
- * Interface prepared for future remote registry extension.
- */
-
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { getKarajanHome } from "../utils/paths.js";
-
-const REGISTRY_FILE = "domain-registry.json";
-const SCHEMA_VERSION = 1;
-
-/**
- * @typedef {Object} RegistryEntry
- * @property {string} name
- * @property {string} [description]
- * @property {string} version
- * @property {string} source — "local" (future: "remote")
- * @property {string} installedAt — ISO timestamp
- * @property {string} filePath — absolute path to DOMAIN.md
- * @property {string[]} tags
- */
-
-export class DomainRegistry {
-  /**
-   * @param {Record<string, RegistryEntry>} domains
-   */
-  constructor(domains = {}) {
-    this._domains = domains;
-  }
-
-  /**
-   * Load registry from disk. Creates empty registry if file is missing or corrupt.
-   * @returns {Promise<DomainRegistry>}
-   */
-  static async load() {
-    const filePath = join(getKarajanHome(), REGISTRY_FILE);
-    try {
-      const raw = await readFile(filePath, "utf-8");
-      const data = JSON.parse(raw);
-      if (data?.schemaVersion === SCHEMA_VERSION && data.domains) {
-        return new DomainRegistry(data.domains);
-      }
-    } catch { /* file missing, corrupt, or wrong schema */ }
-    return new DomainRegistry();
-  }
-
-  /**
-   * Persist registry to disk.
-   */
-  async save() {
-    const home = getKarajanHome();
-    await mkdir(home, { recursive: true });
-    const filePath = join(home, REGISTRY_FILE);
-    const data = {
-      schemaVersion: SCHEMA_VERSION,
-      domains: this._domains
-    };
-    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-  }
-
-  /**
-   * Register or update a domain in the registry.
-   * @param {{name: string, version?: string, tags?: string[], filePath?: string, description?: string}} domainFile
-   */
-  register(domainFile) {
-    this._domains[domainFile.name] = {
-      name: domainFile.name,
-      description: domainFile.description || "",
-      version: domainFile.version || "0.0.0",
-      source: "local",
-      installedAt: new Date().toISOString(),
-      filePath: domainFile.filePath || "",
-      tags: domainFile.tags || []
-    };
-  }
-
-  /**
-   * List domains, optionally filtered by tags and/or free-text query.
-   * @param {{tags?: string[], query?: string}} [filters]
-   * @returns {RegistryEntry[]}
-   */
-  list(filters = {}) {
-    let entries = Object.values(this._domains);
-
-    if (filters.tags?.length) {
-      const tagSet = new Set(filters.tags.map(t => t.toLowerCase()));
-      entries = entries.filter(e =>
-        e.tags?.some(t => tagSet.has(t.toLowerCase()))
-      );
-    }
-
-    if (filters.query) {
-      const q = filters.query.toLowerCase();
-      entries = entries.filter(e =>
-        (e.name || "").toLowerCase().includes(q) ||
-        (e.description || "").toLowerCase().includes(q)
-      );
-    }
-
-    return entries;
-  }
-
-  /**
-   * Search domains by triage hints.
-   * Matches hints against tags, name and description.
-   * Returns results ranked by number of matching hints.
-   * @param {string[]} hints — keywords from triage domainHints
-   * @returns {RegistryEntry[]}
-   */
-  search(hints) {
-    if (!hints?.length) return [];
-
-    const lowerHints = hints.map(h => h.toLowerCase());
-    const entries = Object.values(this._domains);
-    const scored = [];
-
-    for (const entry of entries) {
-      const searchable = [
-        entry.name || "",
-        entry.description || "",
-        ...(entry.tags || [])
-      ].join(" ").toLowerCase();
-
-      let score = 0;
-      for (const hint of lowerHints) {
-        if (searchable.includes(hint)) score++;
-      }
-
-      if (score > 0) {
-        scored.push({ entry, score });
-      }
-    }
-
-    scored.sort((a, b) => b.score - a.score);
-    return scored.map(s => s.entry);
-  }
-}