cclaw-cli 0.51.30 → 1.0.0

package/dist/internal/hook-manifest.d.ts

@@ -1,16 +0,0 @@
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-/**
- * `cclaw internal hook-manifest` — diagnostic command that prints
- * the resolved manifest. Primary use cases:
- *
- *  - debugging "which handler fires for event X on harness Y",
- *  - migration tooling that needs a machine-readable view,
- *  - parity verification between the source-of-truth manifest and
- *    per-harness generated documents.
- */
-export declare function runHookManifestCommand(_projectRoot: string, argv: string[], io: InternalIo): Promise<number>;
-export {};

package/dist/internal/hook-manifest.js

@@ -1,77 +0,0 @@
-import { HOOK_MANIFEST, HOOK_MANIFEST_HARNESSES, groupBindingsByEvent, requiredEventsFor } from "../content/hook-manifest.js";
-function parseArgs(tokens) {
-    const args = { json: false };
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        if (token === "--json")
-            args.json = true;
-        else if (token === "--harness") {
-            const value = tokens[i + 1];
-            if (value !== "claude" && value !== "cursor" && value !== "codex") {
-                throw new Error(`--harness must be one of claude|cursor|codex, got ${String(value)}`);
-            }
-            args.harness = value;
-            i += 1;
-        }
-        else {
-            throw new Error(`Unknown hook-manifest flag: ${token}`);
-        }
-    }
-    return args;
-}
-/**
- * `cclaw internal hook-manifest` — diagnostic command that prints
- * the resolved manifest. Primary use cases:
- *
- *  - debugging "which handler fires for event X on harness Y",
- *  - migration tooling that needs a machine-readable view,
- *  - parity verification between the source-of-truth manifest and
- *    per-harness generated documents.
- */
-export async function runHookManifestCommand(_projectRoot, argv, io) {
-    const args = parseArgs(argv);
-    const harnesses = args.harness ? [args.harness] : [...HOOK_MANIFEST_HARNESSES];
-    if (args.json) {
-        const payload = {
-            handlers: HOOK_MANIFEST.map((spec) => ({
-                handler: spec.handler,
-                description: spec.description,
-                semantic: spec.semantic,
-                bindings: spec.bindings
-            })),
-            byHarness: Object.fromEntries(harnesses.map((harness) => [
-                harness,
-                {
-                    requiredEvents: requiredEventsFor(harness),
-                    events: groupBindingsByEvent(harness)
-                }
-            ]))
-        };
-        io.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-        return 0;
-    }
-    const lines = [];
-    lines.push("cclaw hook manifest");
-    for (const harness of harnesses) {
-        lines.push("");
-        lines.push(`## ${harness}`);
-        const groups = groupBindingsByEvent(harness);
-        if (groups.length === 0) {
-            lines.push("  (no bindings)");
-            continue;
-        }
-        for (const group of groups) {
-            lines.push(`  ${group.event}:`);
-            for (const entry of group.entries) {
-                const parts = [entry.handler];
-                if (entry.matcher)
-                    parts.push(`matcher=${entry.matcher}`);
-                if (entry.timeout)
-                    parts.push(`timeout=${entry.timeout}s`);
-                lines.push(`    - ${parts.join(" ")}`);
-            }
-        }
-    }
-    io.stdout.write(`${lines.join("\n")}\n`);
-    return 0;
-}

package/dist/trace-matrix.d.ts

@@ -1,27 +0,0 @@
-export interface TraceEntry {
-    criterionId: string;
-    taskIds: string[];
-    testSlices: string[];
-    reviewFindings: string[];
-}
-export interface ReviewLoopTraceEntry {
-    stage: "scope" | "design";
-    artifactPath: string;
-    targetScore: number;
-    maxIterations: number;
-    stopReason: "quality_threshold_met" | "max_iterations_reached" | "user_opt_out";
-    finalScore: number;
-    iterations: Array<{
-        iteration: number;
-        qualityScore: number;
-        findingsCount: number;
-    }>;
-}
-export interface TraceMatrix {
-    entries: TraceEntry[];
-    orphanedCriteria: string[];
-    orphanedTasks: string[];
-    orphanedTests: string[];
-    reviewLoops: ReviewLoopTraceEntry[];
-}
-export declare function buildTraceMatrix(projectRoot: string): Promise<TraceMatrix>;

package/dist/trace-matrix.js

@@ -1,226 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { resolveArtifactPath } from "./artifact-paths.js";
-import { RUNTIME_ROOT } from "./constants.js";
-import { extractReviewLoopEnvelopeFromArtifact } from "./content/review-loop.js";
-import { exists } from "./fs-utils.js";
-function activeArtifactPath(projectRoot, name) {
-    return path.join(projectRoot, RUNTIME_ROOT, "artifacts", name);
-}
-async function readArtifact(projectRoot, name) {
-    const candidate = activeArtifactPath(projectRoot, name);
-    if (await exists(candidate)) {
-        return fs.readFile(candidate, "utf8");
-    }
-    return null;
-}
-function uniqPreserve(ids) {
-    const seen = new Set();
-    const out = [];
-    for (const id of ids) {
-        if (!seen.has(id)) {
-            seen.add(id);
-            out.push(id);
-        }
-    }
-    return out;
-}
-function criterionTokens(text) {
-    return text.match(/\bAC-\d+\b/g) ?? [];
-}
-/** AC-1, AC-12, etc. */
-function parseAcceptanceCriterionIds(specMd) {
-    return uniqPreserve(criterionTokens(specMd));
-}
-/** Map task id -> AC ids mentioned on same table row or bullet line as the task. */
-function parsePlanTaskAcLinks(planMd) {
-    const map = new Map();
-    const lines = planMd.split(/\r?\n/);
-    const taskRe = /\b(T-\d+)\b/;
-    const acRe = /\b(AC-\d+)\b/g;
-    for (const line of lines) {
-        const tm = taskRe.exec(line);
-        if (!tm) {
-            continue;
-        }
-        const taskId = tm[1];
-        const acs = [...line.matchAll(acRe)].map((m) => m[0]);
-        if (acs.length === 0) {
-            continue;
-        }
-        const prev = map.get(taskId) ?? [];
-        map.set(taskId, uniqPreserve([...prev, ...acs]));
-    }
-    return map;
-}
-/** All T-N ids appearing in the plan (best-effort). */
-function parsePlanTaskIds(planMd) {
-    const re = /\bT-\d+\b/g;
-    return uniqPreserve(planMd.match(re) ?? []);
-}
-/** Map slice id -> task ids on same line. */
-function parseTddSliceTaskLinks(tddMd) {
-    const map = new Map();
-    const sliceRe = /\b(S-\d+)\b/g;
-    const taskRe = /\b(T-\d+)\b/g;
-    const lines = tddMd.split(/\r?\n/);
-    for (const line of lines) {
-        const slices = [...line.matchAll(sliceRe)].map((m) => m[1]);
-        if (slices.length === 0) {
-            continue;
-        }
-        const tasks = [...line.matchAll(taskRe)].map((m) => m[1]);
-        for (const s of slices) {
-            const prev = map.get(s) ?? [];
-            map.set(s, uniqPreserve([...prev, ...tasks]));
-        }
-    }
-    return map;
-}
-function parseTddSliceIds(tddMd) {
-    return uniqPreserve(tddMd.match(/\bS-\d+\b/g) ?? []);
-}
-/** Body of Layer 1 spec compliance section in 07-review.md */
-function extractLayer1Section(reviewMd) {
-    const lines = reviewMd.split(/\r?\n/);
-    let start = -1;
-    for (let i = 0; i < lines.length; i++) {
-        if (/^##\s+Layer\s*1/i.test(lines[i])) {
-            start = i + 1;
-            break;
-        }
-    }
-    if (start < 0) {
-        return "";
-    }
-    const buf = [];
-    for (let i = start; i < lines.length; i++) {
-        const line = lines[i];
-        if (/^##\s+/.test(line)) {
-            break;
-        }
-        buf.push(line);
-    }
-    return buf.join("\n");
-}
-function layer1LinesForCriterion(layer1, criterionId) {
-    const out = [];
-    for (const line of layer1.split(/\r?\n/)) {
-        if (criterionTokens(line).includes(criterionId)) {
-            out.push(line.trim());
-        }
-    }
-    return out;
-}
-async function readStageArtifact(projectRoot, stage) {
-    let resolved = null;
-    try {
-        resolved = await resolveArtifactPath(stage, {
-            projectRoot,
-            intent: "read"
-        });
-    }
-    catch {
-        resolved = null;
-    }
-    if (!resolved || !(await exists(resolved.absPath))) {
-        return null;
-    }
-    try {
-        const markdown = await fs.readFile(resolved.absPath, "utf8");
-        return { markdown, relPath: resolved.relPath };
-    }
-    catch {
-        return null;
-    }
-}
-async function collectReviewLoopTraceEntries(projectRoot) {
-    const entries = [];
-    for (const stage of ["scope", "design"]) {
-        const artifact = await readStageArtifact(projectRoot, stage);
-        if (!artifact)
-            continue;
-        const envelope = extractReviewLoopEnvelopeFromArtifact(artifact.markdown, stage, artifact.relPath);
-        if (!envelope)
-            continue;
-        const finalScore = envelope.iterations.length > 0
-            ? envelope.iterations[envelope.iterations.length - 1].qualityScore
-            : 0;
-        entries.push({
-            stage,
-            artifactPath: artifact.relPath,
-            targetScore: envelope.targetScore,
-            maxIterations: envelope.maxIterations,
-            stopReason: envelope.stopReason,
-            finalScore,
-            iterations: envelope.iterations.map((row) => ({
-                iteration: row.iteration,
-                qualityScore: row.qualityScore,
-                findingsCount: row.findingsCount
-            }))
-        });
-    }
-    return entries;
-}
-export async function buildTraceMatrix(projectRoot) {
-    const spec = await readArtifact(projectRoot, "04-spec.md");
-    const plan = await readArtifact(projectRoot, "05-plan.md");
-    const tdd = await readArtifact(projectRoot, "06-tdd.md");
-    const review = await readArtifact(projectRoot, "07-review.md");
-    const criterionIds = spec ? parseAcceptanceCriterionIds(spec) : [];
-    const taskToAcs = plan ? parsePlanTaskAcLinks(plan) : new Map();
-    const allTaskIds = plan ? parsePlanTaskIds(plan) : [];
-    const sliceToTasks = tdd ? parseTddSliceTaskLinks(tdd) : new Map();
-    const allSliceIds = tdd ? parseTddSliceIds(tdd) : [];
-    const layer1 = review ? extractLayer1Section(review) : "";
-    const acToTasks = new Map();
-    for (const [task, acs] of taskToAcs) {
-        for (const ac of acs) {
-            const prev = acToTasks.get(ac) ?? new Set();
-            prev.add(task);
-            acToTasks.set(ac, prev);
-        }
-    }
-    const entries = criterionIds.map((criterionId) => {
-        const taskIds = [...(acToTasks.get(criterionId) ?? new Set())];
-        const taskIdSet = new Set(taskIds);
-        const testSlices = [];
-        for (const [slice, tasks] of sliceToTasks) {
-            if (tasks.some((t) => taskIdSet.has(t))) {
-                testSlices.push(slice);
-            }
-        }
-        return {
-            criterionId,
-            taskIds: uniqPreserve(taskIds),
-            testSlices: uniqPreserve(testSlices),
-            reviewFindings: layer1LinesForCriterion(layer1, criterionId)
-        };
-    });
-    const orphanedCriteria = criterionIds.filter((ac) => (acToTasks.get(ac)?.size ?? 0) === 0);
-    const tasksWithSlice = new Set();
-    for (const tasks of sliceToTasks.values()) {
-        for (const t of tasks) {
-            tasksWithSlice.add(t);
-        }
-    }
-    const orphanedTasks = allTaskIds.filter((t) => !tasksWithSlice.has(t));
-    const orphanedTests = allSliceIds.filter((s) => {
-        const tasks = sliceToTasks.get(s) ?? [];
-        if (tasks.length === 0) {
-            return true;
-        }
-        return tasks.every((t) => {
-            const acs = taskToAcs.get(t);
-            return !acs || acs.length === 0;
-        });
-    });
-    const reviewLoops = await collectReviewLoopTraceEntries(projectRoot);
-    return {
-        entries,
-        orphanedCriteria,
-        orphanedTasks,
-        orphanedTests,
-        reviewLoops
-    };
-}