cclaw-cli 0.48.5 → 0.48.7

package/dist/internal/knowledge-digest.js

@@ -0,0 +1,93 @@
+import { selectRelevantLearnings } from "../knowledge-store.js";
+import { FLOW_STAGES } from "../types.js";
+function parseCsv(raw) {
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+function parseKnowledgeDigestArgs(tokens) {
+    const args = {
+        diffFiles: [],
+        openGates: [],
+        limit: 8,
+        format: "markdown"
+    };
+    for (const token of tokens) {
+        if (!token.startsWith("--")) {
+            throw new Error(`Unknown positional token for knowledge-digest: ${token}`);
+        }
+        if (token.startsWith("--stage=")) {
+            const value = token.replace("--stage=", "").trim();
+            if (!value)
+                continue;
+            if (!FLOW_STAGES.includes(value)) {
+                throw new Error(`--stage must be one of: ${FLOW_STAGES.join(", ")}`);
+            }
+            args.stage = value;
+            continue;
+        }
+        if (token.startsWith("--branch=")) {
+            const value = token.replace("--branch=", "").trim();
+            if (value.length > 0) {
+                args.branch = value;
+            }
+            continue;
+        }
+        if (token.startsWith("--diff-files=")) {
+            args.diffFiles.push(...parseCsv(token.replace("--diff-files=", "")));
+            continue;
+        }
+        if (token.startsWith("--open-gates=")) {
+            args.openGates.push(...parseCsv(token.replace("--open-gates=", "")));
+            continue;
+        }
+        if (token.startsWith("--limit=")) {
+            const raw = token.replace("--limit=", "").trim();
+            const value = Number.parseInt(raw, 10);
+            if (!Number.isFinite(value) || value <= 0) {
+                throw new Error("--limit must be a positive integer.");
+            }
+            args.limit = value;
+            continue;
+        }
+        if (token === "--json") {
+            args.format = "json";
+            continue;
+        }
+        if (token === "--markdown") {
+            args.format = "markdown";
+            continue;
+        }
+        throw new Error(`Unknown flag for knowledge-digest: ${token}`);
+    }
+    return args;
+}
+function markdownDigest(rows) {
+    if (rows.length === 0) {
+        return "(no relevant learnings)";
+    }
+    return rows
+        .map((entry) => {
+        const stage = entry.stage ?? "global";
+        const domain = entry.domain ?? "general";
+        return `- [${entry.confidence} | ${stage} | ${domain}] ${entry.trigger} -> ${entry.action}`;
+    })
+        .join("\n");
+}
+export async function runKnowledgeDigestCommand(projectRoot, tokens, io) {
+    const args = parseKnowledgeDigestArgs(tokens);
+    const rows = await selectRelevantLearnings(projectRoot, {
+        stage: args.stage,
+        branch: args.branch,
+        diffFiles: args.diffFiles,
+        openGates: args.openGates,
+        limit: args.limit
+    });
+    if (args.format === "json") {
+        io.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+        return 0;
+    }
+    io.stdout.write(`${markdownDigest(rows)}\n`);
+    return 0;
+}

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/dist/knowledge-store.d.ts

@@ -65,6 +65,13 @@ export interface ReadKnowledgeResult {
     entries: KnowledgeEntry[];
     malformedLines: number;
 }
+export interface SelectRelevantLearningsOptions {
+    stage?: FlowStage | null;
+    branch?: string | null;
+    diffFiles?: string[];
+    openGates?: string[];
+    limit?: number;
+}
 export declare function validateKnowledgeEntry(entry: unknown): {
     ok: boolean;
     errors: string[];
@@ -72,3 +79,4 @@ export declare function validateKnowledgeEntry(entry: unknown): {
 export declare function materializeKnowledgeEntry(seed: KnowledgeSeedEntry, defaults?: AppendKnowledgeDefaults): KnowledgeEntry;
 export declare function readKnowledgeSafely(projectRoot: string, options?: ReadKnowledgeOptions): Promise<ReadKnowledgeResult>;
 export declare function appendKnowledge(projectRoot: string, seeds: KnowledgeSeedEntry[], defaults?: AppendKnowledgeDefaults): Promise<AppendKnowledgeResult>;
+export declare function selectRelevantLearnings(projectRoot: string, options?: SelectRelevantLearningsOptions): Promise<KnowledgeEntry[]>;

package/dist/knowledge-store.js

@@ -327,3 +327,98 @@ export async function appendKnowledge(projectRoot, seeds, defaults = {}) {
         appendedEntries
     };
 }
+function tokenizeText(value) {
+    if (!value)
+        return [];
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3);
+}
+function uniqueTokens(values) {
+    return [...new Set(values)];
+}
+function pathTokens(paths) {
+    if (!Array.isArray(paths) || paths.length === 0)
+        return [];
+    const tokens = [];
+    for (const filePath of paths) {
+        tokens.push(...tokenizeText(filePath));
+    }
+    return uniqueTokens(tokens);
+}
+export async function selectRelevantLearnings(projectRoot, options = {}) {
+    const { entries } = await readKnowledgeSafely(projectRoot);
+    if (entries.length === 0) {
+        return [];
+    }
+    const stage = options.stage ?? null;
+    const branchTokens = tokenizeText(options.branch ?? null);
+    const diffTokens = pathTokens(options.diffFiles);
+    const gateTokens = pathTokens(options.openGates);
+    const limit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0
+        ? Math.floor(options.limit)
+        : 8;
+    const ranked = entries.map((entry, index) => {
+        let score = 0;
+        if (stage) {
+            if (entry.stage === stage) {
+                score += 4;
+            }
+            else if (entry.origin_stage === stage) {
+                score += 3;
+            }
+            else if (entry.stage === null) {
+                score += 1;
+            }
+        }
+        if (entry.confidence === "high")
+            score += 2;
+        if (entry.confidence === "medium")
+            score += 1;
+        if (entry.frequency >= 3)
+            score += 1;
+        if (entry.maturity === "lifted-to-enforcement")
+            score -= 1;
+        const searchable = [
+            ...tokenizeText(entry.domain),
+            ...tokenizeText(entry.trigger),
+            ...tokenizeText(entry.action),
+            ...tokenizeText(entry.origin_feature),
+            ...tokenizeText(entry.project)
+        ];
+        const searchSet = new Set(searchable);
+        for (const token of branchTokens) {
+            if (searchSet.has(token))
+                score += 2;
+        }
+        for (const token of diffTokens) {
+            if (searchSet.has(token))
+                score += 2;
+        }
+        for (const token of gateTokens) {
+            if (searchSet.has(token))
+                score += 2;
+        }
+        return {
+            index,
+            score,
+            entry
+        };
+    });
+    ranked.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        const bySeen = Date.parse(b.entry.last_seen_ts) - Date.parse(a.entry.last_seen_ts);
+        if (!Number.isNaN(bySeen) && bySeen !== 0)
+            return bySeen;
+        if (b.entry.frequency !== a.entry.frequency)
+            return b.entry.frequency - a.entry.frequency;
+        return b.index - a.index;
+    });
+    return ranked
+        .filter((row) => row.score > 0)
+        .slice(0, limit)
+        .map((row) => row.entry);
+}

package/dist/tdd-cycle.d.ts

@@ -20,3 +20,10 @@ export declare function parseTddCycleLog(text: string): TddCycleEntry[];
 export declare function validateTddCycleOrder(entries: TddCycleEntry[], options?: {
     runId?: string;
 }): TddCycleValidation;
+/**
+ * Checks whether the log contains a failing RED record associated with
+ * `productionPath` for the active run.
+ */
+export declare function hasFailingTestForPath(entries: TddCycleEntry[], productionPath: string, options?: {
+    runId?: string;
+}): boolean;

package/dist/tdd-cycle.js

@@ -119,3 +119,32 @@ export function validateTddCycleOrder(entries, options = {}) {
         sliceCount: bySlice.size
     };
 }
+function normalizePath(value) {
+    return value.replace(/\\/gu, "/").toLowerCase();
+}
+/**
+ * Checks whether the log contains a failing RED record associated with
+ * `productionPath` for the active run.
+ */
+export function hasFailingTestForPath(entries, productionPath, options = {}) {
+    const normalizedTarget = normalizePath(productionPath);
+    const filtered = options.runId
+        ? entries.filter((entry) => entry.runId === options.runId)
+        : entries;
+    for (const entry of filtered) {
+        if (entry.phase !== "red")
+            continue;
+        if (entry.exitCode === undefined || entry.exitCode === 0)
+            continue;
+        if (!Array.isArray(entry.files) || entry.files.length === 0)
+            continue;
+        const hasMatch = entry.files.some((filePath) => {
+            const normalized = normalizePath(filePath);
+            return normalized === normalizedTarget || normalized.endsWith(`/${normalizedTarget}`);
+        });
+        if (hasMatch) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/types.d.ts

@@ -109,6 +109,10 @@ export interface TddPathConfig {
 export interface CompoundConfig {
     recurrenceThreshold?: number;
 }
+export interface IronLawsConfig {
+    mode?: "advisory" | "strict";
+    strictLaws?: string[];
+}
 export interface CclawConfig {
     version: string;
     flowVersion: string;
@@ -173,6 +177,8 @@ export interface CclawConfig {
      * discipline tractable without forcing it on tiny quick-track fixes.
      */
     sliceReview?: SliceReviewConfig;
+    /** Optional per-law strictness controls for hook-enforced iron laws. */
+    ironLaws?: IronLawsConfig;
 }
 /**
  * @deprecated Use `CclawConfig` instead.

package/package.json

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