cclaw-cli 7.7.1 → 8.1.1

package/dist/internal/advance-stage/cancel-run.js

@@ -1,19 +0,0 @@
-import { archiveRun } from "../../runs.js";
-export async function runCancelRun(projectRoot, args, io) {
-    const archived = await archiveRun(projectRoot, args.name, {
-        disposition: args.disposition,
-        dispositionReason: args.reason
-    });
-    if (!args.quiet) {
-        io.stdout.write(`${JSON.stringify({
-            ok: true,
-            command: "cancel-run",
-            disposition: archived.disposition,
-            reason: archived.dispositionReason ?? args.reason,
-            archiveId: archived.archiveId,
-            archivePath: archived.archivePath,
-            resetRunId: archived.resetState.activeRunId
-        }, null, 2)}\n`);
-    }
-    return 0;
-}

package/dist/internal/advance-stage/flow-state-coercion.d.ts

@@ -1,3 +0,0 @@
-import { type FlowState } from "../../flow-state.js";
-export declare function parseCandidateGateCatalog(value: unknown, fallback: FlowState["stageGateCatalog"]): FlowState["stageGateCatalog"];
-export declare function coerceCandidateFlowState(raw: unknown, fallback: FlowState): FlowState;

package/dist/internal/advance-stage/flow-state-coercion.js

@@ -1,81 +0,0 @@
-import { FLOW_STAGES } from "../../types.js";
-import { isFlowTrack } from "../../flow-state.js";
-import { emptyGateState, isFlowStageValue, parseGuardEvidence, parseStringList, unique } from "./helpers.js";
-export function parseCandidateGateCatalog(value, fallback) {
-    const next = {};
-    for (const stage of FLOW_STAGES) {
-        // Guard against stale on-disk flow-state files that persisted a partial
-        // stageGateCatalog (missing a stage key). Previously `fallback[stage]`
-        // could be undefined and the spread below would throw at runtime.
-        const base = fallback[stage] ?? emptyGateState();
-        next[stage] = {
-            required: [...base.required],
-            recommended: [...base.recommended],
-            conditional: [...base.conditional],
-            triggered: [...base.triggered],
-            passed: [...base.passed],
-            blocked: [...base.blocked]
-        };
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return next;
-    }
-    const rawCatalog = value;
-    for (const stage of FLOW_STAGES) {
-        const rawStage = rawCatalog[stage];
-        if (!rawStage || typeof rawStage !== "object" || Array.isArray(rawStage)) {
-            continue;
-        }
-        const typed = rawStage;
-        const base = fallback[stage] ?? emptyGateState();
-        const allowed = new Set([...base.required, ...base.recommended, ...base.conditional]);
-        const conditional = new Set(base.conditional);
-        const passed = unique(parseStringList(typed.passed)).filter((gateId) => allowed.has(gateId));
-        const blocked = unique(parseStringList(typed.blocked)).filter((gateId) => allowed.has(gateId));
-        const triggered = unique([
-            ...parseStringList(typed.triggered).filter((gateId) => conditional.has(gateId)),
-            ...passed.filter((gateId) => conditional.has(gateId)),
-            ...blocked.filter((gateId) => conditional.has(gateId))
-        ]);
-        next[stage] = {
-            required: [...base.required],
-            recommended: [...base.recommended],
-            conditional: [...base.conditional],
-            triggered,
-            passed,
-            blocked
-        };
-    }
-    return next;
-}
-export function coerceCandidateFlowState(raw, fallback) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return fallback;
-    }
-    const typed = raw;
-    const track = isFlowTrack(typed.track) ? typed.track : fallback.track;
-    const currentStage = isFlowStageValue(typed.currentStage)
-        ? typed.currentStage
-        : fallback.currentStage;
-    const completedStages = unique(parseStringList(typed.completedStages).filter((stage) => isFlowStageValue(stage)));
-    const skippedStagesRaw = parseStringList(typed.skippedStages).filter((stage) => isFlowStageValue(stage));
-    const skippedStages = skippedStagesRaw.length > 0 ? skippedStagesRaw : fallback.skippedStages;
-    // When the candidate payload omits `guardEvidence` entirely we must keep
-    // the on-disk fallback — otherwise a partial update (e.g. a tooling call
-    // that only passes stage + passedGateIds) would silently wipe every
-    // previously recorded evidence string and fail the next
-    // `verifyCurrentStageGateEvidence` check.
-    const candidateEvidence = parseGuardEvidence(typed.guardEvidence);
-    const guardEvidence = typed.guardEvidence === undefined
-        ? { ...fallback.guardEvidence }
-        : candidateEvidence;
-    return {
-        ...fallback,
-        currentStage,
-        completedStages,
-        track,
-        skippedStages,
-        guardEvidence,
-        stageGateCatalog: parseCandidateGateCatalog(typed.stageGateCatalog, fallback.stageGateCatalog)
-    };
-}

package/dist/internal/advance-stage/helpers.d.ts

@@ -1,14 +0,0 @@
-import { type FlowStage } from "../../types.js";
-import { type StageGateState } from "../../flow-state.js";
-export declare function unique<T extends string>(values: T[]): T[];
-export declare function asRecord(value: unknown): Record<string, unknown> | null;
-export declare function parseStringList(raw: unknown): string[];
-export declare function isFlowStageValue(value: unknown): value is FlowStage;
-export declare function parseGuardEvidence(value: unknown): Record<string, string>;
-export declare function emptyGateState(): StageGateState;
-export declare function stringifyGateEvidenceValue(value: unknown): string;
-export declare function parseEvidenceByGate(raw: string | undefined): Record<string, string>;
-export declare function parseCsv(raw: string | undefined): string[];
-export declare function pathExists(projectRoot: string, relPath: string): Promise<boolean>;
-export declare function listExistingFiles(projectRoot: string, relPaths: string[]): Promise<string[]>;
-export declare function listFilesUnder(projectRoot: string, relDir: string, limit?: number): Promise<string[]>;

package/dist/internal/advance-stage/helpers.js

@@ -1,145 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { FLOW_STAGES } from "../../types.js";
-export function unique(values) {
-    return [...new Set(values)];
-}
-export function asRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    return value;
-}
-export function parseStringList(raw) {
-    if (!Array.isArray(raw))
-        return [];
-    return raw
-        .filter((item) => typeof item === "string")
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-}
-export function isFlowStageValue(value) {
-    return typeof value === "string" && FLOW_STAGES.includes(value);
-}
-export function parseGuardEvidence(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-    }
-    const next = {};
-    for (const [key, raw] of Object.entries(value)) {
-        if (typeof raw !== "string")
-            continue;
-        const trimmed = raw.trim();
-        if (trimmed.length === 0)
-            continue;
-        next[key] = trimmed;
-    }
-    return next;
-}
-export function emptyGateState() {
-    return {
-        required: [],
-        recommended: [],
-        conditional: [],
-        triggered: [],
-        passed: [],
-        blocked: []
-    };
-}
-export function stringifyGateEvidenceValue(value) {
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "boolean")
-        return value ? "passed" : "failed";
-    if (typeof value === "number" || typeof value === "bigint")
-        return String(value);
-    if (value === null || value === undefined)
-        return "";
-    if (typeof value === "object")
-        return JSON.stringify(value);
-    return String(value);
-}
-export function parseEvidenceByGate(raw) {
-    if (!raw || raw.trim().length === 0) {
-        return {};
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`--evidence-json must be valid JSON object: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("--evidence-json must deserialize to an object.");
-    }
-    const next = {};
-    for (const [key, value] of Object.entries(parsed)) {
-        const normalized = stringifyGateEvidenceValue(value).trim();
-        if (normalized.length === 0)
-            continue;
-        next[key] = normalized;
-    }
-    return next;
-}
-export function parseCsv(raw) {
-    if (!raw)
-        return [];
-    return raw
-        .split(",")
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-}
-export async function pathExists(projectRoot, relPath) {
-    try {
-        await fs.stat(path.join(projectRoot, relPath));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function listExistingFiles(projectRoot, relPaths) {
-    const matches = [];
-    for (const relPath of relPaths) {
-        try {
-            const stat = await fs.stat(path.join(projectRoot, relPath));
-            if (stat.isFile())
-                matches.push(relPath);
-        }
-        catch {
-            // continue
-        }
-    }
-    return matches;
-}
-export async function listFilesUnder(projectRoot, relDir, limit = 20) {
-    const root = path.join(projectRoot, relDir);
-    const out = [];
-    async function walk(absDir) {
-        if (out.length >= limit)
-            return;
-        let entries;
-        try {
-            entries = await fs.readdir(absDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (out.length >= limit)
-                return;
-            if (entry.name.startsWith("."))
-                continue;
-            const abs = path.join(absDir, entry.name);
-            if (entry.isDirectory()) {
-                await walk(abs);
-            }
-            else if (entry.isFile()) {
-                out.push(path.relative(projectRoot, abs).split(path.sep).join("/"));
-            }
-        }
-    }
-    await walk(root);
-    return out;
-}

package/dist/internal/advance-stage/hook.d.ts

@@ -1,8 +0,0 @@
-import type { HookArgs } from "./parsers.js";
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export declare function runHookCommand(projectRoot: string, args: HookArgs, io: InternalIo): Promise<number>;
-export {};

package/dist/internal/advance-stage/hook.js

@@ -1,40 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import process from "node:process";
-import { RUNTIME_ROOT } from "../../constants.js";
-export async function runHookCommand(projectRoot, args, io) {
-    const runHookPath = path.join(projectRoot, RUNTIME_ROOT, "hooks", "run-hook.mjs");
-    try {
-        await fs.access(runHookPath);
-    }
-    catch {
-        io.stderr.write(`cclaw internal hook: missing hook runtime at ${runHookPath}. Run \`cclaw sync\` first.\n`);
-        return 1;
-    }
-    return await new Promise((resolve) => {
-        const child = spawn(process.execPath, [runHookPath, args.hookName], {
-            cwd: projectRoot,
-            env: process.env,
-            stdio: ["inherit", "pipe", "pipe"]
-        });
-        child.stdout.on("data", (chunk) => {
-            io.stdout.write(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            io.stderr.write(chunk);
-        });
-        child.on("error", (err) => {
-            io.stderr.write(`cclaw internal hook: failed to launch runtime (${err instanceof Error ? err.message : String(err)}).\n`);
-            resolve(1);
-        });
-        child.on("close", (code, signal) => {
-            if (signal) {
-                io.stderr.write(`cclaw internal hook: runtime terminated by signal ${signal}.\n`);
-                resolve(1);
-                return;
-            }
-            resolve(typeof code === "number" ? code : 1);
-        });
-    });
-}

package/dist/internal/advance-stage/parsers.d.ts

@@ -1,72 +0,0 @@
-import { type DiscoveryMode, type FlowStage, type FlowTrack } from "../../types.js";
-import type { ArchiveDisposition } from "../../runs.js";
-export interface AdvanceStageArgs {
-    stage: FlowStage;
-    passedGateIds: string[];
-    evidenceByGate: Record<string, string>;
-    waiveDelegations: string[];
-    waiverReason?: string;
-    acceptProactiveWaiver: boolean;
-    acceptProactiveWaiverReason?: string;
-    /**
-     * Approval token issued by `cclaw-cli internal waiver-grant`. Required
-     * (via `--accept-proactive-waiver=<token>`) whenever the caller asserts
-     * `acceptProactiveWaiver`. Legacy `--accept-proactive-waiver` without a
-     * token is still parsed but rejected downstream by the advance-stage
-     * handler so operators see the error at runtime.
-     */
-    acceptProactiveWaiverToken?: string;
-    skipQuestions: boolean;
-    quiet: boolean;
-    json: boolean;
-}
-export interface VerifyFlowStateDiffArgs {
-    afterJson?: string;
-    afterFile?: string;
-    quiet: boolean;
-}
-export interface VerifyCurrentStateArgs {
-    quiet: boolean;
-}
-export interface HookArgs {
-    hookName: string;
-}
-export interface RewindArgs {
-    mode: "rewind" | "ack";
-    targetStage: FlowStage;
-    reason?: string;
-    quiet: boolean;
-    json: boolean;
-}
-export interface StartFlowArgs {
-    track: FlowTrack;
-    discoveryMode: DiscoveryMode;
-    className?: string;
-    prompt?: string;
-    reason?: string;
-    stack?: string;
-    forceReset: boolean;
-    reclassify: boolean;
-    quiet: boolean;
-    /**
-     * `/cc-ideate` handoff carry-forward.
-     * Workspace-relative POSIX path to `.cclaw/ideas/idea-YYYY-MM-DD-<slug>.md`
-     * (or wherever `/cc-ideate` wrote its artifact).
-     */
-    fromIdeaArtifact?: string;
-    /** Optional `I-#` row id chosen from the idea artifact's ranked list. */
-    fromIdeaCandidateId?: string;
-}
-export interface CancelRunArgs {
-    reason: string;
-    disposition: Extract<ArchiveDisposition, "cancelled" | "abandoned">;
-    name?: string;
-    quiet: boolean;
-}
-export declare function parseAdvanceStageArgs(tokens: string[]): AdvanceStageArgs;
-export declare function parseVerifyFlowStateDiffArgs(tokens: string[]): VerifyFlowStateDiffArgs;
-export declare function parseVerifyCurrentStateArgs(tokens: string[]): VerifyCurrentStateArgs;
-export declare function parseRewindArgs(tokens: string[]): RewindArgs;
-export declare function parseHookArgs(tokens: string[]): HookArgs;
-export declare function parseStartFlowArgs(tokens: string[]): StartFlowArgs;
-export declare function parseCancelRunArgs(tokens: string[]): CancelRunArgs;