karajan-code 4.70.4 → 5.0.1

package/src/roles/architect-role.js

@@ -1,77 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { buildArchitectPrompt, parseArchitectOutput } from "../prompts/architect.js";
-
-const EMPTY_ARCHITECTURE = {
-  type: "", layers: [], patterns: [], dataModel: { entities: [] },
-  apiContracts: [], dependencies: [], tradeoffs: []
-};
-
-export class ArchitectRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "architect" });
-  }
-
-  extractInput(input) {
-    if (typeof input === "string") return { task: input, researchContext: null, onOutput: null };
-    return {
-      task: input?.task || this.context?.task || "",
-      researchContext: input?.researchContext || null,
-      onOutput: input?.onOutput || null
-    };
-  }
-
-  async buildPrompt({ task, researchContext }) {
-    const prompt = await buildArchitectPrompt({
-      task, instructions: this.instructions, researchContext,
-      productContext: this.config?.productContext || null,
-      domainContext: this.config?.domainContext || null,
-      projectDir: this.config?.projectDir || null,
-      provider: this._resolvedProvider || (typeof this.resolveProvider === "function" ? this.resolveProvider() : null)
-    });
-    return { prompt };
-  }
-
-  parseOutput(raw) { return parseArchitectOutput(raw); }
-
-  buildSuccessResult(parsed, provider) {
-    return {
-      verdict: parsed.verdict,
-      architecture: parsed.architecture,
-      questions: parsed.questions,
-      provider
-    };
-  }
-
-  buildSummary(parsed) {
-    const parts = [];
-    const arch = parsed.architecture;
-    if (arch.type) parts.push(arch.type);
-    const layers = arch.layers?.length || 0;
-    if (layers) parts.push(`${layers} layer${layers === 1 ? "" : "s"}`);
-    const patterns = arch.patterns?.length || 0;
-    if (patterns) parts.push(`${patterns} pattern${patterns === 1 ? "" : "s"}`);
-    const entities = arch.dataModel?.entities?.length || 0;
-    if (entities) parts.push(`${entities} entit${entities === 1 ? "y" : "ies"}`);
-    const questions = parsed.questions?.length || 0;
-    if (questions) parts.push(`${questions} question${questions === 1 ? "" : "s"}`);
-    return parts.length
-      ? `Architecture complete: ${parts.join(", ")} (verdict: ${parsed.verdict})`
-      : "Architecture complete";
-  }
-
-  handleParseNull(agentResult, provider) {
-    return {
-      ok: true,
-      result: {
-        verdict: "needs_clarification", architecture: { ...EMPTY_ARCHITECTURE },
-        questions: [], raw: agentResult.output, provider
-      },
-      summary: "Architecture complete (unstructured output)",
-      usage: agentResult.usage
-    };
-  }
-
-  handleParseError(_err, agentResult, provider) {
-    return this.handleParseNull(agentResult, provider);
-  }
-}

package/src/roles/coder-role.js

@@ -1,113 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { buildCoderPromptLayout } from "../prompts/coder.js";
-import { joinLayout } from "../prompts/prompt-layout.js";
-import { isHostAgent } from "../utils/agent-detect.js";
-import { HostAgent } from "../agents/host-agent.js";
-import { detectProjectStack } from "../utils/stack-detect.js";
-import { detectTestFramework } from "../utils/project-detect.js";
-
-export class CoderRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "coder" });
-    this._askHost = opts.askHost || null;
-  }
-
-  resolveProvider() {
-    return this.config?.roles?.coder?.provider || this.config?.coder || "claude";
-  }
-
-  createAgentInstance(provider, input = {}) {
-    // KJC-TSK-1070 (MR-D2): the HU's route rides on this call only; the shared
-    // role keeps its own config (lanes run in parallel).
-    const route = input?.route;
-    const config = route ? { ...this.config, roles: { ...this.config?.roles, coder: { ...this.config?.roles?.coder, model: route.model, effort: route.effort } } } : this.config;
-    // KJC-BUG-0129 (issues #1301/#1303): running INSIDE an agent does not
-    // make it "the host executor" — delegating sent the full instruction
-    // prompt through elicitInput as a hanging board "question". A CLI
-    // provider spawns as a subprocess ALWAYS; host delegation is explicit
-    // opt-in (roles.coder.host_delegation: true) for MCP-only setups.
-    if (this._askHost && isHostAgent(provider)) {
-      if (this.config?.roles?.coder?.host_delegation === true) {
-        this.logger.info(`Host-as-coder: delegating to host AI (roles.coder.host_delegation, skipping ${provider} subprocess)`);
-        return new HostAgent(this.config, this.logger, { askHost: this._askHost });
-      }
-      this.logger.info(`Running inside ${provider} — spawning it as a subprocess anyway (set roles.coder.host_delegation: true to delegate to the host)`);
-    }
-    return this._createAgent(provider, config, this.logger);
-  }
-
-  extractInput(input) {
-    if (typeof input === "string") {
-      return {
-        task: input,
-        reviewerFeedback: null, sonarSummary: null, deferredContext: null,
-        acceptanceTests: null,
-        adrs: null, specSection: null, reviewerFindings: null, huId: null,
-        projectDir: null,
-        onOutput: null
-      };
-    }
-    return {
-      task: input?.task || this.context?.task || "",
-      reviewerFeedback: input?.reviewerFeedback || null,
-      sonarSummary: input?.sonarSummary || null,
-      deferredContext: input?.deferredContext || null,
-      // Tests-first (v2.7.5): the coder reads these as the gate it
-      // must satisfy. Only the plan-backed HU path populates this;
-      // the standard single-task `kj run` flow leaves it null.
-      acceptanceTests: input?.acceptanceTests || null,
-      // PR F (v2.7.5): per-HU planning context. ADRs constrain HOW,
-      // specSection ties this HU to a SPEC heading, reviewerFindings
-      // are filtered to entries that mention this HU. All four are
-      // null for non-plan-backed runs, which keeps the legacy flow
-      // byte-for-byte identical.
-      adrs: Array.isArray(input?.adrs) ? input.adrs : null,
-      specSection: input?.specSection || null,
-      reviewerFindings: input?.reviewerFindings || null,
-      huId: input?.huId || null,
-      // PAR-E2 (KJC-TSK-0629): per-call project root. Worktree lanes pass
-      // their lane dir here; the shared role instance keeps its own config.
-      projectDir: input?.projectDir || null,
-      // PAR-H (KJC-TSK-0631): per-call subprocess env (lane slot vars).
-      env: input?.env || null,
-      // KJC-TSK-1070: the model and effort this HU's coder runs on.
-      route: input?.route || null,
-      onOutput: input?.onOutput || null
-    };
-  }
-
-  async buildPrompt({ task, reviewerFeedback, sonarSummary, deferredContext, acceptanceTests, adrs, specSection, reviewerFindings, huId, projectDir: laneProjectDir }) {
-    const projectDir = laneProjectDir || this.config?.projectDir || null;
-    // KJC sesgo-de-stack: pasar stack/testFramework al prompt para que
-    // el coder no asuma JS/vitest en proyectos Python / Go / Rust /
-    // Ruby. audit-role.js y tester-role.js ya lo hacen así.
-    let stack = null;
-    let testFramework = null;
-    if (projectDir) {
-      try { stack = await detectProjectStack(projectDir); } catch { /* best-effort */ }
-      try { testFramework = await detectTestFramework(projectDir); } catch { /* best-effort */ }
-    }
-    const layout = await buildCoderPromptLayout({
-      task, reviewerFeedback, sonarSummary, deferredContext, acceptanceTests,
-      adrs, specSection, reviewerFindings, huId,
-      coderRules: this.instructions,
-      methodology: this.config?.development?.methodology || "tdd",
-      serenaEnabled: Boolean(this.config?.serena?.enabled),
-      rtkAvailable: Boolean(this.config?.rtk?.available),
-      productContext: this.config?.productContext || null,
-      domainContext: this.config?.domainContext || null,
-      projectDir,
-      stack, testFramework,
-      provider: this._resolvedProvider || (typeof this.resolveProvider === "function" ? this.resolveProvider() : null)
-    });
-    // Φ1-D: prompt is the joined layout (identical for every agent);
-    // the buckets ride along so ClaudeAgent can system-split them.
-    return { prompt: joinLayout(layout), stablePrompt: layout.stable, volatilePrompt: layout.volatile };
-  }
-
-  buildSuccessResult(parsed, provider, agentResult) {
-    return { ...agentResult, output: agentResult.output || "", provider };
-  }
-
-  buildSummary() { return "Coder completed"; }
-}

package/src/roles/commiter-role.js

@@ -1,113 +0,0 @@
-import { BaseRole } from "./base-role.js";
-import { stampStagedVerdict } from "../review/verdict-store.js";
-import {
-  ensureGitRepo,
-  currentBranch,
-  fetchBase,
-  ensureBranchUpToDateWithBase,
-  hasChanges,
-  commitAll,
-  pushBranch,
-  createPullRequest,
-  revParse,
-  hasRemote
-} from "../utils/git.js";
-
-function buildCommitMessage(task) {
-  const clean = String(task || "")
-    .replaceAll(/\s+/g, " ")
-    .trim();
-  const prefix = "feat: ";
-  const maxBody = 72 - prefix.length;
-  return `${prefix}${clean.slice(0, maxBody) || "update"}`;
-}
-
-function buildPrTitle(task) {
-  const clean = String(task || "")
-    .replaceAll(/\s+/g, " ")
-    .trim();
-  return clean.slice(0, 70) || "Karajan update";
-}
-
-export class CommiterRole extends BaseRole {
-  constructor({ config, logger, emitter = null }) {
-    super({ name: "commiter", config, logger, emitter });
-  }
-
-  async execute(input) {
-    // KJC-TSK-0838: the caller hands the sonar stage result (pipelineSonarBlock);
-    // without it the stamp carries no proof and the commit gate refuses code.
-    const { task, commitMessage, push = false, createPr = false, sonar = null } = input || {};
-
-    const isRepo = await ensureGitRepo();
-    if (!isRepo) {
-      return {
-        ok: false,
-        result: { error: "Current directory is not a git repository" },
-        summary: "Commiter failed: not a git repo"
-      };
-    }
-
-    const branch = await currentBranch();
-    const changes = await hasChanges();
-
-    if (!changes) {
-      return {
-        ok: true,
-        result: { branch, committed: false, commitHash: null, prUrl: null },
-        summary: "No changes to commit"
-      };
-    }
-
-    const msg = commitMessage || buildCommitMessage(task);
-    // ENV-F1 (KJC-TSK-0643): CommiterRole runs after the HU review passed —
-    // stamp the pipeline's verdict so the v4 gate accepts this commit.
-    await commitAll(msg, null, {
-      beforeCommit: () => stampStagedVerdict({
-        projectDir: this.config?.projectDir || process.cwd(),
-        reviewer: this.config?.reviewer || "pipeline-reviewer",
-        summary: "kj pipeline (commiter role): review passed",
-        sonar,
-      }),
-    });
-    const commitHash = await revParse("HEAD");
-
-    // KJC-BUG-0112: no `origin` remote (quickstart scenario) → skip
-    // push/PR instead of throwing on fetch.
-    const remoteAvailable = push ? await hasRemote() : false;
-    if (push && !remoteAvailable) {
-      this.logger?.info?.("No remote configured — skipping push/PR");
-    }
-    if (push && remoteAvailable) {
-      const baseBranch = this.config.base_branch || "main";
-      await fetchBase(baseBranch);
-      await ensureBranchUpToDateWithBase({
-        branch,
-        baseBranch,
-        autoRebase: true
-      });
-      await pushBranch(branch);
-    }
-
-    let prUrl = null;
-    if (push && createPr && remoteAvailable) {
-      const baseBranch = this.config.base_branch || "main";
-      prUrl = await createPullRequest({
-        baseBranch,
-        branch,
-        title: buildPrTitle(task),
-        body: `Task: ${task || "N/A"}`
-      });
-    }
-
-    const parts = [`Committed on ${branch}`];
-    if (push) parts.push("pushed");
-    if (prUrl) parts.push(`PR: ${prUrl}`);
-
-    return {
-      ok: true,
-      result: { branch, committed: true, commitHash, prUrl },
-      summary: parts.join(", ")
-    };
-  }
-}

package/src/roles/domain-curator-role.js

@@ -1,134 +0,0 @@
-/**
- * Domain Curator role.
- * Discovers, proposes and synthesizes domain knowledge for the pipeline.
- * Operates deterministically (loader + registry + synthesizer) — no LLM call needed
- * unless the user wants to generate domain knowledge from scratch.
- */
-
-import { loadDomains } from "../domains/domain-loader.js";
-import { DomainRegistry } from "../domains/domain-registry.js";
-import { synthesizeDomainContext } from "../domains/domain-synthesizer.js";
-
-export class DomainCuratorRole {
-  constructor({ config, logger }) {
-    this.config = config;
-    this.logger = logger;
-  }
-
-  /**
-   * Execute domain curation.
-   * @param {Object} input
-   * @param {string} input.task — the task description
-   * @param {string[]} input.domainHints — keywords from triage
-   * @param {Function & {interactive: boolean}} [input.askQuestion] — interactive question function
-   * @param {string} [input.projectDir] — project root
-   * @returns {Promise<{ok: boolean, result: Object, summary: string}>}
-   */
-  async execute({ task, domainHints = [], askQuestion = null, projectDir = null }) {
-    // 1. Load domains from filesystem
-    const fileDomains = await loadDomains(projectDir);
-
-    // 2. Search registry for additional matches
-    let registryDomains = [];
-    if (domainHints.length > 0) {
-      try {
-        const registry = await DomainRegistry.load();
-        registryDomains = registry.search(domainHints);
-      } catch {
-        this.logger.warn("Domain Curator: failed to load registry, continuing with file domains only");
-      }
-    }
-
-    // 3. Deduplicate (file domains take precedence over registry entries)
-    const allDomains = deduplicateDomains(fileDomains, registryDomains);
-
-    // 4. No domains found. KJC-BUG-0295 (#1992): this used to ASK the user
-    // ("do you have domain documents?") and then do nothing with the answer:
-    // a cryptic, English-only question with no consequence, raised even when
-    // the card already carried the acceptance criteria. A question that changes
-    // nothing is not asked; what kj uses instead is said.
-    if (allDomains.length === 0) {
-      this.logger.info("Domain Curator: no domain documents in .karajan/domains/ nor the registry; the task's own text, the card's acceptance criteria and the repo are the context");
-
-      return {
-        ok: true,
-        result: {
-          selectedDomains: [],
-          domainContext: null,
-          domainsFound: 0,
-          domainsUsed: 0,
-          source: "none"
-        },
-        summary: "Domain Curator: no domains found"
-      };
-    }
-
-    // 5. Propose selection to user (if interactive) or use all
-    let selectedDomains;
-
-    if (askQuestion?.interactive && allDomains.length > 1) {
-      const options = allDomains.map(d => ({
-        id: d.name,
-        label: `${d.name} (v${d.version || "?"}) — ${d.description || "no description"}`,
-        default: true
-      }));
-
-      const selected = await askQuestion({
-        message: `Found ${allDomains.length} domain knowledge package(s):`,
-        type: "multi-select",
-        options,
-        defaults: allDomains.map(d => d.name)
-      });
-
-      if (Array.isArray(selected) && selected.length > 0) {
-        const selectedSet = new Set(selected);
-        selectedDomains = allDomains.filter(d => selectedSet.has(d.name));
-      } else {
-        selectedDomains = allDomains; // fallback to all
-      }
-    } else {
-      // Single domain or non-interactive: use all
-      selectedDomains = allDomains;
-    }
-
-    // 6. Synthesize context
-    const domainContext = synthesizeDomainContext({
-      task,
-      domainHints,
-      selectedDomains
-    });
-
-    const source = selectedDomains.some(d => d.origin === "project") ? "project+user" : "user";
-
-    return {
-      ok: true,
-      result: {
-        selectedDomains: selectedDomains.map(d => d.name),
-        domainContext: domainContext || null,
-        domainsFound: allDomains.length,
-        domainsUsed: selectedDomains.length,
-        source
-      },
-      summary: `Domain Curator: ${selectedDomains.length}/${allDomains.length} domain(s) selected`
-    };
-  }
-}
-
-/**
- * Deduplicate domains — file domains override registry entries by name.
- */
-function deduplicateDomains(fileDomains, registryDomains) {
-  const byName = new Map();
-
-  // Registry entries first (lower priority)
-  for (const rd of registryDomains) {
-    if (rd.name) byName.set(rd.name, rd);
-  }
-
-  // File domains override
-  for (const fd of fileDomains) {
-    if (fd.name) byName.set(fd.name, fd);
-  }
-
-  return Array.from(byName.values());
-}

package/src/roles/hu-reviewer-role.js

@@ -1,64 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { buildHuReviewerPrompt, parseHuReviewerOutput } from "../prompts/hu-reviewer.js";
-
-const EMPTY_BATCH = { total: 0, certified: 0, needs_rewrite: 0, needs_context: 0, consolidated_questions: "" };
-
-export class HuReviewerRole extends AgentRole {
-  constructor(opts) {
-    super({ ...opts, name: "hu-reviewer" });
-  }
-
-  resolveProvider() {
-    return (
-      this.config?.roles?.["hu-reviewer"]?.provider ||
-      this.config?.roles?.hu_reviewer?.provider ||
-      this.config?.roles?.coder?.provider ||
-      "claude"
-    );
-  }
-
-  extractInput(input) {
-    return {
-      stories: input?.stories || [],
-      context: input?.context || null,
-      onOutput: input?.onOutput || null
-    };
-  }
-
-  async buildPrompt({ stories, context }) {
-    const prompt = buildHuReviewerPrompt({
-      stories, instructions: this.instructions, context,
-      productContext: this.config?.productContext || null,
-      domainContext: this.config?.domainContext || null
-    });
-    return { prompt };
-  }
-
-  parseOutput(raw) { return parseHuReviewerOutput(raw); }
-
-  buildSuccessResult(parsed, provider) {
-    return { evaluations: parsed.evaluations, batch_summary: parsed.batch_summary, provider };
-  }
-
-  buildSummary(parsed) {
-    const bs = parsed.batch_summary;
-    const parts = [`${bs.total} HU(s) evaluated`];
-    if (bs.certified > 0) parts.push(`${bs.certified} certified`);
-    if (bs.needs_rewrite > 0) parts.push(`${bs.needs_rewrite} need rewrite`);
-    if (bs.needs_context > 0) parts.push(`${bs.needs_context} need context`);
-    return `HU Review complete: ${parts.join(", ")}`;
-  }
-
-  handleParseNull(agentResult, provider) {
-    return {
-      ok: true,
-      result: { evaluations: [], batch_summary: { ...EMPTY_BATCH }, raw: agentResult.output, provider },
-      summary: "HU Review complete (unstructured output)",
-      usage: agentResult.usage
-    };
-  }
-
-  handleParseError(_err, agentResult, provider) {
-    return this.handleParseNull(agentResult, provider);
-  }
-}

package/src/roles/impeccable-role.js

@@ -1,85 +0,0 @@
-import { AgentRole } from "./agent-role.js";
-import { isDevToolsMcpAvailable, ensureWebPerfSkills } from "../webperf/devtools-detect.js";
-import { extractFirstJson } from "../utils/json-extract.js";
-
-const SUBAGENT_PREAMBLE = [
-  "IMPORTANT: You are running as a Karajan sub-agent.",
-  "Do NOT ask about using Karajan, do NOT mention Karajan, do NOT suggest orchestration.",
-  "Do NOT use any MCP tools. Focus only on auditing frontend/UI code for design quality."
-].join(" ");
-
-function buildSummary(parsed) {
-  const verdict = parsed.verdict || "APPROVED";
-  const found = parsed.issuesFound || 0;
-  const fixed = parsed.issuesFixed || 0;
-  if (verdict === "APPROVED" || found === 0) return "Verdict: APPROVED; No frontend design issues found";
-
-  const cats = parsed.categories || {};
-  const parts = Object.entries(cats).filter(([, count]) => count > 0).map(([cat, count]) => `${count} ${cat}`);
-  return `Verdict: ${verdict}; ${found} issue(s) found, ${fixed} fixed (${parts.join(", ")})`;
-}
-
-export class ImpeccableRole extends AgentRole {
-  constructor(opts) {
-    const mode = opts.mode || "audit";
-    const roleName = mode === "refactoring" ? "impeccable-design" : "impeccable";
-    super({ ...opts, name: roleName });
-    this.mode = mode;
-  }
-
-  resolveProvider() {
-    return this.config?.roles?.impeccable?.provider || this.config?.roles?.coder?.provider || "claude";
-  }
-
-  async execute(input) {
-    const task = typeof input === "string" ? input : input?.task || this.context?.task || "";
-    const diff = typeof input === "object" ? input?.diff || null : null;
-    const projectDir = typeof input === "object" ? input?.projectDir || null : null;
-
-    // Auto-install WebPerf skills when DevTools MCP is configured
-    if (isDevToolsMcpAvailable(this.config)) {
-      const dir = projectDir || process.cwd();
-      try {
-        const webperfResult = await ensureWebPerfSkills(dir, this.logger);
-        if (webperfResult.installed.length > 0) this.logger?.info?.(`WebPerf skills installed: ${webperfResult.installed.join(", ")}`);
-      } catch (err) {
-        this.logger?.warn?.(`WebPerf skill installation failed: ${err.message}`);
-      }
-    } else {
-      this.logger?.debug?.("Chrome DevTools MCP not configured — WebPerf skills skipped");
-    }
-
-    const provider = this.resolveProvider();
-    const agent = this.createAgentInstance(provider);
-
-    const sections = [SUBAGENT_PREAMBLE];
-    if (this.instructions) sections.push(this.instructions);
-    sections.push(`## Task\n${task}`);
-    if (diff) sections.push(`## Git diff to audit\n${diff}`);
-    if (isDevToolsMcpAvailable(this.config)) {
-      sections.push("\nNote: WebPerf domain skills are available. Use them for Core Web Vitals analysis if the audit involves frontend performance.");
-    }
-
-    const result = await agent.runTask({ prompt: sections.join("\n\n"), role: "impeccable" });
-
-    if (!result.ok) {
-      return { ok: false, result: { error: result.error || result.output || "Impeccable audit failed", provider }, summary: `Impeccable audit failed: ${result.error || "unknown error"}` };
-    }
-
-    try {
-      const parsed = extractFirstJson(result.output);
-      if (!parsed) {
-        return { ok: false, result: { error: "Failed to parse impeccable output: no JSON found", provider }, summary: "Impeccable output parse error: no JSON found" };
-      }
-
-      const verdict = parsed.verdict || (parsed.issuesFound > 0 ? "IMPROVED" : "APPROVED");
-      return {
-        ok: verdict === "APPROVED" || verdict === "IMPROVED",
-        result: { verdict, issuesFound: parsed.issuesFound || 0, issuesFixed: parsed.issuesFixed || 0, categories: parsed.categories || {}, changes: parsed.changes || [], provider },
-        summary: buildSummary({ ...parsed, verdict })
-      };
-    } catch (err) {
-      return { ok: false, result: { error: `Failed to parse impeccable output: ${err.message}`, provider }, summary: `Impeccable output parse error: ${err.message}` };
-    }
-  }
-}

package/src/roles/index.js

@@ -1,18 +0,0 @@
-export { BaseRole, ROLE_EVENTS, resolveRoleMdPath, loadFirstExisting } from "./base-role.js";
-export { AgentRole } from "./agent-role.js";
-export { PlannerRole } from "./planner-role.js";
-export { ReviewerRole } from "./reviewer-role.js";
-export { RefactorerRole } from "./refactorer-role.js";
-export { CommiterRole } from "./commiter-role.js";
-export { CoderRole } from "./coder-role.js";
-export { SonarRole } from "./sonar-role.js";
-export { ResearcherRole } from "./researcher-role.js";
-export { TriageRole } from "./triage-role.js";
-export { TesterRole } from "./tester-role.js";
-export { SecurityRole } from "./security-role.js";
-export { SolomonRole } from "./solomon-role.js";
-export { DiscoverRole } from "./discover-role.js";
-export { ArchitectRole } from "./architect-role.js";
-export { AuditRole } from "./audit-role.js";
-export { HuReviewerRole } from "./hu-reviewer-role.js";
-export { KarajanBrainRole } from "./karajan-brain-role.js";