cclaw-cli 0.48.6 → 0.48.8

package/dist/install.js

@@ -24,8 +24,9 @@ import { rewindCommandContract, rewindCommandSkillMarkdown } from "./content/rew
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { ironLawRuntimeDocument, ironLawsSkillMarkdown } from "./content/iron-laws.js";
-import { sessionStartScript, stopCheckpointScript, runHookDispatcherScript, stageCompleteScript, preCompactScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
+import { hookLibScript, sessionStartScript, stopCheckpointScript, runHookDispatcherScript, stageCompleteScript, preCompactScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
 import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./content/observe.js";
+import { nodeHookRuntimeScript } from "./content/node-hooks.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { decisionProtocolMarkdown, completionProtocolMarkdown, ethosProtocolMarkdown } from "./content/protocols.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
@@ -630,6 +631,7 @@ async function writeHooks(projectRoot, config) {
         mode: config.ironLaws?.mode,
         strictLaws: config.ironLaws?.strictLaws
     }), null, 2)}\n`);
+    await writeFileSafe(path.join(hooksDir, "_lib.sh"), hookLibScript());
     await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript());
     await writeFileSafe(path.join(hooksDir, "stop-checkpoint.sh"), stopCheckpointScript());
     await writeFileSafe(path.join(hooksDir, "run-hook.cmd"), runHookDispatcherScript());
@@ -645,10 +647,18 @@ async function writeHooks(projectRoot, config) {
         tddProductionPathPatterns: config.tdd?.productionPathPatterns
     }));
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
+    await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), nodeHookRuntimeScript({
+        promptGuardMode: config.promptGuardMode ?? config.strictness ?? "advisory",
+        workflowGuardMode: config.strictness ?? "advisory",
+        tddEnforcementMode: config.tddEnforcement ?? config.strictness ?? "advisory",
+        tddTestPathPatterns: config.tdd?.testPathPatterns ?? config.tddTestGlobs,
+        tddProductionPathPatterns: config.tdd?.productionPathPatterns
+    }));
     const opencodePluginSource = opencodePluginJs();
     await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
     try {
         for (const script of [
+            "_lib.sh",
             "session-start.sh",
             "stop-checkpoint.sh",
             "run-hook.cmd",
@@ -657,6 +667,7 @@ async function writeHooks(projectRoot, config) {
             "prompt-guard.sh",
             "workflow-guard.sh",
             "context-monitor.sh",
+            "run-hook.mjs",
             "opencode-plugin.mjs"
         ]) {
             await fs.chmod(path.join(hooksDir, script), 0o755);

package/dist/internal/advance-stage.js

@@ -1,5 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { spawn } from "node:child_process";
+import process from "node:process";
 import { RUNTIME_ROOT, SHIP_FINALIZATION_MODES } from "../constants.js";
 import { stageSchema } from "../content/stage-schema.js";
 import { appendDelegation, checkMandatoryDelegations } from "../delegation.js";
@@ -12,6 +14,7 @@ import { readFlowState, writeFlowState } from "../runs.js";
 import { FLOW_STAGES } from "../types.js";
 import { runEnvelopeValidateCommand } from "./envelope-validate.js";
 import { runKnowledgeDigestCommand } from "./knowledge-digest.js";
+import { runTddRedEvidenceCommand } from "./tdd-red-evidence.js";
 function unique(values) {
     return [...new Set(values)];
 }
@@ -305,6 +308,17 @@ function parseVerifyCurrentStateArgs(tokens) {
     }
     return { quiet };
 }
+function parseHookArgs(tokens) {
+    const [hookName, ...rest] = tokens;
+    const normalizedHook = typeof hookName === "string" ? hookName.trim() : "";
+    if (normalizedHook.length === 0) {
+        throw new Error("internal hook requires a hook name: cclaw internal hook <name>.");
+    }
+    if (rest.length > 0) {
+        throw new Error(`Unknown arguments for internal hook: ${rest.join(" ")}`);
+    }
+    return { hookName: normalizedHook };
+}
 async function buildValidationReport(projectRoot, flowState) {
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage);
     const gates = await verifyCurrentStageGateEvidence(projectRoot, flowState);
@@ -620,10 +634,45 @@ async function runVerifyCurrentState(projectRoot, args, io) {
     }
     return validation.ok ? 0 : 1;
 }
+async function runHookCommand(projectRoot, args, io) {
+    const runHookPath = path.join(projectRoot, RUNTIME_ROOT, "hooks", "run-hook.mjs");
+    try {
+        await fs.access(runHookPath);
+    }
+    catch {
+        io.stderr.write(`cclaw internal hook: missing hook runtime at ${runHookPath}. Run \`cclaw sync\` first.\n`);
+        return 1;
+    }
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, [runHookPath, args.hookName], {
+            cwd: projectRoot,
+            env: process.env,
+            stdio: ["inherit", "pipe", "pipe"]
+        });
+        child.stdout.on("data", (chunk) => {
+            io.stdout.write(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            io.stderr.write(chunk);
+        });
+        child.on("error", (err) => {
+            io.stderr.write(`cclaw internal hook: failed to launch runtime (${err instanceof Error ? err.message : String(err)}).\n`);
+            resolve(1);
+        });
+        child.on("close", (code, signal) => {
+            if (signal) {
+                io.stderr.write(`cclaw internal hook: runtime terminated by signal ${signal}.\n`);
+                resolve(1);
+                return;
+            }
+            resolve(typeof code === "number" ? code : 1);
+        });
+    });
+}
 export async function runInternalCommand(projectRoot, argv, io) {
     const [subcommand, ...tokens] = argv;
     if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate\n");
+        io.stderr.write("cclaw internal requires a subcommand: advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence | hook\n");
         return 1;
     }
     try {
@@ -642,7 +691,13 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "envelope-validate") {
             return await runEnvelopeValidateCommand(projectRoot, tokens, io);
         }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate\n`);
+        if (subcommand === "tdd-red-evidence") {
+            return await runTddRedEvidenceCommand(projectRoot, tokens, io);
+        }
+        if (subcommand === "hook") {
+            return await runHookCommand(projectRoot, parseHookArgs(tokens), io);
+        }
+        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence | hook\n`);
         return 1;
     }
     catch (err) {

package/dist/internal/tdd-red-evidence.d.ts

@@ -0,0 +1,7 @@
+import type { Writable } from "node:stream";
+interface InternalIo {
+    stdout: Writable;
+    stderr: Writable;
+}
+export declare function runTddRedEvidenceCommand(projectRoot: string, tokens: string[], io: InternalIo): Promise<number>;
+export {};

package/dist/internal/tdd-red-evidence.js

@@ -0,0 +1,130 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { RUNTIME_ROOT } from "../constants.js";
+import { readFlowState } from "../runs.js";
+import { hasFailingTestForPath, parseTddCycleLog } from "../tdd-cycle.js";
+function normalizePath(value) {
+    return value.replace(/\\/gu, "/").toLowerCase();
+}
+function parseArgs(tokens) {
+    const args = { quiet: false };
+    for (const token of tokens) {
+        if (token === "--quiet") {
+            args.quiet = true;
+            continue;
+        }
+        if (token.startsWith("--path=")) {
+            const value = token.slice("--path=".length).trim();
+            if (!value) {
+                throw new Error("--path must not be empty.");
+            }
+            args.targetPath = value;
+            continue;
+        }
+        if (token.startsWith("--run-id=")) {
+            const value = token.slice("--run-id=".length).trim();
+            if (value) {
+                args.runId = value;
+            }
+            continue;
+        }
+        throw new Error(`Unknown flag for tdd-red-evidence: ${token}`);
+    }
+    if (!args.targetPath) {
+        throw new Error("Missing required flag: --path=<production-file-path>");
+    }
+    return args;
+}
+function parseAutoEvidence(text) {
+    const out = [];
+    for (const rawLine of text.split(/\r?\n/gu)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const exitCode = parsed.exitCode;
+            if (typeof exitCode !== "number" || exitCode === 0)
+                continue;
+            const runId = typeof parsed.runId === "string" && parsed.runId.length > 0
+                ? parsed.runId
+                : "active";
+            const rawPaths = Array.isArray(parsed.paths)
+                ? parsed.paths
+                : typeof parsed.path === "string"
+                    ? [parsed.path]
+                    : [];
+            const paths = rawPaths
+                .filter((value) => typeof value === "string")
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0);
+            if (paths.length === 0)
+                continue;
+            out.push({
+                runId,
+                exitCode,
+                paths
+            });
+        }
+        catch {
+            // ignore malformed lines
+        }
+    }
+    return out;
+}
+function hasFailingAutoEvidenceForPath(entries, targetPath, options = {}) {
+    const normalizedTarget = normalizePath(targetPath);
+    for (const entry of entries) {
+        if (options.runId && entry.runId !== options.runId)
+            continue;
+        for (const filePath of entry.paths) {
+            const normalized = normalizePath(filePath);
+            if (normalized === normalizedTarget || normalized.endsWith(`/${normalizedTarget}`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export async function runTddRedEvidenceCommand(projectRoot, tokens, io) {
+    const args = parseArgs(tokens);
+    const flowState = await readFlowState(projectRoot).catch(() => null);
+    const effectiveRunId = args.runId ?? flowState?.activeRunId;
+    const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
+    const autoEvidencePath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-red-evidence.jsonl");
+    let cycleLogHasRed = false;
+    let autoEvidenceHasRed = false;
+    try {
+        const raw = await fs.readFile(tddLogPath, "utf8");
+        const entries = parseTddCycleLog(raw);
+        cycleLogHasRed = hasFailingTestForPath(entries, args.targetPath, {
+            runId: effectiveRunId
+        });
+    }
+    catch {
+        cycleLogHasRed = false;
+    }
+    try {
+        const raw = await fs.readFile(autoEvidencePath, "utf8");
+        const entries = parseAutoEvidence(raw);
+        autoEvidenceHasRed = hasFailingAutoEvidenceForPath(entries, args.targetPath, {
+            runId: effectiveRunId
+        });
+    }
+    catch {
+        autoEvidenceHasRed = false;
+    }
+    const hasRed = cycleLogHasRed || autoEvidenceHasRed;
+    if (!args.quiet) {
+        io.stdout.write(`${JSON.stringify({
+            ok: hasRed,
+            path: args.targetPath,
+            runId: effectiveRunId ?? null,
+            sources: {
+                tddCycleLog: cycleLogHasRed,
+                autoEvidence: autoEvidenceHasRed
+            }
+        }, null, 2)}\n`);
+    }
+    return hasRed ? 0 : 2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.48.6",
+  "version": "0.48.8",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {