cclaw-cli 0.12.0 → 0.14.0

package/dist/tdd-cycle.d.ts

@@ -0,0 +1,22 @@
+export type TddCyclePhase = "red" | "green" | "refactor";
+export interface TddCycleEntry {
+    ts: string;
+    runId: string;
+    stage: string;
+    slice: string;
+    phase: TddCyclePhase;
+    command: string;
+    files?: string[];
+    exitCode?: number;
+    note?: string;
+}
+export interface TddCycleValidation {
+    ok: boolean;
+    issues: string[];
+    openRedSlices: string[];
+    sliceCount: number;
+}
+export declare function parseTddCycleLog(text: string): TddCycleEntry[];
+export declare function validateTddCycleOrder(entries: TddCycleEntry[], options?: {
+    runId?: string;
+}): TddCycleValidation;

package/dist/tdd-cycle.js

@@ -0,0 +1,82 @@
+export function parseTddCycleLog(text) {
+    const out = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const phase = parsed.phase;
+            if (phase !== "red" && phase !== "green" && phase !== "refactor") {
+                continue;
+            }
+            const entry = {
+                ts: typeof parsed.ts === "string" ? parsed.ts : "",
+                runId: typeof parsed.runId === "string" ? parsed.runId : "active",
+                stage: typeof parsed.stage === "string" ? parsed.stage : "tdd",
+                slice: typeof parsed.slice === "string" ? parsed.slice : "S-unknown",
+                phase,
+                command: typeof parsed.command === "string" ? parsed.command : "",
+                files: Array.isArray(parsed.files)
+                    ? parsed.files.filter((item) => typeof item === "string")
+                    : undefined,
+                exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : undefined,
+                note: typeof parsed.note === "string" ? parsed.note : undefined
+            };
+            out.push(entry);
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return out;
+}
+export function validateTddCycleOrder(entries, options = {}) {
+    const targetRun = options.runId;
+    const filtered = targetRun
+        ? entries.filter((entry) => entry.runId === targetRun)
+        : entries;
+    const bySlice = new Map();
+    for (const entry of filtered) {
+        const list = bySlice.get(entry.slice) ?? [];
+        list.push(entry);
+        bySlice.set(entry.slice, list);
+    }
+    const issues = [];
+    const openRedSlices = [];
+    for (const [slice, sliceEntries] of bySlice.entries()) {
+        let state = "need_red";
+        for (const entry of sliceEntries) {
+            if (entry.phase === "red") {
+                if (state === "red_open") {
+                    issues.push(`slice ${slice}: duplicate red before green`);
+                    continue;
+                }
+                state = "red_open";
+                continue;
+            }
+            if (entry.phase === "green") {
+                if (state !== "red_open") {
+                    issues.push(`slice ${slice}: green logged before red`);
+                    continue;
+                }
+                state = "green_done";
+                continue;
+            }
+            // refactor
+            if (state !== "green_done") {
+                issues.push(`slice ${slice}: refactor logged before green`);
+            }
+            state = "need_red";
+        }
+        if (state === "red_open") {
+            openRedSlices.push(slice);
+        }
+    }
+    return {
+        ok: issues.length === 0 && openRedSlices.length === 0,
+        issues,
+        openRedSlices,
+        sliceCount: bySlice.size
+    };
+}

package/dist/types.d.ts

@@ -57,10 +57,12 @@ export interface VibyConfig {
     version: string;
     flowVersion: string;
     harnesses: HarnessId[];
-    /** When true, stage skills instruct the agent to continue to the following stage after gates pass. */
-    autoAdvance?: boolean;
     /** Prompt guard behavior for runtime write-risk detection hooks. */
     promptGuardMode?: "advisory" | "strict";
+    /** TDD red->green->refactor enforcement mode used by workflow guard hooks. */
+    tddEnforcement?: "advisory" | "strict";
+    /** Optional test file globs used by guard guidance and /cc-tdd-log docs. */
+    tddTestGlobs?: string[];
     /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */
     gitHookGuards?: boolean;
     /** Default flow track for new runs (quick = shortened path, standard = full pipeline). */

package/package.json

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