karajan-code 1.59.0 → 2.0.0

package/src/planning-game/client.js

@@ -65,11 +65,11 @@ export async function fetchCard({ projectId, cardId, timeoutMs = DEFAULT_TIMEOUT
   return data?.card || data;
 }
 
-export async function getCard({ projectId, cardId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+async function getCard({ projectId, cardId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
   return fetchCard({ projectId, cardId, timeoutMs });
 }
 
-export async function listCards({ projectId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+async function listCards({ projectId, timeoutMs = DEFAULT_TIMEOUT_MS }) {
   const url = `${getApiUrl()}/projects/${encodeURIComponent(projectId)}/cards`;
   const response = await fetchWithRetry(url, {}, timeoutMs);
   const data = await parseJsonResponse(response);

package/src/planning-game/pipeline-adapter.js

@@ -188,7 +188,7 @@ export function accumulateCommit(session, commitInfo) {
     hash: commitInfo.hash,
     message: commitInfo.message || "",
     date: commitInfo.date || new Date().toISOString(),
-    author: commitInfo.author || "BecarIA"
+    author: commitInfo.author || "Karajan"
   });
 }
 

package/src/prompts/coder.js

@@ -33,7 +33,7 @@ const SERENA_INSTRUCTIONS = [
   "Fall back to reading files only when Serena tools are not sufficient."
 ].join("\n");
 
-export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, proxyEnabled = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en" }) {
+export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en" }) {
   const langInstruction = getLanguageInstruction(language);
   const sections = [
     serenaEnabled ? SUBAGENT_PREAMBLE_SERENA : SUBAGENT_PREAMBLE,
@@ -41,6 +41,10 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
     `Task:\n${task}`,
     "Implement directly in the repository.",
     "Keep changes minimal and production-ready.",
+    "Follow SOLID principles. Write small, focused functions (< 30 lines).",
+    "Make atomic commits: 1 logical change = 1 commit. Keep PRs small and reviewable.",
+    "Security: use httpOnly cookies for auth tokens, validate all input, parameterize queries, never expose secrets.",
+    "No console.log — use a structured logger. No 'any' types — use JSDoc annotations.",
     SUBPROCESS_CONSTRAINTS
   ];
 
@@ -48,7 +52,7 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
     sections.push(SERENA_INSTRUCTIONS);
   }
 
-  const rtkSnippet = buildRtkInstructions({ rtkAvailable, proxyEnabled });
+  const rtkSnippet = buildRtkInstructions({ rtkAvailable });
   if (rtkSnippet) {
     sections.push(rtkSnippet);
   }
@@ -85,7 +89,17 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
   }
 
   if (reviewerFeedback) {
-    sections.push(`Reviewer blocking feedback:\n${reviewerFeedback}`);
+    sections.push(
+      `## Reviewer blocking feedback — YOU MUST FIX THESE BEFORE PROCEEDING`,
+      reviewerFeedback,
+      "",
+      "For each issue above:",
+      "1. Find the relevant file(s) in the project",
+      "2. Make the specific code change needed to resolve the issue",
+      "3. If tests are missing, write them",
+      "4. If dependencies are needed, install them (npm install)",
+      "5. Do NOT skip any issue — all must be resolved"
+    );
   }
 
   if (deferredContext) {

package/src/prompts/reviewer.js

@@ -24,7 +24,7 @@ const SERENA_INSTRUCTIONS = [
   "Fall back to reading files only when Serena tools are not sufficient."
 ].join("\n");
 
-export async function buildReviewerPrompt({ task, diff, reviewRules, mode, serenaEnabled = false, rtkAvailable = false, proxyEnabled = false, productContext = null, domainContext = null, projectDir = null, language = "en" }) {
+export async function buildReviewerPrompt({ task, diff, reviewRules, mode, serenaEnabled = false, rtkAvailable = false, productContext = null, domainContext = null, projectDir = null, language = "en" }) {
   const truncatedDiff = diff.length > 12000 ? `${diff.slice(0, 12000)}\n\n[TRUNCATED]` : diff;
 
   const langInstruction = getLanguageInstruction(language);
@@ -43,7 +43,7 @@ export async function buildReviewerPrompt({ task, diff, reviewRules, mode, seren
     sections.push(SERENA_INSTRUCTIONS);
   }
 
-  const rtkSnippet = buildRtkInstructions({ rtkAvailable, proxyEnabled });
+  const rtkSnippet = buildRtkInstructions({ rtkAvailable });
   if (rtkSnippet) {
     sections.push(rtkSnippet);
   }

package/src/prompts/rtk-snippet.js

@@ -15,13 +15,11 @@ export const RTK_INSTRUCTIONS = [
 ].join("\n");
 
 /**
- * Build RTK instructions, returning empty string when proxy compression
- * handles token optimization at the HTTP layer.
- * @param {{ rtkAvailable?: boolean, proxyEnabled?: boolean }} options
+ * Build RTK instructions when RTK is detected.
+ * @param {{ rtkAvailable?: boolean }} options
  * @returns {string}
  */
-export function buildRtkInstructions({ rtkAvailable = false, proxyEnabled = false } = {}) {
-  if (proxyEnabled) return "";
+export function buildRtkInstructions({ rtkAvailable = false } = {}) {
   if (!rtkAvailable) return "";
   return RTK_INSTRUCTIONS;
 }

package/src/review/diff-generator.js

@@ -1,8 +1,33 @@
 import { runCommand } from "../utils/process.js";
+import { generateSnapshotDiff } from "./snapshot-diff.js";
 
 /** @type {((command: string, args?: string[], options?: object) => Promise<object>)|null} */
 let _runner = null;
 
+/** @type {Map<string, string>|null} — pre-coder filesystem snapshot for git-free diff */
+let _snapshot = null;
+
+/** @type {string|null} — project directory scope for git diff (prevents leaking unrelated changes) */
+let _projectDir = null;
+
+/**
+ * Set the project directory scope. When set, all diffs are scoped to this directory.
+ * Call once at pipeline start when projectDir differs from repo root.
+ * @param {string|null} dir
+ */
+export function setProjectDir(dir) {
+  _projectDir = dir;
+}
+
+/**
+ * Store a filesystem snapshot for git-free diff fallback.
+ * Call before the coder runs. If git is available, this is unused.
+ * @param {Map<string, string>} snapshot
+ */
+export function setSnapshot(snapshot) {
+  _snapshot = snapshot;
+}
+
 /**
  * Inject an RTK-aware runner so all git operations in this module benefit from token savings.
  * Call once at pipeline start when RTK is available.
@@ -18,29 +43,53 @@ function run(command, args, ...rest) {
 
 export async function computeBaseRef({ baseBranch = "main", baseRef = null }) {
   if (baseRef) return baseRef;
-  const mergeBase = await run("git", ["merge-base", "HEAD", `origin/${baseBranch}`]);
-  if (mergeBase.exitCode === 0) return mergeBase.stdout.trim();
 
-  const fallback = await run("git", ["rev-parse", "HEAD~1"]);
-  if (fallback.exitCode === 0) return fallback.stdout.trim();
+  try {
+    const mergeBase = await run("git", ["merge-base", "HEAD", `origin/${baseBranch}`]);
+    if (mergeBase.exitCode === 0) return mergeBase.stdout.trim();
 
-  // Empty repo (zero commits): diff against the empty tree
-  const emptyTree = await run("git", ["hash-object", "-t", "tree", "/dev/null"]);
-  if (emptyTree.exitCode === 0) return emptyTree.stdout.trim();
+    const fallback = await run("git", ["rev-parse", "HEAD~1"]);
+    if (fallback.exitCode === 0) return fallback.stdout.trim();
 
-  throw new Error("Could not compute diff base reference");
+    // Empty repo (zero commits): diff against the empty tree
+    const emptyTree = await run("git", ["hash-object", "-t", "tree", "/dev/null"]);
+    if (emptyTree.exitCode === 0) return emptyTree.stdout.trim();
+  } catch { /* git not available */ }
+
+  // No git or all strategies failed — return sentinel for snapshot-based diff
+  return "__snapshot__";
 }
 
-export async function generateDiff({ baseRef, stageNewFiles = false }) {
-  // Stage untracked files so they appear in the diff (coder creates files but doesn't git add)
-  if (stageNewFiles) {
-    await run("git", ["add", "-A"]);
-  }
-  const result = await run("git", ["diff", stageNewFiles ? "--cached" : "", `${baseRef}`].filter(Boolean));
-  if (result.exitCode !== 0) {
-    throw new Error(`git diff failed: ${result.stderr || result.stdout}`);
+export async function generateDiff({ baseRef, stageNewFiles = false, projectDir = null }) {
+  // Auto-resolve projectDir from config if not passed explicitly
+  const scopeDir = projectDir || _projectDir || null;
+
+  // Try git diff first
+  try {
+    if (stageNewFiles) {
+      const addArgs = scopeDir ? ["-A", scopeDir] : ["-A"];
+      await run("git", ["add", ...addArgs]);
+    }
+    const diffArgs = ["diff", stageNewFiles ? "--cached" : "", `${baseRef}`].filter(Boolean);
+    // Scope diff to projectDir when it's a subdirectory (prevents leaking unrelated changes)
+    if (scopeDir) diffArgs.push("--", scopeDir);
+    const result = await run("git", diffArgs);
+    if (result.exitCode === 0) {
+      return result.stdout;
+    }
+  } catch { /* git not available or failed */ }
+
+  // Fallback: snapshot-based diff (no git needed)
+  if (_snapshot) {
+    const dir = projectDir || process.cwd();
+    return generateSnapshotDiff(_snapshot, null, dir);
   }
-  return result.stdout;
+
+  // No git and no snapshot — generate diff of all files as new
+  const dir = projectDir || process.cwd();
+  const { takeSnapshot } = await import("./snapshot-diff.js");
+  const emptySnapshot = new Map();
+  return generateSnapshotDiff(emptySnapshot, null, dir);
 }
 
 export async function getUntrackedFiles() {

package/src/review/snapshot-diff.js

@@ -0,0 +1,122 @@
+/**
+ * Git-free diff generation using filesystem snapshots.
+ *
+ * Takes a snapshot of project files (path → content hash), then compares
+ * a later snapshot to generate a unified diff. Works on any OS, no git needed.
+ */
+
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+
+const DEFAULT_IGNORE = new Set([
+  "node_modules", ".git", ".kj", ".karajan", "dist", "build",
+  ".next", ".nuxt", ".svelte-kit", "__pycache__", ".venv",
+  "coverage", ".nyc_output", ".reviews"
+]);
+
+const MAX_FILE_SIZE = 512 * 1024; // 512KB — skip large files
+
+/**
+ * Scan a directory recursively and return a Map of relative path → content hash.
+ * @param {string} rootDir
+ * @returns {Promise<Map<string, string>>} path → sha256 hash
+ */
+export async function takeSnapshot(rootDir) {
+  const snapshot = new Map();
+  await scanDir(rootDir, rootDir, snapshot);
+  return snapshot;
+}
+
+async function scanDir(dir, rootDir, snapshot) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch { return; }
+
+  for (const entry of entries) {
+    if (DEFAULT_IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
+
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await scanDir(fullPath, rootDir, snapshot);
+    } else if (entry.isFile()) {
+      try {
+        const s = await stat(fullPath);
+        if (s.size > MAX_FILE_SIZE) continue;
+        const content = await readFile(fullPath);
+        const hash = createHash("sha256").update(content).digest("hex");
+        snapshot.set(relative(rootDir, fullPath), hash);
+      } catch { /* skip unreadable files */ }
+    }
+  }
+}
+
+/**
+ * Compare two snapshots and generate a unified diff string.
+ * @param {Map<string, string>} before — snapshot before coder
+ * @param {Map<string, string>|null} after — snapshot after coder (null = read from disk)
+ * @param {string} rootDir — project root (for reading file contents)
+ * @returns {Promise<string>} unified diff text
+ */
+export async function generateSnapshotDiff(before, after, rootDir) {
+  if (!after) {
+    after = await takeSnapshot(rootDir);
+  }
+
+  const lines = [];
+
+  // New files (in after but not before)
+  for (const [path, hash] of after) {
+    if (!before.has(path)) {
+      const content = await safeRead(join(rootDir, path));
+      if (content !== null) {
+        lines.push(`diff --snapshot a/${path} b/${path}`);
+        lines.push("new file");
+        lines.push(`--- /dev/null`);
+        lines.push(`+++ b/${path}`);
+        for (const line of content.split("\n")) {
+          lines.push(`+${line}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  // Modified files (in both, different hash)
+  for (const [path, hash] of after) {
+    if (before.has(path) && before.get(path) !== hash) {
+      const content = await safeRead(join(rootDir, path));
+      if (content !== null) {
+        lines.push(`diff --snapshot a/${path} b/${path}`);
+        lines.push("modified file");
+        lines.push(`--- a/${path}`);
+        lines.push(`+++ b/${path}`);
+        // Show full new content (we don't have the old content)
+        for (const line of content.split("\n")) {
+          lines.push(`+${line}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  // Deleted files (in before but not after)
+  for (const [path] of before) {
+    if (!after.has(path)) {
+      lines.push(`diff --snapshot a/${path} b/${path}`);
+      lines.push("deleted file");
+      lines.push(`--- a/${path}`);
+      lines.push(`+++ /dev/null`);
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+async function safeRead(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch { return null; }
+}

package/src/review/tdd-policy.js

@@ -2,7 +2,8 @@ function extractChangedFiles(diff) {
   const files = new Set();
   const lines = String(diff || "").split("\n");
   for (const line of lines) {
-    if (!line.startsWith("diff --git ")) continue;
+    // Support both git diff and snapshot diff formats
+    if (!line.startsWith("diff --git ") && !line.startsWith("diff --snapshot ")) continue;
     const parts = line.split(" ");
     const b = parts[3] || "";
     if (b.startsWith("b/")) files.add(b.slice(2));
@@ -49,7 +50,8 @@ export function evaluateTddPolicy(diff, developmentConfig = {}, untrackedFiles =
   }
 
   if (sourceFiles.length === 0) {
-    return { ok: true, reason: "no_source_changes", sourceFiles, testFiles };
+    const reason = files.length === 0 ? "no_diff_available" : "no_source_changes";
+    return { ok: true, reason, sourceFiles, testFiles };
   }
 
   if (testFiles.length === 0) {

package/src/roles/agent-role.js

@@ -0,0 +1,135 @@
+/**
+ * Base class for LLM-backed roles.
+ * Handles the common execute() flow: resolve provider → create agent → call LLM → parse output.
+ * Subclasses override hooks (buildPrompt, parseOutput, buildSuccessResult, buildSummary)
+ * instead of reimplementing the full execute() boilerplate.
+ */
+import { BaseRole } from "./base-role.js";
+import { createAgent as defaultCreateAgent } from "../agents/index.js";
+
+export class AgentRole extends BaseRole {
+  constructor({ name, config, logger, emitter = null, createAgentFn = null }) {
+    super({ name, config, logger, emitter });
+    this._createAgent = createAgentFn || defaultCreateAgent;
+  }
+
+  /** Provider fallback chain. Override for roles with non-standard chains. */
+  resolveProvider() {
+    return (
+      this.config?.roles?.[this.name]?.provider ||
+      this.config?.roles?.coder?.provider ||
+      "claude"
+    );
+  }
+
+  /** Agent method to call. Override with "reviewTask" for reviewer. */
+  get agentMethod() { return "runTask"; }
+
+  /** Create the agent. Override for special logic (e.g. HostAgent in coder). */
+  createAgentInstance(provider) {
+    return this._createAgent(provider, this.config, this.logger);
+  }
+
+  /**
+   * Build the prompt for this role. MUST be overridden.
+   * @param {*} input - raw input from pipeline
+   * @returns {Promise<{prompt: string, onOutput?: Function}>|{prompt: string, onOutput?: Function}|string}
+   */
+  async buildPrompt(_input) {
+    throw new Error(`${this.name}: buildPrompt() not implemented`);
+  }
+
+  /**
+   * Parse raw LLM output into structured data. Return null to trigger handleParseNull.
+   * @param {string} raw - raw agent output
+   * @returns {*} parsed result
+   */
+  parseOutput(raw) { return raw; }
+
+  /**
+   * Build the result object for a successful parse.
+   * @param {*} parsed - output of parseOutput
+   * @param {string} provider
+   * @param {object} agentResult - full agent result (for accessing .usage, .output, etc.)
+   * @returns {object} result to include in { ok, result, summary, usage }
+   */
+  buildSuccessResult(parsed, provider, _agentResult) { return { ...parsed, provider }; }
+
+  /** Build human-readable summary from parsed output. */
+  buildSummary(_parsed) { return `${this.name} completed`; }
+
+  /** Determine ok status from parsed result. Default: true. Override for verdict-based roles. */
+  isSuccessful(_parsed) { return true; }
+
+  /** Handle null parse (no JSON found). Default returns error. Override for lenient roles. */
+  handleParseNull(agentResult, provider) {
+    return {
+      ok: false,
+      result: { error: `Failed to parse ${this.name} output: no JSON found`, provider },
+      summary: `${this.name} output parse error: no JSON found`,
+      usage: agentResult.usage
+    };
+  }
+
+  /** Handle parse exception. Default returns error. Override for lenient roles. */
+  handleParseError(err, agentResult, provider) {
+    return {
+      ok: false,
+      result: { error: `Failed to parse ${this.name} output: ${err.message}`, provider },
+      summary: `${this.name} output parse error: ${err.message}`,
+      usage: agentResult.usage
+    };
+  }
+
+  /**
+   * Extract input fields from raw input. Default handles string-or-object.
+   * Override for roles needing extra fields.
+   */
+  extractInput(input) {
+    if (typeof input === "string") return { task: input, onOutput: null };
+    return {
+      task: input?.task || this.context?.task || "",
+      onOutput: input?.onOutput || null,
+      ...input
+    };
+  }
+
+  async execute(input) {
+    const extracted = this.extractInput(input);
+    const provider = this.resolveProvider();
+    const agent = this.createAgentInstance(provider);
+
+    const promptResult = await this.buildPrompt(extracted);
+    const { prompt, onOutput } = typeof promptResult === "string"
+      ? { prompt: promptResult, onOutput: extracted.onOutput }
+      : { onOutput: extracted.onOutput, ...promptResult };
+
+    const runArgs = { prompt, role: this.name };
+    if (onOutput) runArgs.onOutput = onOutput;
+
+    const result = await agent[this.agentMethod](runArgs);
+
+    if (!result.ok) {
+      return {
+        ok: false,
+        result: { error: result.error || result.output || `${this.name} failed`, provider },
+        summary: `${this.name} failed: ${result.error || "unknown error"}`,
+        usage: result.usage
+      };
+    }
+
+    try {
+      const parsed = this.parseOutput(result.output);
+      if (parsed === null) return this.handleParseNull(result, provider);
+
+      return {
+        ok: this.isSuccessful(parsed),
+        result: this.buildSuccessResult(parsed, provider, result),
+        summary: this.buildSummary(parsed),
+        usage: result.usage
+      };
+    } catch (err) {
+      return this.handleParseError(err, result, provider);
+    }
+  }
+}