@infinitedusky/indusk-mcp 1.12.3 → 1.13.1

package/dist/lib/eval/persistent-judge.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Persistent judge session management.
+ *
+ * First eval spawns a new session with full catchup. Subsequent evals resume
+ * the same session — no catchup cost, just "evaluate this change."
+ *
+ * Session state stored in `.indusk/eval/judge-session.json`.
+ */
+import type { EvalErrorEntry, EvalScorecard } from "./types.js";
+/**
+ * Run eval using a persistent session. First call does catchup + eval.
+ * Subsequent calls resume the session with just the new change.
+ */
+export declare function runPersistentEval(opts: {
+    projectRoot: string;
+    changeId: string;
+    transcriptPath: string;
+    mode: "eval" | "baseline";
+    evalEndpoint?: string;
+}): Promise<EvalScorecard | EvalErrorEntry>;

package/dist/lib/eval/persistent-judge.js

@@ -0,0 +1,192 @@
+/**
+ * Persistent judge session management.
+ *
+ * First eval spawns a new session with full catchup. Subsequent evals resume
+ * the same session — no catchup cost, just "evaluate this change."
+ *
+ * Session state stored in `.indusk/eval/judge-session.json`.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getProjectGroupId } from "../config.js";
+import { ingestScorecard } from "./findings.js";
+import { EvalLogWriter } from "./log-writer.js";
+import { buildJudgePrompt } from "./prompt-builder.js";
+import { V1_RUBRIC } from "./rubric.js";
+function getSessionPath(projectRoot) {
+    return join(projectRoot, ".indusk", "eval", "judge-session.json");
+}
+function getEvalLogPath(projectRoot) {
+    return join(projectRoot, ".indusk", "eval", "results.log");
+}
+function readSession(projectRoot) {
+    const path = getSessionPath(projectRoot);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeSession(projectRoot, session) {
+    const path = getSessionPath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(session, null, 2)}\n`);
+}
+function clearSession(projectRoot) {
+    const path = getSessionPath(projectRoot);
+    if (existsSync(path)) {
+        const { unlinkSync } = require("node:fs");
+        unlinkSync(path);
+    }
+}
+const ALLOWED_TOOLS = [
+    "Read",
+    "Grep",
+    "Glob",
+    "Bash(jj:*)",
+    "Bash(git:*)",
+    "mcp__graphiti__*",
+    "mcp__indusk__*",
+    "mcp__codegraphcontext__*",
+];
+function parseClaudeOutput(stdout) {
+    let scorecardText = stdout;
+    let usage;
+    let sessionId;
+    try {
+        const jsonOutput = JSON.parse(stdout);
+        scorecardText = jsonOutput.result ?? jsonOutput.text ?? jsonOutput.content ?? stdout;
+        sessionId = jsonOutput.session_id;
+        if (jsonOutput.total_cost_usd !== undefined || jsonOutput.usage) {
+            const u = jsonOutput.usage ?? {};
+            usage = {
+                costUsd: jsonOutput.total_cost_usd ?? 0,
+                inputTokens: u.input_tokens ?? 0,
+                outputTokens: u.output_tokens ?? 0,
+                cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+                cacheReadTokens: u.cache_read_input_tokens ?? 0,
+                durationMs: jsonOutput.duration_ms ?? 0,
+            };
+        }
+    }
+    catch {
+        // raw output
+    }
+    const jsonMatch = scorecardText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (jsonMatch?.[1]) {
+        scorecardText = jsonMatch[1];
+    }
+    return { scorecardText, usage, sessionId };
+}
+async function spawnClaude(args, prompt, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn("claude", args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env },
+        });
+        child.stdin?.write(prompt);
+        child.stdin?.end();
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ stdout, stderr, code });
+        });
+    });
+}
+/**
+ * Run eval using a persistent session. First call does catchup + eval.
+ * Subsequent calls resume the session with just the new change.
+ */
+export async function runPersistentEval(opts) {
+    const logWriter = new EvalLogWriter(getEvalLogPath(opts.projectRoot));
+    const session = readSession(opts.projectRoot);
+    const projectGroup = getProjectGroupId(opts.projectRoot);
+    try {
+        let result;
+        if (session) {
+            // Resume existing session — cheap eval, no catchup
+            const resumePrompt = `Evaluate a new commit. Change ID: ${opts.changeId}
+
+Run \`jj diff -r ${opts.changeId}\` to see what changed. Then answer the same evaluation questions as before. Read the changed files for full context.
+
+Output ONLY the JSON scorecard as before — no commentary.`;
+            result = await spawnClaude([
+                "--print",
+                "--output-format",
+                "json",
+                "--resume",
+                session.sessionId,
+                "--allowed-tools",
+                ALLOWED_TOOLS.join(","),
+            ], resumePrompt, opts.projectRoot);
+        }
+        else {
+            // First eval — full catchup + evaluation
+            const fullPrompt = buildJudgePrompt({
+                rubric: V1_RUBRIC,
+                changeId: opts.changeId,
+                transcriptPath: opts.transcriptPath,
+                mode: opts.mode,
+                projectGroup,
+            });
+            result = await spawnClaude([
+                "--print",
+                "--output-format",
+                "json",
+                "--model",
+                "opus",
+                "--permission-mode",
+                "acceptEdits",
+                "--allowed-tools",
+                ALLOWED_TOOLS.join(","),
+            ], fullPrompt, opts.projectRoot);
+        }
+        if (result.code !== 0) {
+            // If resuming failed, clear session and retry with full catchup
+            if (session) {
+                clearSession(opts.projectRoot);
+                return runPersistentEval(opts);
+            }
+            throw new Error(`claude exited with code ${result.code}: ${result.stderr.slice(0, 500)}`);
+        }
+        const parsed = parseClaudeOutput(result.stdout);
+        const scorecard = JSON.parse(parsed.scorecardText.trim());
+        if (parsed.usage)
+            scorecard.usage = parsed.usage;
+        scorecard.telemetryPosted = false;
+        // Update session state
+        const newSession = {
+            sessionId: parsed.sessionId ?? session?.sessionId ?? "unknown",
+            createdAt: session?.createdAt ?? new Date().toISOString(),
+            lastEvalAt: new Date().toISOString(),
+            evalCount: (session?.evalCount ?? 0) + 1,
+        };
+        writeSession(opts.projectRoot, newSession);
+        await logWriter.append(scorecard);
+        ingestScorecard(opts.projectRoot, scorecard);
+        return scorecard;
+    }
+    catch (err) {
+        const errorEntry = {
+            version: 1,
+            timestamp: new Date().toISOString(),
+            mode: opts.mode,
+            changeId: opts.changeId,
+            error: true,
+            message: err instanceof Error ? err.message : String(err),
+        };
+        await logWriter.append(errorEntry);
+        return errorEntry;
+    }
+}

package/hooks/eval-trigger.js

@@ -11,10 +11,24 @@
  */
 
 import { execSync, spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// Hook debug log — writes to .indusk/eval/hook.log so we can see what's happening
+function hookLog(projectRoot, msg) {
+	try {
+		const logDir = resolve(projectRoot || ".", ".indusk", "eval");
+		mkdirSync(logDir, { recursive: true });
+		appendFileSync(
+			resolve(logDir, "hook.log"),
+			`${new Date().toISOString()} ${msg}\n`,
+		);
+	} catch {
+		// ignore — logging should never break the hook
+	}
+}
+
 // Read hook input from stdin
 let input = "";
 for await (const chunk of process.stdin) {
@@ -24,9 +38,13 @@ for await (const chunk of process.stdin) {
 const event = JSON.parse(input);
 const toolInput = event.tool_input ?? {};
 const command = toolInput.command ?? "";
+const cwd = event.cwd ?? process.cwd();
+
+hookLog(cwd, `hook fired — tool: ${event.tool_name}, command: ${command.slice(0, 100)}`);
 
 // Fast path: not a jj describe command
 if (!command.includes("jj describe")) {
+	hookLog(cwd, "skip — no jj describe in command");
 	process.exit(0);
 }
 
@@ -61,11 +79,14 @@ function readEvalConfig(projectRoot) {
 	}
 }
 
-const projectRoot = findProjectRoot(event.cwd ?? process.cwd());
+const projectRoot = findProjectRoot(cwd);
 const evalConfig = readEvalConfig(projectRoot);
 
+hookLog(projectRoot, `projectRoot: ${projectRoot}, eval.enabled: ${evalConfig.enabled}`);
+
 // Check if eval is disabled
 if (!evalConfig.enabled) {
+	hookLog(projectRoot, "skip — eval disabled in config");
 	process.exit(0);
 }
 
@@ -117,11 +138,13 @@ const candidates = [
 ];
 let judgeRunnerPath = null;
 for (const c of candidates) {
+	hookLog(projectRoot, `candidate: ${c} — ${existsSync(c) ? "found" : "missing"}`);
 	if (existsSync(c)) {
 		judgeRunnerPath = c;
 		break;
 	}
 }
+hookLog(projectRoot, `judgeRunnerPath: ${judgeRunnerPath ?? "NOT FOUND"}`);
 
 if (!judgeRunnerPath) {
 	// Can't find the package — log error and exit
@@ -160,10 +183,16 @@ if (existsSync(findingsPath)) {
 	}
 }
 
-// Spawn a detached node process that calls runJudgeSync (which awaits completion).
+// Use persistent judge — resumes existing session if available, otherwise does full catchup.
+const persistentJudgePath = judgeRunnerPath.replace("judge-runner.js", "persistent-judge.js");
+const useModule = existsSync(persistentJudgePath) ? persistentJudgePath : judgeRunnerPath;
+const useFunction = existsSync(persistentJudgePath) ? "runPersistentEval" : "runJudgeSync";
+
+hookLog(projectRoot, `spawning judge — module: ${useModule}, function: ${useFunction}, changeId: ${changeId}`);
+
 const judgeScript = `
-import("${judgeRunnerPath}")
-  .then(m => m.runJudgeSync({
+import("${useModule}")
+  .then(m => m.${useFunction}({
     projectRoot: ${JSON.stringify(projectRoot)},
     changeId: ${JSON.stringify(changeId)},
     transcriptPath: ${JSON.stringify(transcriptPath)},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.12.3",
+	"version": "1.13.1",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [