cclaw-cli 7.7.0 → 8.1.0

package/dist/internal/wave-status.js

@@ -1,450 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
-import { readDelegationEvents, readDelegationLedger } from "../delegation.js";
-import { readFlowState } from "../runs.js";
-import { DEFAULT_SLICE_STREAM_REL_PATH, readEventStreamFile } from "../streaming/event-stream.js";
-import { readConfig, resolveExecutionStrictness, resolveExecutionTopology, resolveMaxBuilders } from "../config.js";
-import { routeExecutionTopology } from "../execution-topology.js";
-import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "./plan-split-waves.js";
-import { compareSliceIds, parseSliceId } from "../util/slice-id.js";
-const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
-const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
-function parseArgs(tokens) {
-    const args = { format: "json", streamMode: "auto" };
-    for (const token of tokens) {
-        if (token === "--json")
-            args.format = "json";
-        else if (token === "--human" || token === "--text")
-            args.format = "human";
-        else if (token === "--live")
-            args.streamMode = "live";
-        else if (token === "--file-only")
-            args.streamMode = "file";
-        else if (token.startsWith("--format=")) {
-            const raw = token.slice("--format=".length).trim();
-            if (raw === "json" || raw === "human")
-                args.format = raw;
-            else
-                throw new Error(`Unknown wave-status --format value: ${raw}`);
-        }
-        else if (token.startsWith("--stream-mode=")) {
-            const raw = token.slice("--stream-mode=".length).trim();
-            if (raw === "auto" || raw === "live" || raw === "file")
-                args.streamMode = raw;
-            else
-                throw new Error(`Unknown wave-status --stream-mode value: ${raw}`);
-        }
-        else {
-            throw new Error(`Unknown wave-status flag: ${token}`);
-        }
-    }
-    return args;
-}
-function classifyWaveStatus(total, closedCount) {
-    if (total === 0)
-        return "empty";
-    if (closedCount === 0)
-        return "open";
-    if (closedCount >= total)
-        return "closed";
-    return "partial";
-}
-function parsePipeRow(trimmedLine) {
-    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
-    return inner.split("|").map((cell) => cell.trim());
-}
-function normalizePathToken(raw) {
-    return raw.trim().replace(/^`|`$/gu, "").replace(/^\.\/+/u, "");
-}
-function parseManagedWaveClaimedPaths(planMarkdown) {
-    const out = new Map();
-    const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
-    const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
-    if (startIdx < 0 || endIdx <= startIdx)
-        return out;
-    const body = planMarkdown.slice(startIdx + PARALLEL_EXEC_MANAGED_START.length, endIdx);
-    const lines = body.split(/\r?\n/u);
-    let currentWaveId = null;
-    let headerIdx = new Map();
-    for (const rawLine of lines) {
-        const trimmed = rawLine.trim();
-        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
-        if (waveMatch) {
-            currentWaveId = `W-${waveMatch[1].padStart(2, "0")}`;
-            if (!out.has(currentWaveId)) {
-                out.set(currentWaveId, new Map());
-            }
-            headerIdx = new Map();
-            continue;
-        }
-        if (!currentWaveId || !trimmed.startsWith("|"))
-            continue;
-        const cells = parsePipeRow(trimmed);
-        if (cells.length === 0)
-            continue;
-        const first = cells[0].toLowerCase();
-        if (first === "sliceid" ||
-            first === "slice id" ||
-            first === "unitid" ||
-            first === "unit id" ||
-            first === "unit") {
-            headerIdx = new Map();
-            for (let i = 0; i < cells.length; i += 1) {
-                const key = cells[i].toLowerCase().replace(/[^a-z0-9]/gu, "");
-                if (key.length > 0 && !headerIdx.has(key)) {
-                    headerIdx.set(key, i);
-                }
-            }
-            continue;
-        }
-        if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
-            continue;
-        }
-        const firstCell = (cells[0] ?? "").replace(/^`|`$/gu, "").trim();
-        const parsedSlice = parseSliceId(firstCell);
-        const parsedUnit = /^U-(\d+(?:[a-z][a-z0-9]*)?)$/iu.exec(firstCell);
-        if (!parsedSlice && !parsedUnit)
-            continue;
-        const sliceId = parsedSlice?.id ?? `S-${parsedUnit[1].toLowerCase()}`;
-        const pathsIdx = headerIdx.get("claimedpaths");
-        const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
-        const claimedPaths = rawPaths.length === 0
-            ? []
-            : rawPaths
-                .split(",")
-                .map((p) => normalizePathToken(p))
-                .filter((p) => p.length > 0);
-        out.get(currentWaveId).set(sliceId, claimedPaths);
-    }
-    return out;
-}
-function detectPathConflicts(readySlices, bySlice) {
-    const conflicts = new Set();
-    const ordered = [...readySlices].sort(compareSliceIds);
-    for (let i = 0; i < ordered.length; i += 1) {
-        const leftSlice = ordered[i];
-        const leftPaths = bySlice.get(leftSlice) ?? [];
-        if (leftPaths.length === 0)
-            continue;
-        const leftSet = new Set(leftPaths);
-        for (let j = i + 1; j < ordered.length; j += 1) {
-            const rightSlice = ordered[j];
-            const rightPaths = bySlice.get(rightSlice) ?? [];
-            if (rightPaths.length === 0)
-                continue;
-            for (const pathToken of rightPaths) {
-                if (!leftSet.has(pathToken))
-                    continue;
-                conflicts.add(`${leftSlice}:${pathToken}`);
-                conflicts.add(`${rightSlice}:${pathToken}`);
-            }
-        }
-    }
-    return [...conflicts].sort();
-}
-const TERMINAL_PHASES = new Set([
-    "refactor",
-    "refactor-deferred",
-    "resolve-conflict"
-]);
-/**
- * Deterministic helper for the TDD controller. Reads the managed
- * `<!-- parallel-exec-managed-start -->` block from
- * `<artifacts-dir>/05-plan.md` plus the `wave-plans/` directory and
- * reports waves + the next dispatchable members so the controller does
- * NOT have to page through a long plan to find the active wave.
- *
- * Always exits 0 unless the plan is malformed (no managed block AND no
- * wave-plans directory), in which case exit 2 with a structured error.
- */
-export async function runWaveStatus(projectRoot, options = {}) {
-    const artifactsDir = options.artifactsDir ?? path.join(projectRoot, RUNTIME_ROOT, "artifacts");
-    const flowState = await readFlowState(projectRoot).catch(() => null);
-    const activeRunId = flowState?.activeRunId ?? "unknown-run";
-    const currentStage = flowState?.currentStage ?? "tdd";
-    let planRaw = "";
-    try {
-        planRaw = await fs.readFile(path.join(artifactsDir, "05-plan.md"), "utf8");
-    }
-    catch {
-        planRaw = "";
-    }
-    let primaryWaves = [];
-    try {
-        primaryWaves = parseParallelExecutionPlanWaves(planRaw);
-    }
-    catch (err) {
-        return {
-            activeRunId,
-            currentStage,
-            waves: [],
-            nextDispatch: {
-                waveId: null,
-                readyToDispatch: [],
-                pathConflicts: [],
-                mode: "none",
-                topology: "none",
-                topologyReason: "wave plan could not be parsed",
-                maxBuilders: 0
-            },
-            warnings: [
-                `wave_plan_parse_error: ${err instanceof Error ? err.message : String(err)}`
-            ]
-        };
-    }
-    let secondaryWaves = [];
-    try {
-        secondaryWaves = await parseWavePlanDirectory(artifactsDir);
-    }
-    catch (err) {
-        secondaryWaves = [];
-        void err;
-    }
-    let merged = [];
-    try {
-        merged = mergeParallelWaveDefinitions(primaryWaves, secondaryWaves);
-    }
-    catch (err) {
-        return {
-            activeRunId,
-            currentStage,
-            waves: [],
-            nextDispatch: {
-                waveId: null,
-                readyToDispatch: [],
-                pathConflicts: [],
-                mode: "none",
-                topology: "none",
-                topologyReason: "wave plan sources conflict",
-                maxBuilders: 0
-            },
-            warnings: [
-                `wave_plan_merge_conflict: ${err instanceof Error ? err.message : String(err)}`
-            ]
-        };
-    }
-    // Collect closed slice ids from the active run delegation ledger +
-    // events. A slice is "closed" once it carries a terminal phase
-    // (refactor, refactor-deferred, resolve-conflict) OR a phase=green
-    // event with `refactorOutcome` recorded inline. Anything else we treat
-    // as still open so the helper never falsely advances.
-    const closedSlices = new Set();
-    let ledgerEntries = [];
-    try {
-        const ledger = await readDelegationLedger(projectRoot);
-        ledgerEntries = ledger.entries.filter((entry) => entry.runId === ledger.runId && entry.stage === "tdd");
-    }
-    catch {
-        ledgerEntries = [];
-    }
-    for (const entry of ledgerEntries) {
-        if (entry.status !== "completed")
-            continue;
-        if (typeof entry.sliceId !== "string")
-            continue;
-        if (typeof entry.phase !== "string")
-            continue;
-        if (TERMINAL_PHASES.has(entry.phase)) {
-            closedSlices.add(entry.sliceId);
-            continue;
-        }
-        if (entry.phase === "green" && entry.refactorOutcome) {
-            const mode = entry.refactorOutcome.mode;
-            if (mode === "inline" || mode === "deferred") {
-                closedSlices.add(entry.sliceId);
-            }
-        }
-    }
-    const warnings = [];
-    const streamMode = options.streamMode ?? "auto";
-    const streamPath = options.streamPath ?? path.join(projectRoot, DEFAULT_SLICE_STREAM_REL_PATH);
-    let shouldReadJsonlFallback = streamMode === "file";
-    // Prefer live stream events when requested/available.
-    if (streamMode !== "file") {
-        const streamResult = await readEventStreamFile(streamPath);
-        if (streamResult.droppedLines > 0) {
-            warnings.push(`wave_stream_dropped_lines: ${streamResult.droppedLines}`);
-        }
-        if (streamResult.events.length > 0) {
-            for (const ev of streamResult.events) {
-                if (ev.runId && ev.runId !== activeRunId)
-                    continue;
-                if (ev.stage && ev.stage !== "tdd")
-                    continue;
-                if (TERMINAL_PHASES.has(ev.phase)) {
-                    closedSlices.add(ev.sliceId);
-                    continue;
-                }
-                if (ev.phase === "green" && ev.refactorOutcome) {
-                    const mode = ev.refactorOutcome.mode;
-                    if (mode === "inline" || mode === "deferred") {
-                        closedSlices.add(ev.sliceId);
-                    }
-                }
-            }
-            shouldReadJsonlFallback = false;
-        }
-        else {
-            shouldReadJsonlFallback = true;
-            if (streamMode === "auto" || streamMode === "live") {
-                warnings.push("wave_status_live_fallback_to_file: no parseable stream events");
-            }
-        }
-    }
-    // Fallback to JSONL events when live stream is absent or disabled.
-    if (shouldReadJsonlFallback) {
-        try {
-            const { events } = await readDelegationEvents(projectRoot);
-            for (const ev of events) {
-                if (ev.event !== "completed")
-                    continue;
-                if (ev.runId !== activeRunId)
-                    continue;
-                if (ev.stage !== "tdd")
-                    continue;
-                if (typeof ev.sliceId !== "string")
-                    continue;
-                if (typeof ev.phase !== "string")
-                    continue;
-                if (TERMINAL_PHASES.has(ev.phase)) {
-                    closedSlices.add(ev.sliceId);
-                    continue;
-                }
-                if (ev.phase === "green" && ev.refactorOutcome) {
-                    const mode = ev.refactorOutcome.mode;
-                    if (mode === "inline" || mode === "deferred") {
-                        closedSlices.add(ev.sliceId);
-                    }
-                }
-            }
-        }
-        catch {
-            // best-effort; ledger already covers the canonical case.
-        }
-    }
-    const waves = merged.map((wave) => {
-        const members = wave.members.map((m) => m.sliceId);
-        const closedMembers = members.filter((id) => closedSlices.has(id));
-        const openMembers = members.filter((id) => !closedSlices.has(id));
-        return {
-            waveId: wave.waveId,
-            members,
-            closedMembers,
-            openMembers,
-            readyMembers: openMembers,
-            blockedMembers: [],
-            status: classifyWaveStatus(members.length, closedMembers.length)
-        };
-    });
-    const firstOpenWave = waves.find((w) => w.status === "open" || w.status === "partial") ?? null;
-    if (merged.length === 0 && planRaw.length === 0) {
-        warnings.push("wave_plan_missing: 05-plan.md not found or empty under <artifacts-dir>.");
-    }
-    else if (merged.length === 0) {
-        warnings.push("wave_plan_managed_block_missing: <!-- parallel-exec-managed-start --> block not found in 05-plan.md and wave-plans/ has no parseable wave files.");
-    }
-    let nextDispatch;
-    const config = await readConfig(projectRoot).catch(() => null);
-    const configuredTopology = resolveExecutionTopology(config);
-    const strictness = resolveExecutionStrictness(config);
-    const maxBuilders = resolveMaxBuilders(config);
-    if (firstOpenWave === null) {
-        nextDispatch = {
-            waveId: null,
-            readyToDispatch: [],
-            pathConflicts: [],
-            mode: "none",
-            topology: "none",
-            topologyReason: "no open wave has ready units",
-            maxBuilders
-        };
-    }
-    else {
-        const readyToDispatch = [...firstOpenWave.readyMembers].sort(compareSliceIds);
-        const claimedPathsByWave = parseManagedWaveClaimedPaths(planRaw);
-        const conflicts = detectPathConflicts(readyToDispatch, claimedPathsByWave.get(firstOpenWave.waveId) ?? new Map());
-        const mode = conflicts.length > 0
-            ? "blocked"
-            : readyToDispatch.length > 1
-                ? "wave-fanout"
-                : readyToDispatch.length === 1
-                    ? "single-slice"
-                    : "none";
-        const topologyDecision = mode === "none"
-            ? null
-            : routeExecutionTopology({
-                configuredTopology,
-                strictness,
-                maxBuilders,
-                shape: {
-                    unitCount: readyToDispatch.length,
-                    independentUnitCount: conflicts.length > 0 ? 0 : readyToDispatch.length,
-                    substantialUnitCount: readyToDispatch.length,
-                    hasPathConflicts: conflicts.length > 0,
-                    inlineSafe: false
-                }
-            });
-        nextDispatch = {
-            waveId: firstOpenWave.waveId,
-            readyToDispatch,
-            pathConflicts: conflicts,
-            mode,
-            topology: topologyDecision?.topology ?? "none",
-            topologyReason: topologyDecision?.reason ?? "no ready units",
-            maxBuilders: topologyDecision?.maxBuilders ?? maxBuilders
-        };
-    }
-    return {
-        activeRunId,
-        currentStage,
-        waves,
-        nextDispatch,
-        warnings
-    };
-}
-function formatHumanReport(report) {
-    const lines = [];
-    lines.push(`activeRunId: ${report.activeRunId}`);
-    lines.push(`currentStage: ${report.currentStage}`);
-    lines.push("waves:");
-    if (report.waves.length === 0) {
-        lines.push("  (no waves discovered)");
-    }
-    else {
-        for (const wave of report.waves) {
-            lines.push(`  ${wave.waveId} [${wave.status}]: ` +
-                `closed=[${wave.closedMembers.join(",")}] ` +
-                `open=[${wave.openMembers.join(",")}]`);
-        }
-    }
-    lines.push(`nextDispatch: wave=${report.nextDispatch.waveId ?? "(none)"} ` +
-        `mode=${report.nextDispatch.mode} ` +
-        `topology=${report.nextDispatch.topology} ` +
-        `ready=[${report.nextDispatch.readyToDispatch.join(",")}]`);
-    if (report.warnings.length > 0) {
-        lines.push("warnings:");
-        for (const warn of report.warnings) {
-            lines.push(`  - ${warn}`);
-        }
-    }
-    return lines.join("\n") + "\n";
-}
-export async function runWaveStatusCommand(projectRoot, argv, io) {
-    let parsed;
-    try {
-        parsed = parseArgs(argv);
-    }
-    catch (err) {
-        io.stderr.write(`cclaw internal wave-status: ${err instanceof Error ? err.message : String(err)}\n`);
-        return 1;
-    }
-    const report = await runWaveStatus(projectRoot, { streamMode: parsed.streamMode });
-    if (parsed.format === "json") {
-        io.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    }
-    else {
-        io.stdout.write(formatHumanReport(report));
-    }
-    return 0;
-}

package/dist/managed-resources.d.ts

@@ -1,53 +0,0 @@
-import { type HarnessId } from "./types.js";
-import type { WriteFileSafeOptions } from "./fs-utils.js";
-export declare const MANAGED_RESOURCE_MANIFEST_REL_PATH = ".cclaw/state/managed-resources.json";
-export interface ManagedResourceEntry {
-    path: string;
-    sha256: string;
-    owner: "cclaw";
-    harness?: HarnessId | "core";
-    packageVersion: string;
-    prunable: boolean;
-    safeToOverwrite: boolean;
-    updatedAt: string;
-    lastBackupPath?: string;
-    previousSha256?: string;
-}
-export interface ManagedResourceManifest {
-    version: 1;
-    generatedAt: string;
-    packageVersion: string;
-    resources: ManagedResourceEntry[];
-}
-interface ManagedResourceSessionOptions {
-    projectRoot: string;
-    operation: string;
-}
-export interface ManagedResourceValidationIssue {
-    index?: number;
-    path?: string;
-    field: string;
-    message: string;
-}
-export declare function isManagedGeneratedPath(relPath: string): boolean;
-export declare function validateManagedResourceEntry(value: unknown, index?: number): ManagedResourceValidationIssue[];
-export declare function validateManagedResourceManifest(value: unknown): ManagedResourceValidationIssue[];
-export declare function isValidManagedResourceEntry(value: unknown): value is ManagedResourceEntry;
-export declare function readManagedResourceManifest(projectRoot: string): Promise<ManagedResourceManifest | null>;
-export declare class ManagedResourceSession {
-    private readonly projectRoot;
-    private readonly operation;
-    private readonly timestamp;
-    private readonly previous;
-    private readonly touched;
-    private constructor();
-    static create(options: ManagedResourceSessionOptions): Promise<ManagedResourceSession>;
-    shouldManage(filePath: string): boolean;
-    writeFileSafe(filePath: string, content: string, options?: WriteFileSafeOptions): Promise<void>;
-    commit(): Promise<ManagedResourceManifest>;
-}
-export declare function getActiveManagedResourceSession(): ManagedResourceSession | null;
-export declare function setActiveManagedResourceSession(session: ManagedResourceSession | null): void;
-export declare function isManagedResourcePath(projectRoot: string, filePath: string): boolean;
-export declare function hashManagedResourceContent(content: string | Buffer): string;
-export {};