cclaw-cli 7.7.1 → 8.1.1

package/dist/internal/early-loop-status.js

@@ -1,93 +0,0 @@
-import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
-import { clampEarlyLoopStatusForWrite, computeEarlyLoopStatus, formatEarlyLoopStatusLine, isEarlyLoopStage } from "../early-loop.js";
-import { writeFileSafe } from "../fs-utils.js";
-import { readFlowState } from "../runs.js";
-function parseArgs(tokens) {
-    const args = { json: false, quiet: false, write: true };
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        const nextToken = tokens[index + 1];
-        if (token === "--json") {
-            args.json = true;
-            continue;
-        }
-        if (token === "--quiet") {
-            args.quiet = true;
-            continue;
-        }
-        if (token === "--write") {
-            args.write = true;
-            continue;
-        }
-        if (token === "--no-write") {
-            args.write = false;
-            continue;
-        }
-        if (token === "--stage") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--stage requires a value: brainstorm | scope | design");
-            }
-            if (!isEarlyLoopStage(nextToken)) {
-                throw new Error("--stage must be one of: brainstorm, scope, design");
-            }
-            args.stage = nextToken;
-            index += 1;
-            continue;
-        }
-        if (token.startsWith("--stage=")) {
-            const stageRaw = token.slice("--stage=".length);
-            if (!isEarlyLoopStage(stageRaw)) {
-                throw new Error("--stage must be one of: brainstorm, scope, design");
-            }
-            args.stage = stageRaw;
-            continue;
-        }
-        if (token === "--run-id") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--run-id requires a value.");
-            }
-            args.runId = nextToken.trim();
-            index += 1;
-            continue;
-        }
-        if (token.startsWith("--run-id=")) {
-            args.runId = token.slice("--run-id=".length).trim();
-            continue;
-        }
-        throw new Error(`Unknown early-loop-status flag: ${token}`);
-    }
-    return args;
-}
-function stateDir(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state");
-}
-export async function runEarlyLoopStatusCommand(projectRoot, argv, io) {
-    const args = parseArgs(argv);
-    const flow = await readFlowState(projectRoot).catch(() => null);
-    const stage = args.stage ?? flow?.currentStage;
-    if (!isEarlyLoopStage(stage)) {
-        io.stderr.write("cclaw internal early-loop-status: current stage is not an early-loop stage. Pass --stage=brainstorm|scope|design.\n");
-        return 1;
-    }
-    const runId = (args.runId ?? flow?.activeRunId ?? "active").trim() || "active";
-    let status = await computeEarlyLoopStatus(stage, runId, path.join(stateDir(projectRoot), "early-loop-log.jsonl"));
-    const persisted = clampEarlyLoopStatusForWrite(status);
-    if (persisted.clampedFrom !== null) {
-        io.stderr.write(`cclaw internal early-loop-status: early-loop iteration ${persisted.clampedFrom} exceeds maxIterations ${status.maxIterations}; clamping before write.\n`);
-        status = persisted.status;
-    }
-    if (args.write) {
-        const target = path.join(stateDir(projectRoot), "early-loop.json");
-        await writeFileSafe(target, `${JSON.stringify(status, null, 2)}\n`);
-    }
-    if (!args.quiet) {
-        if (args.json) {
-            io.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
-        }
-        else {
-            io.stdout.write(`${formatEarlyLoopStatusLine(status)}\n`);
-        }
-    }
-    return 0;
-}

package/dist/internal/envelope-validate.d.ts

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

package/dist/internal/envelope-validate.js

@@ -1,66 +0,0 @@
-import fs from "node:fs/promises";
-import { parseSkillEnvelope, validateSkillEnvelope } from "../content/stage-schema.js";
-function parseArgs(tokens) {
-    const args = { stdin: false, quiet: false };
-    for (const token of tokens) {
-        if (token === "--stdin") {
-            args.stdin = true;
-            continue;
-        }
-        if (token === "--quiet") {
-            args.quiet = true;
-            continue;
-        }
-        if (token.startsWith("--json=")) {
-            args.json = token.replace("--json=", "");
-            continue;
-        }
-        if (token.startsWith("--file=")) {
-            args.file = token.replace("--file=", "");
-            continue;
-        }
-        throw new Error(`Unknown flag for envelope-validate: ${token}`);
-    }
-    return args;
-}
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
-    }
-    return Buffer.concat(chunks).toString("utf8");
-}
-export async function runEnvelopeValidateCommand(_projectRoot, tokens, io) {
-    const args = parseArgs(tokens);
-    let raw = "";
-    if (args.json !== undefined) {
-        raw = args.json;
-    }
-    else if (args.file !== undefined) {
-        raw = await fs.readFile(args.file, "utf8");
-    }
-    else if (args.stdin) {
-        raw = await readStdin();
-    }
-    else {
-        throw new Error("Provide one source: --json=<payload> | --file=<path> | --stdin");
-    }
-    const parsed = parseSkillEnvelope(raw);
-    if (parsed) {
-        if (!args.quiet) {
-            io.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
-        }
-        return 0;
-    }
-    let candidate;
-    try {
-        candidate = JSON.parse(raw);
-    }
-    catch (error) {
-        io.stderr.write(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
-    }
-    const validation = validateSkillEnvelope(candidate);
-    io.stderr.write(`Invalid envelope: ${validation.errors.join(" ")}\n`);
-    return 1;
-}

package/dist/internal/flow-state-repair.d.ts

@@ -1,20 +0,0 @@
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export interface FlowStateRepairArgs {
-    reason: string;
-    json: boolean;
-    quiet: boolean;
-    /**
-     * when true, normalize `state/early-loop.json` to the canonical
-     * shape derived from `early-loop-log.jsonl`. Lets operators recover from
-     * legacy hand-written `early-loop.json` files that drifted from the
-     * source-of-truth log.
-     */
-    earlyLoop: boolean;
-}
-export declare function parseFlowStateRepairArgs(tokens: string[]): FlowStateRepairArgs;
-export declare function runFlowStateRepair(projectRoot: string, args: FlowStateRepairArgs, io: InternalIo): Promise<number>;
-export {};

package/dist/internal/flow-state-repair.js

@@ -1,104 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
-import { clampEarlyLoopStatusForWrite, computeEarlyLoopStatus, isEarlyLoopStage } from "../early-loop.js";
-import { writeFileSafe } from "../fs-utils.js";
-import { repairFlowStateGuard } from "../run-persistence.js";
-import { readFlowState } from "../runs.js";
-export function parseFlowStateRepairArgs(tokens) {
-    let reason;
-    let json = false;
-    let quiet = false;
-    let earlyLoop = false;
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        const nextToken = tokens[i + 1];
-        if (token === "--json") {
-            json = true;
-            continue;
-        }
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token === "--early-loop") {
-            earlyLoop = true;
-            continue;
-        }
-        if (token === "--reason") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--reason requires a short slug value.");
-            }
-            reason = nextToken.trim();
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--reason=")) {
-            reason = token.slice("--reason=".length).trim();
-            continue;
-        }
-        throw new Error(`Unknown flag for internal flow-state-repair: ${token}`);
-    }
-    if (!reason || reason.length === 0) {
-        throw new Error("internal flow-state-repair requires --reason=<slug> (e.g. --reason=manual_edit_recovery).");
-    }
-    return { reason, json, quiet, earlyLoop };
-}
-async function repairEarlyLoopFile(projectRoot, io) {
-    const flow = await readFlowState(projectRoot).catch(() => null);
-    if (!flow) {
-        return { performed: false, skipped: "flow-state-unreadable" };
-    }
-    const stage = flow.currentStage;
-    if (!isEarlyLoopStage(stage)) {
-        return { performed: false, skipped: `current-stage-${stage}-not-early-loop` };
-    }
-    const runId = flow.activeRunId.trim();
-    if (runId.length === 0) {
-        io.stderr.write("cclaw internal flow-state-repair --early-loop: active run has no runId; cannot derive canonical early-loop.json.\n");
-        return { performed: false, skipped: "missing-active-runId" };
-    }
-    const stateDir = path.join(projectRoot, RUNTIME_ROOT, "state");
-    const logPath = path.join(stateDir, "early-loop-log.jsonl");
-    const status = await computeEarlyLoopStatus(stage, runId, logPath);
-    const persisted = clampEarlyLoopStatusForWrite(status);
-    const finalStatus = persisted.status;
-    const target = path.join(stateDir, "early-loop.json");
-    await writeFileSafe(target, `${JSON.stringify(finalStatus, null, 2)}\n`);
-    return {
-        performed: true,
-        stage,
-        runId,
-        iteration: finalStatus.iteration,
-        openConcernCount: finalStatus.openConcerns.length
-    };
-}
-export async function runFlowStateRepair(projectRoot, args, io) {
-    const result = await repairFlowStateGuard(projectRoot, args.reason);
-    const logRel = path.relative(projectRoot, result.repairLogPath).replace(/\\/gu, "/");
-    const guardRel = path.relative(projectRoot, result.guardPath).replace(/\\/gu, "/");
-    let earlyLoopOutcome = null;
-    if (args.earlyLoop) {
-        earlyLoopOutcome = await repairEarlyLoopFile(projectRoot, io);
-    }
-    void fs;
-    const payload = {
-        ok: true,
-        command: "flow-state-repair",
-        reason: args.reason,
-        sidecar: result.sidecar,
-        guardPath: guardRel,
-        repairLogPath: logRel,
-        completedStageMetaBackfilled: result.completedStageMetaBackfilled,
-        earlyLoop: earlyLoopOutcome,
-        runtimeRoot: RUNTIME_ROOT
-    };
-    if (args.json) {
-        io.stdout.write(`${JSON.stringify(payload)}\n`);
-        return 0;
-    }
-    if (!args.quiet) {
-        io.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    }
-    return 0;
-}

package/dist/internal/plan-split-waves.d.ts

@@ -1,190 +0,0 @@
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-/**
- * split a large `05-plan.md` Implementation Units section
- * into wave-NN.md sub-files so an executor can carry one wave at a time
- * without re-reading the whole plan.
- *
- * Threshold contract:
- *   - total units < SMALL_PLAN_THRESHOLD → no-op, exit 0.
- *   - total units >= SMALL_PLAN_THRESHOLD → split into waves of `--wave-size`
- *     (default 25).
- *
- * Files written:
- *   - `<artifacts-dir>/wave-plans/wave-NN.md` per wave (1-indexed).
- *   - In-place update to `05-plan.md` adding (or refreshing) a
- *     `## Wave Plans` section between
- *     `<!-- wave-split-managed-start -->` and `<!-- wave-split-managed-end -->`
- *     markers. Outside-marker content is preserved verbatim.
- *
- * `--dry-run` prints the plan but does not write. `--force` overwrites
- * existing wave files; without it, the command refuses to clobber.
- */
-export interface PlanSplitWavesArgs {
-    waveSize: number;
-    dryRun: boolean;
-    force: boolean;
-    json: boolean;
-}
-export declare const PLAN_SPLIT_DEFAULT_WAVE_SIZE = 5;
-export declare const PLAN_SPLIT_SMALL_PLAN_THRESHOLD = 50;
-/** Member line in Parallel Execution Plan or wave-NN.md */
-export interface ParsedParallelWaveMember {
-    sliceId: string;
-    unitId: string;
-}
-export interface ParsedParallelWave {
-    waveId: string;
-    members: ParsedParallelWaveMember[];
-}
-export declare class WavePlanDuplicateSliceError extends Error {
-    constructor(message: string);
-}
-export declare class WavePlanMergeConflictError extends Error {
-    constructor(message: string);
-}
-/**
- * Raw body between parallel execution managed markers (no markers included).
- */
-export declare function extractParallelExecutionManagedBody(planMarkdown: string): string | null;
-/**
- * Members list after `Members:` in Parallel Execution Plan / wave-NN headers.
- * Supports markdown bold `**Members:**` (colon between Members and closing `**`)
- * and plain `Members:`.
- */
-export declare function extractMembersListFromLine(trimmedLine: string): string | null;
-/**
- * Extract a `(sliceId, unitId)` pair from a markdown table data row
- * whose first column is an `S-NN` token. Used by the wave parser to
- * recognize the table-format Parallel Execution Plan alongside (or
- * instead of) the `**Members:**` bullet line.
- *
- * Rules:
- * - The line must start with `|` (after trimming).
- * - Column 1 (after stripping markdown noise) may be either a slice id
- *   (`S-N`) or an implementation-unit id (`U-N`). Unit ids derive their
- *   execution slice as `S-N`, which lets 7.7+ plans schedule feature-atomic
- *   units without inventing a tiny `T-NNN` row per dispatch lane. Header rows
- *   (`| sliceId | …`, `| unit | …`) and separator rows (`|---|---|…`) are
- *   silently skipped.
- * - Column 2, when present and non-empty, becomes the `unitId`
- *   verbatim (after stripping whitespace + backticks/quotes/brackets).
- *   This lets authors record task ids (`T-010`, `T-008a`, …) in the
- *   `unit` column without forcing a `U-NN` derivation.
- * - When column 2 is absent or empty, fall back to the
- *   `S-NN → U-NN` derivation so the `**Members:**` parser path stays
- *   bit-identical for non-table plans.
- */
-export declare function parseTableRowMember(trimmedLine: string): ParsedParallelWaveMember | null;
-/**
- * Parse `## Parallel Execution Plan` managed block for wave headings and
- * member declarations. Recognizes BOTH the `**Members:**` / `Members:`
- * line shape AND the markdown-table shape
- * (`| sliceId | unit | dependsOn | …`).
- *
- * Wave headings accepted (case-insensitive, trailing text allowed):
- * - `### Wave 04`
- * - `### Wave W-04`
- * - `### Wave W-04 — after fan-in W-03 (5 lanes …)`
- *
- * Within a single wave the parser dedupes by `sliceId`: if the same
- * slice appears in both `**Members:**` and a table row, the first
- * occurrence wins (line-order). Cross-wave duplicates still throw
- * `WavePlanDuplicateSliceError`.
- *
- * Malformed member tokens are skipped. Empty waves (heading present
- * but neither a Members line nor any matching `| S-NN |` row found
- * before the next heading) are RETURNED with `members: []` so callers
- * can surface the boundary; classification is up to the caller.
- */
-export declare function parseParallelExecutionPlanWaves(planMarkdown: string): ParsedParallelWave[];
-/**
- * Parse a single wave-NN.md: prefer a `Members:` line in the header; otherwise
- * collect distinct S-N tokens in the first lines (legacy).
- */
-export declare function parseWavePlanFileBody(body: string, waveId: string): ParsedParallelWave;
-export declare function parseWavePlanDirectory(artifactsDir: string): Promise<ParsedParallelWave[]>;
-/**
- * Merge wave definitions: managed Parallel Execution Plan first, then wave-NN.md.
- * Same slice must map to the same wave id and unit id in both sources or a
- * `WavePlanMergeConflictError` is thrown.
- */
-export declare function mergeParallelWaveDefinitions(primary: ParsedParallelWave[], secondary: ParsedParallelWave[]): ParsedParallelWave[];
-/**
- * One-line operator hint after sync when a multi-member wave exists.
- */
-export declare function formatNextParallelWaveSyncHint(merged: ParsedParallelWave[]): string | null;
-export interface ParsedImplementationUnit {
-    id: string;
-    /**
-     * The full markdown body of this unit, starting at the
-     * `### Implementation Unit U-N` heading and ending right before the
-     * next unit heading (or the next `## ` H2, or end of file).
-     */
-    body: string;
-    /** Repo-relative path declarations from the optional `Files:` line. */
-    paths: string[];
-}
-export interface ImplementationUnitParallelFields {
-    unitId: string;
-    dependsOn: string[];
-    claimedPaths: string[];
-    parallelizable: boolean;
-    riskTier: "low" | "standard" | "high";
-    lane?: string;
-}
-export interface ParseImplementationUnitParallelOptions {
-    /**
-     * Continuation: when the plan predates explicit parallel
-     * bullets, units without a `parallelizable:` line default to serial eligibility
-     * in the scheduler (`parallelizable: false`).
-     */
-    legacyParallelDefaultSerial?: boolean;
-}
-/**
- * Parse parallel-metadata bullets from an implementation unit body.
- * Missing keys use conservative defaults (`dependsOn: []`, `parallelizable: true`
- * unless `legacyParallelDefaultSerial` is set).
- */
-export declare function parseImplementationUnitParallelFields(unit: ParsedImplementationUnit, options?: ParseImplementationUnitParallelOptions): ImplementationUnitParallelFields;
-/**
- * True when the plan has implementation units but any unit is missing
- * `dependsOn` / `claimedPaths` / `parallelizable` / `riskTier` bullets.
- */
-export declare function planArtifactLacksV613ParallelMetadata(planMarkdown: string): boolean;
-export declare function compareCanonicalUnitIds(a: string, b: string): number;
-/**
- * Group implementation units into waves: topological order, then greedy
- * placement with disjoint `claimedPaths` and `cap` members per wave.
- */
-export declare function buildConflictAwareWavesFromUnits(units: ParsedImplementationUnit[], cap: number): ParsedImplementationUnit[][];
-export declare function buildParallelExecutionPlanSection(waves: ParsedImplementationUnit[][], cap: number): string;
-/**
- * Replace or append the managed Parallel Execution Plan block.
- */
-export declare function upsertParallelExecutionPlanSection(planMarkdown: string, managedBlock: string): string;
-/**
- * Parse `## Implementation Units` section into individual unit blocks.
- * Recognizes the canonical heading shape in the TDD-velocity plan template
- * (`### Implementation Unit U-<n>`). Tolerant of `Files:` listed either
- * inline or as a `- **Files (...):**` bullet block.
- */
-export declare function parseImplementationUnits(planMarkdown: string): ParsedImplementationUnit[];
-/**
- * Pull repo-relative paths from a `Files:` line or the `Files (...)` bullet
- * block. Both shapes appear in the wild; the parser extracts after the colon
- * and splits on commas. Empty/whitespace items are dropped.
- */
-export declare function extractPathsLine(unitBody: string): string[];
-export declare function parsePlanSplitWavesArgs(tokens: string[]): PlanSplitWavesArgs;
-/**
- * Replace any existing managed Wave Plans block with the new one, or append
- * it at the end of the file when no markers are present yet. The helper
- * never touches text outside the markers.
- */
-export declare function upsertWavePlansSection(planMarkdown: string, managedBlock: string): string;
-export declare function runPlanSplitWaves(projectRoot: string, args: PlanSplitWavesArgs, io: InternalIo): Promise<number>;
-export {};