karajan-code 1.59.0 → 2.0.0

package/src/roles/architect-role.js

@@ -1,122 +1,75 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { buildArchitectPrompt, parseArchitectOutput } from "../prompts/architect.js";
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.architect?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
-}
-
-function 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";
-}
-
 const EMPTY_ARCHITECTURE = {
-  type: "",
-  layers: [],
-  patterns: [],
-  dataModel: { entities: [] },
-  apiContracts: [],
-  dependencies: [],
-  tradeoffs: []
+  type: "", layers: [], patterns: [], dataModel: { entities: [] },
+  apiContracts: [], dependencies: [], tradeoffs: []
 };
 
-export class ArchitectRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "architect", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
+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 execute(input) {
-    const task = typeof input === "string"
-      ? input
-      : input?.task || this.context?.task || "";
-    const onOutput = typeof input === "string" ? null : input?.onOutput || null;
-    const researchContext = typeof input === "object" ? input?.researchContext || null : null;
+  async buildPrompt({ task, researchContext }) {
+    const prompt = await buildArchitectPrompt({
+      task, instructions: this.instructions, researchContext,
+      productContext: this.config?.productContext || null,
+      domainContext: this.config?.domainContext || null
+    });
+    return { prompt };
+  }
 
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
+  parseOutput(raw) { return parseArchitectOutput(raw); }
 
-    const prompt = await buildArchitectPrompt({ task, instructions: this.instructions, researchContext, productContext: this.config?.productContext || null, domainContext: this.config?.domainContext || null });
-    const runArgs = { prompt, role: "architect" };
-    if (onOutput) runArgs.onOutput = onOutput;
-    const result = await agent.runTask(runArgs);
+  buildSuccessResult(parsed, provider) {
+    return {
+      verdict: parsed.verdict,
+      architecture: parsed.architecture,
+      questions: parsed.questions,
+      provider
+    };
+  }
 
-    if (!result.ok) {
-      return {
-        ok: false,
-        result: {
-          error: result.error || result.output || "Architect failed",
-          provider
-        },
-        summary: `Architect failed: ${result.error || "unknown error"}`,
-        usage: result.usage
-      };
-    }
+  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";
+  }
 
-    try {
-      const parsed = parseArchitectOutput(result.output);
-      if (!parsed) {
-        return {
-          ok: true,
-          result: {
-            verdict: "needs_clarification",
-            architecture: { ...EMPTY_ARCHITECTURE },
-            questions: [],
-            raw: result.output,
-            provider
-          },
-          summary: "Architecture complete (unstructured output)",
-          usage: result.usage
-        };
-      }
+  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
+    };
+  }
 
-      return {
-        ok: true,
-        result: {
-          verdict: parsed.verdict,
-          architecture: parsed.architecture,
-          questions: parsed.questions,
-          provider
-        },
-        summary: buildSummary(parsed),
-        usage: result.usage
-      };
-    } catch { /* agent output is not structured JSON */
-      return {
-        ok: true,
-        result: {
-          verdict: "needs_clarification",
-          architecture: { ...EMPTY_ARCHITECTURE },
-          questions: [],
-          raw: result.output,
-          provider
-        },
-        summary: "Architecture complete (unstructured output)",
-        usage: result.usage
-      };
-    }
+  handleParseError(_err, agentResult, provider) {
+    return this.handleParseNull(agentResult, provider);
   }
 }

package/src/roles/audit-role.js

@@ -1,14 +1,13 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { buildAuditPrompt, parseAuditOutput, AUDIT_DIMENSIONS } from "../prompts/audit.js";
 import { measureBasalCost, loadPreviousAudit, saveAuditSnapshot, computeGrowthDelta } from "../audit/basal-cost.js";
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.audit?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
+function parseDimensions(dimensionsStr) {
+  if (!dimensionsStr || dimensionsStr === "all") return null;
+  const requested = dimensionsStr.split(",").map(d => d.trim().toLowerCase());
+  const mapped = requested.map(d => d === "quality" ? "codeQuality" : d);
+  const valid = mapped.filter(d => AUDIT_DIMENSIONS.includes(d));
+  return valid.length > 0 ? valid : null;
 }
 
 function buildSummary(parsed) {
@@ -18,45 +17,21 @@ function buildSummary(parsed) {
   if (summary.high > 0) parts.push(`${summary.high} high`);
   if (summary.medium > 0) parts.push(`${summary.medium} medium`);
   if (summary.low > 0) parts.push(`${summary.low} low`);
-
   const findingsStr = parts.length > 0 ? parts.join(", ") : "no issues";
   return `Overall health: ${summary.overallHealth}. ${summary.totalFindings} findings (${findingsStr})`;
 }
 
-function resolveInput(input, context) {
-  if (typeof input === "string") {
-    return { task: input, onOutput: null, dimensions: null, context: null };
-  }
-  return {
-    task: input?.task || context?.task || "",
-    onOutput: input?.onOutput || null,
-    dimensions: input?.dimensions || null,
-    context: input?.context || null
-  };
-}
-
-function parseDimensions(dimensionsStr) {
-  if (!dimensionsStr || dimensionsStr === "all") return null;
-  const requested = dimensionsStr.split(",").map(d => d.trim().toLowerCase());
-  // Map "quality" shorthand to "codeQuality"
-  const mapped = requested.map(d => d === "quality" ? "codeQuality" : d);
-  const valid = mapped.filter(d => AUDIT_DIMENSIONS.includes(d));
-  return valid.length > 0 ? valid : null;
-}
-
-export class AuditRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "audit", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
+export class AuditRole extends AgentRole {
+  constructor(opts) {
+    super({ ...opts, name: "audit" });
   }
 
   async execute(input) {
-    const { task, onOutput, dimensions: rawDimensions, context } = resolveInput(input, this.context);
-    const dimensions = typeof rawDimensions === "string"
-      ? parseDimensions(rawDimensions)
-      : rawDimensions;
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
+    const task = typeof input === "string" ? input : input?.task || this.context?.task || "";
+    const onOutput = typeof input === "string" ? null : input?.onOutput || null;
+    const rawDimensions = typeof input === "object" ? input?.dimensions || null : null;
+    const context = typeof input === "object" ? input?.context || null : null;
+    const dimensions = typeof rawDimensions === "string" ? parseDimensions(rawDimensions) : rawDimensions;
 
     const projectDir = this.config?.projectDir || process.cwd();
     let basalCost = null;
@@ -65,59 +40,38 @@ export class AuditRole extends BaseRole {
       basalCost = await measureBasalCost(projectDir);
       const previous = await loadPreviousAudit(projectDir);
       growthDelta = computeGrowthDelta(basalCost, previous);
-    } catch {
-      // basal cost is best-effort, don't fail the audit
-    }
+    } catch { /* basal cost is best-effort */ }
 
+    const provider = this.resolveProvider();
+    const agent = this.createAgentInstance(provider);
     const prompt = buildAuditPrompt({ task, instructions: this.instructions, dimensions, context, basalCost, growthDelta });
     const runArgs = { prompt, role: "audit" };
     if (onOutput) runArgs.onOutput = onOutput;
     const result = await agent.runTask(runArgs);
 
     if (!result.ok) {
-      return {
-        ok: false,
-        result: { error: result.error || result.output || "Audit failed", provider },
-        summary: `Audit failed: ${result.error || "unknown error"}`,
-        usage: result.usage
-      };
+      return { ok: false, result: { error: result.error || result.output || "Audit failed", provider }, summary: `Audit failed: ${result.error || "unknown error"}`, usage: result.usage };
     }
 
     try {
       const parsed = parseAuditOutput(result.output);
       if (!parsed) {
-        return {
-          ok: true,
-          result: { raw: result.output, provider },
-          summary: "Audit complete (unstructured output)",
-          usage: result.usage
-        };
-      }
-
-      if (basalCost) {
-        try { await saveAuditSnapshot(projectDir, basalCost); } catch { /* best-effort */ }
+        return { ok: true, result: { raw: result.output, provider }, summary: "Audit complete (unstructured output)", usage: result.usage };
       }
+      if (basalCost) { try { await saveAuditSnapshot(projectDir, basalCost); } catch { /* best-effort */ } }
 
       return {
         ok: true,
         result: {
-          summary: parsed.summary,
-          dimensions: parsed.dimensions,
+          summary: parsed.summary, dimensions: parsed.dimensions,
           topRecommendations: parsed.topRecommendations,
-          basalCost: basalCost || undefined,
-          growthDelta: growthDelta || undefined,
-          provider
+          basalCost: basalCost || undefined, growthDelta: growthDelta || undefined, provider
         },
         summary: buildSummary(parsed),
         usage: result.usage
       };
-    } catch { /* agent output is not structured JSON */
-      return {
-        ok: true,
-        result: { raw: result.output, provider },
-        summary: "Audit complete (unstructured output)",
-        usage: result.usage
-      };
+    } catch {
+      return { ok: true, result: { raw: result.output, provider }, summary: "Audit complete (unstructured output)", usage: result.usage };
     }
   }
 }

package/src/roles/coder-role.js

@@ -1,78 +1,53 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { buildCoderPrompt } from "../prompts/coder.js";
 import { isHostAgent } from "../utils/agent-detect.js";
 import { HostAgent } from "../agents/host-agent.js";
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.coder?.provider ||
-    config?.coder ||
-    "claude"
-  );
-}
-
-export class CoderRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null, askHost = null }) {
-    super({ name: "coder", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
-    this._askHost = askHost;
+export class CoderRole extends AgentRole {
+  constructor(opts) {
+    super({ ...opts, name: "coder" });
+    this._askHost = opts.askHost || null;
   }
 
-  async execute(input) {
-    const { task, reviewerFeedback, sonarSummary, deferredContext, onOutput } = typeof input === "string"
-      ? { task: input, reviewerFeedback: null, sonarSummary: null, deferredContext: null, onOutput: null }
-      : input || {};
-
-    const provider = resolveProvider(this.config);
-    const useHost = this._askHost && isHostAgent(provider);
-    const agent = useHost
-      ? new HostAgent(this.config, this.logger, { askHost: this._askHost })
-      : this._createAgent(provider, this.config, this.logger);
+  resolveProvider() {
+    return this.config?.roles?.coder?.provider || this.config?.coder || "claude";
+  }
 
-    if (useHost) {
+  createAgentInstance(provider) {
+    if (this._askHost && isHostAgent(provider)) {
       this.logger.info(`Host-as-coder: delegating to host AI (skipping ${provider} subprocess)`);
+      return new HostAgent(this.config, this.logger, { askHost: this._askHost });
     }
+    return this._createAgent(provider, this.config, this.logger);
+  }
+
+  extractInput(input) {
+    if (typeof input === "string") return { task: input, reviewerFeedback: null, sonarSummary: null, deferredContext: null, onOutput: null };
+    return {
+      task: input?.task || this.context?.task || "",
+      reviewerFeedback: input?.reviewerFeedback || null,
+      sonarSummary: input?.sonarSummary || null,
+      deferredContext: input?.deferredContext || null,
+      onOutput: input?.onOutput || null
+    };
+  }
 
+  async buildPrompt({ task, reviewerFeedback, sonarSummary, deferredContext }) {
     const prompt = await buildCoderPrompt({
-      task: task || this.context?.task || "",
-      reviewerFeedback: reviewerFeedback || null,
-      sonarSummary: sonarSummary || null,
-      deferredContext: deferredContext || null,
+      task, reviewerFeedback, sonarSummary, deferredContext,
       coderRules: this.instructions,
       methodology: this.config?.development?.methodology || "tdd",
       serenaEnabled: Boolean(this.config?.serena?.enabled),
       rtkAvailable: Boolean(this.config?.rtk?.available),
-      proxyEnabled: Boolean(this.config?.proxy?.enabled),
       productContext: this.config?.productContext || null,
       domainContext: this.config?.domainContext || null
     });
+    return { prompt };
+  }
 
-    const coderArgs = { prompt, role: "coder" };
-    if (onOutput) coderArgs.onOutput = onOutput;
-
-    const result = await agent.runTask(coderArgs);
-
-    if (!result.ok) {
-      return {
-        ok: false,
-        result: {
-          ...result,
-          error: result.error || result.output || "Coder failed",
-          provider
-        },
-        summary: `Coder failed: ${result.error || result.output || "unknown error"}`
-      };
-    }
-
-    return {
-      ok: true,
-      result: {
-        ...result,
-        output: result.output || "",
-        provider
-      },
-      summary: "Coder completed"
-    };
+  buildSuccessResult(parsed, provider, agentResult) {
+    return { ...agentResult, output: agentResult.output || "", provider };
   }
+
+  buildSummary() { return "Coder completed"; }
 }

package/src/roles/discover-role.js

@@ -1,23 +1,21 @@
-import { BaseRole } from "./base-role.js";
-import { createAgent as defaultCreateAgent } from "../agents/index.js";
+import { AgentRole } from "./agent-role.js";
 import { buildDiscoverPrompt, parseDiscoverOutput } from "../prompts/discover.js";
 
-function resolveProvider(config) {
-  return (
-    config?.roles?.discover?.provider ||
-    config?.roles?.coder?.provider ||
-    "claude"
-  );
-}
-
 function pluralize(count, singular, plural) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
 
-function collectModeParts(parsed, mode, gapCount) {
+const MODE_FIELDS = {
+  momtest: { key: "momTestQuestions", fallback: [] },
+  wendel: { key: "wendelChecklist", fallback: [] },
+  classify: { key: "classification", fallback: null },
+  jtbd: { key: "jtbds", fallback: [] }
+};
+
+function buildSummary(parsed, mode) {
+  const gapCount = parsed.gaps?.length || 0;
   const parts = [];
   if (gapCount > 0) parts.push(`${pluralize(gapCount, "gap", "gaps")} found`);
-
   if (mode === "momtest") {
     const qCount = parsed.momTestQuestions?.length || 0;
     if (qCount > 0) parts.push(`${pluralize(qCount, "Mom Test question", "Mom Test questions")}`);
@@ -33,63 +31,23 @@ function collectModeParts(parsed, mode, gapCount) {
     const jCount = parsed.jtbds?.length || 0;
     if (jCount > 0) parts.push(`${pluralize(jCount, "JTBD", "JTBDs")} generated`);
   }
-  return parts;
-}
-
-function buildSummary(parsed, mode) {
-  const gapCount = parsed.gaps?.length || 0;
-  const parts = collectModeParts(parsed, mode, gapCount);
   if (parts.length === 0) return "Discovery complete: task is ready";
   return `Discovery complete: ${parts.join(", ")} (verdict: ${parsed.verdict})`;
 }
 
-function resolveInput(input, context) {
-  if (typeof input === "string") {
-    return { task: input, onOutput: null, mode: "gaps", context: null };
-  }
-  return {
-    task: input?.task || context?.task || "",
-    onOutput: input?.onOutput || null,
-    mode: input?.mode || "gaps",
-    context: input?.context || null
-  };
-}
-
-function buildUnstructuredResult(output, mode, provider, usage) {
-  return {
-    ok: true,
-    result: { verdict: "ready", gaps: [], mode, raw: output, provider },
-    summary: "Discovery complete (unstructured output)",
-    usage
-  };
-}
-
-const MODE_FIELDS = {
-  momtest: { key: "momTestQuestions", fallback: [] },
-  wendel: { key: "wendelChecklist", fallback: [] },
-  classify: { key: "classification", fallback: null },
-  jtbd: { key: "jtbds", fallback: [] }
-};
-
-function buildResultFromParsed(parsed, mode, provider) {
-  const resultObj = { verdict: parsed.verdict, gaps: parsed.gaps, mode, provider };
-  const fieldDef = MODE_FIELDS[mode];
-  if (fieldDef) {
-    resultObj[fieldDef.key] = parsed[fieldDef.key] ?? fieldDef.fallback;
-  }
-  return resultObj;
-}
-
-export class DiscoverRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
-    super({ name: "discover", config, logger, emitter });
-    this._createAgent = createAgentFn || defaultCreateAgent;
+export class DiscoverRole extends AgentRole {
+  constructor(opts) {
+    super({ ...opts, name: "discover" });
   }
 
   async execute(input) {
-    const { task, onOutput, mode, context } = resolveInput(input, this.context);
-    const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
+    const task = typeof input === "string" ? input : input?.task || this.context?.task || "";
+    const onOutput = typeof input === "string" ? null : input?.onOutput || null;
+    const mode = typeof input === "object" ? input?.mode || "gaps" : "gaps";
+    const context = typeof input === "object" ? input?.context || null : null;
+
+    const provider = this.resolveProvider();
+    const agent = this.createAgentInstance(provider);
 
     const prompt = buildDiscoverPrompt({ task, instructions: this.instructions, mode, context });
     const runArgs = { prompt, role: "discover" };
@@ -107,16 +65,17 @@ export class DiscoverRole extends BaseRole {
 
     try {
       const parsed = parseDiscoverOutput(result.output);
-      if (!parsed) return buildUnstructuredResult(result.output, mode, provider, result.usage);
+      if (!parsed) {
+        return { ok: true, result: { verdict: "ready", gaps: [], mode, raw: result.output, provider }, summary: "Discovery complete (unstructured output)", usage: result.usage };
+      }
 
-      return {
-        ok: true,
-        result: buildResultFromParsed(parsed, mode, provider),
-        summary: buildSummary(parsed, mode),
-        usage: result.usage
-      };
-    } catch { /* agent output is not structured JSON */
-      return buildUnstructuredResult(result.output, mode, provider, result.usage);
+      const resultObj = { verdict: parsed.verdict, gaps: parsed.gaps, mode, provider };
+      const fieldDef = MODE_FIELDS[mode];
+      if (fieldDef) resultObj[fieldDef.key] = parsed[fieldDef.key] ?? fieldDef.fallback;
+
+      return { ok: true, result: resultObj, summary: buildSummary(parsed, mode), usage: result.usage };
+    } catch {
+      return { ok: true, result: { verdict: "ready", gaps: [], mode, raw: result.output, provider }, summary: "Discovery complete (unstructured output)", usage: result.usage };
     }
   }
 }