cclaw-cli 7.7.1 → 8.1.1

package/dist/harness-selection.d.ts

@@ -1,31 +0,0 @@
-import { type CliContext, type HarnessId } from "./types.js";
-export type HarnessSelectionAnswer = {
-    kind: "accept";
-} | {
-    kind: "all";
-} | {
-    kind: "toggle";
-    indexes: number[];
-} | {
-    kind: "invalid";
-    message: string;
-};
-export interface HarnessChecklistState {
-    choices: readonly HarnessId[];
-    selected: readonly HarnessId[];
-    cursor: number;
-    message?: string;
-}
-export type HarnessChecklistOutcome = "confirm" | "cancel";
-export interface HarnessChecklistUpdate {
-    state: HarnessChecklistState;
-    outcome?: HarnessChecklistOutcome;
-}
-export declare function parseHarnessSelectionAnswer(raw: string, total?: 4): HarnessSelectionAnswer;
-export declare function createHarnessChecklistState(selected: readonly HarnessId[], choices?: readonly HarnessId[]): HarnessChecklistState;
-export declare function updateHarnessChecklistState(state: HarnessChecklistState, key: string): HarnessChecklistUpdate;
-export declare function promptHarnessSelectionChecklist(defaults: {
-    harnesses: HarnessId[];
-    detectedHarnesses?: HarnessId[];
-    currentHarnesses?: HarnessId[];
-}, ctx: CliContext, label?: string): Promise<HarnessId[]>;

package/dist/harness-selection.js

@@ -1,214 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import process from "node:process";
-import { HARNESS_ADAPTERS } from "./harness-adapters.js";
-import { HARNESS_IDS } from "./types.js";
-export function parseHarnessSelectionAnswer(raw, total = HARNESS_IDS.length) {
-    const answer = raw.trim().toLowerCase();
-    if (answer.length === 0)
-        return { kind: "accept" };
-    if (answer === "all")
-        return { kind: "all" };
-    if (answer === "none") {
-        return { kind: "invalid", message: "Zero harnesses is not supported. Select at least one harness." };
-    }
-    const parts = answer.split(",").map((part) => part.trim()).filter(Boolean);
-    const indexes = parts.map((part) => Number.parseInt(part, 10));
-    if (indexes.some((value) => !Number.isInteger(value) || value < 1 || value > total)) {
-        return { kind: "invalid", message: `Invalid selection. Use numbers 1-${total}, comma-separated.` };
-    }
-    return { kind: "toggle", indexes };
-}
-export function createHarnessChecklistState(selected, choices = HARNESS_IDS) {
-    const validSelected = choices.filter((harness) => selected.includes(harness));
-    return {
-        choices,
-        selected: validSelected.length > 0 ? validSelected : choices.slice(),
-        cursor: 0
-    };
-}
-function moveCursor(state, delta) {
-    const next = (state.cursor + delta + state.choices.length) % state.choices.length;
-    return { ...state, cursor: next, message: undefined };
-}
-function toggleCurrent(state) {
-    const current = state.choices[state.cursor];
-    if (!current)
-        return state;
-    const selected = state.selected.includes(current)
-        ? state.selected.filter((harness) => harness !== current)
-        : [...state.selected, current];
-    return { ...state, selected: state.choices.filter((harness) => selected.includes(harness)), message: undefined };
-}
-export function updateHarnessChecklistState(state, key) {
-    if (key === "\u0003" || key === "\u001b") {
-        return { state: { ...state, message: "Cancelled." }, outcome: "cancel" };
-    }
-    if (key === "\u001b[A" || key === "k" || key === "K") {
-        return { state: moveCursor(state, -1) };
-    }
-    if (key === "\u001b[B" || key === "j" || key === "J") {
-        return { state: moveCursor(state, 1) };
-    }
-    if (key === " ") {
-        return { state: toggleCurrent(state) };
-    }
-    if (key === "a" || key === "A") {
-        return { state: { ...state, selected: state.choices.slice(), message: undefined } };
-    }
-    if (key === "\r" || key === "\n") {
-        if (state.selected.length === 0) {
-            return { state: { ...state, message: "Select at least one harness." } };
-        }
-        return { state, outcome: "confirm" };
-    }
-    return { state };
-}
-function selectedHarnessPreview(harnesses) {
-    return harnesses.length > 0 ? harnesses.join(", ") : "none";
-}
-function harnessLabel(harness) {
-    const adapter = HARNESS_ADAPTERS[harness];
-    const tier = adapter ? `${adapter.reality.declaredSupport}, ${adapter.capabilities.hookSurface} hooks` : "supported";
-    return `${harness} (${tier})`;
-}
-function renderChecklist(state, defaults, ctx, label) {
-    const detected = new Set(defaults.detectedHarnesses ?? []);
-    const current = new Set(defaults.currentHarnesses ?? []);
-    const defaultSet = new Set(defaults.defaultHarnesses ?? []);
-    ctx.stdout.write("\x1b[2J\x1b[H");
-    ctx.stdout.write(`${label}\n`);
-    ctx.stdout.write(`Detected: ${selectedHarnessPreview(defaults.detectedHarnesses ?? [])}\n`);
-    ctx.stdout.write(`Current: ${selectedHarnessPreview(defaults.currentHarnesses ?? [])}\n`);
-    ctx.stdout.write("Use Up/Down or k/j to move, Space to toggle, a to select all, Enter to confirm, Esc to cancel.\n\n");
-    state.choices.forEach((harness, index) => {
-        const adapter = HARNESS_ADAPTERS[harness];
-        const markers = [
-            detected.has(harness) ? "detected" : "",
-            current.has(harness) ? "current" : "",
-            defaultSet.has(harness) ? "default" : ""
-        ].filter(Boolean).join(", ");
-        const pointer = index === state.cursor ? ">" : " ";
-        const checked = state.selected.includes(harness) ? "x" : " ";
-        ctx.stdout.write(`${pointer} [${checked}] ${harnessLabel(harness)} -> ${adapter.commandDir}${markers ? ` (${markers})` : ""}\n`);
-    });
-    if (state.message) {
-        ctx.stdout.write(`\n${state.message}\n`);
-    }
-}
-function rawModeAvailable(ctx) {
-    return Boolean(process.stdin.isTTY &&
-        ctx.stdout.isTTY &&
-        typeof process.stdin.setRawMode === "function");
-}
-async function promptHarnessSelectionRaw(defaults, ctx, label) {
-    let state = createHarnessChecklistState(defaults.harnesses);
-    const input = process.stdin;
-    const wasRaw = Boolean(input.isRaw);
-    let settle;
-    let rejectSelection;
-    const done = new Promise((resolve, reject) => {
-        settle = resolve;
-        rejectSelection = reject;
-    });
-    const onData = (chunk) => {
-        const key = chunk.toString("utf8");
-        const update = updateHarnessChecklistState(state, key);
-        state = update.state;
-        renderChecklist(state, {
-            detectedHarnesses: defaults.detectedHarnesses,
-            currentHarnesses: defaults.currentHarnesses,
-            defaultHarnesses: defaults.harnesses
-        }, ctx, label);
-        if (update.outcome === "confirm") {
-            settle?.(HARNESS_IDS.filter((harness) => state.selected.includes(harness)));
-        }
-        else if (update.outcome === "cancel") {
-            rejectSelection?.(new Error("Harness selection cancelled."));
-        }
-    };
-    try {
-        input.setRawMode?.(true);
-        input.resume();
-        input.on("data", onData);
-        renderChecklist(state, {
-            detectedHarnesses: defaults.detectedHarnesses,
-            currentHarnesses: defaults.currentHarnesses,
-            defaultHarnesses: defaults.harnesses
-        }, ctx, label);
-        return await done;
-    }
-    finally {
-        input.off("data", onData);
-        input.setRawMode?.(wasRaw);
-        if (!wasRaw)
-            input.pause();
-        ctx.stdout.write("\n");
-    }
-}
-async function promptHarnessSelectionText(defaults, ctx, label) {
-    const rl = createInterface({
-        input: process.stdin,
-        output: ctx.stdout
-    });
-    const defaultSet = new Set(defaults.harnesses);
-    const selected = new Set(defaults.harnesses.length > 0 ? defaults.harnesses : HARNESS_IDS);
-    const detected = new Set(defaults.detectedHarnesses ?? []);
-    const current = new Set(defaults.currentHarnesses ?? []);
-    const printMenu = () => {
-        ctx.stdout.write(`\n${label}\n`);
-        ctx.stdout.write(`Detected: ${selectedHarnessPreview(defaults.detectedHarnesses ?? [])}\n`);
-        ctx.stdout.write(`Current: ${selectedHarnessPreview(defaults.currentHarnesses ?? [])}\n`);
-        ctx.stdout.write("Supported harnesses and target paths:\n");
-        HARNESS_IDS.forEach((harness, index) => {
-            const adapter = HARNESS_ADAPTERS[harness];
-            const markers = [
-                detected.has(harness) ? "detected" : "",
-                current.has(harness) ? "current" : "",
-                defaultSet.has(harness) ? "default" : ""
-            ].filter(Boolean).join(", ");
-            const checked = selected.has(harness) ? "x" : " ";
-            ctx.stdout.write(`  ${index + 1}. [${checked}] ${harnessLabel(harness)} -> ${adapter.commandDir}${markers ? ` (${markers})` : ""}\n`);
-        });
-        ctx.stdout.write("Enter numbers to toggle (for example 1,3), 'all', or press Enter to accept.\n");
-    };
-    try {
-        while (true) {
-            printMenu();
-            const answer = await rl.question(`Selected [${[...selected].join(",") || "select at least one"}]: `);
-            const parsedAnswer = parseHarnessSelectionAnswer(answer);
-            if (parsedAnswer.kind === "accept") {
-                if (selected.size === 0) {
-                    ctx.stdout.write("Select at least one harness.\n");
-                    continue;
-                }
-                return HARNESS_IDS.filter((harness) => selected.has(harness));
-            }
-            if (parsedAnswer.kind === "all") {
-                HARNESS_IDS.forEach((harness) => selected.add(harness));
-                continue;
-            }
-            if (parsedAnswer.kind === "invalid") {
-                ctx.stdout.write(`${parsedAnswer.message}\n`);
-                continue;
-            }
-            for (const index of parsedAnswer.indexes) {
-                const harness = HARNESS_IDS[index - 1];
-                if (!harness)
-                    continue;
-                if (selected.has(harness))
-                    selected.delete(harness);
-                else
-                    selected.add(harness);
-            }
-        }
-    }
-    finally {
-        rl.close();
-    }
-}
-export async function promptHarnessSelectionChecklist(defaults, ctx, label = "Harness selection") {
-    if (rawModeAvailable(ctx)) {
-        return promptHarnessSelectionRaw(defaults, ctx, label);
-    }
-    return promptHarnessSelectionText(defaults, ctx, label);
-}

package/dist/hook-schema.d.ts

@@ -1,6 +0,0 @@
-export type HookSchemaHarness = "claude" | "cursor" | "codex";
-export interface HookSchemaValidationResult {
-    ok: boolean;
-    errors: string[];
-}
-export declare function validateHookDocument(harness: HookSchemaHarness, document: unknown): HookSchemaValidationResult;

package/dist/hook-schema.js

@@ -1,114 +0,0 @@
-import claudeHooksSchema from "./hook-schemas/claude-hooks.v1.json" with { type: "json" };
-import codexHooksSchema from "./hook-schemas/codex-hooks.v1.json" with { type: "json" };
-import cursorHooksSchema from "./hook-schemas/cursor-hooks.v1.json" with { type: "json" };
-const SCHEMA_MAP = {
-    claude: claudeHooksSchema,
-    cursor: cursorHooksSchema,
-    codex: codexHooksSchema
-};
-function toObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    return value;
-}
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function isPositiveNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-function validateCursorEvent(eventName, eventEntries, errors) {
-    for (let index = 0; index < eventEntries.length; index += 1) {
-        const rawEntry = eventEntries[index];
-        const entry = toObject(rawEntry);
-        if (!entry) {
-            errors.push(`hooks.${eventName}[${index}] must be an object`);
-            continue;
-        }
-        if (!isNonEmptyString(entry.command)) {
-            errors.push(`hooks.${eventName}[${index}].command must be a non-empty string`);
-        }
-        if (entry.matcher !== undefined && typeof entry.matcher !== "string") {
-            errors.push(`hooks.${eventName}[${index}].matcher must be a string when present`);
-        }
-        if (entry.timeout !== undefined && !isPositiveNumber(entry.timeout)) {
-            errors.push(`hooks.${eventName}[${index}].timeout must be a positive number when present`);
-        }
-    }
-}
-function validateClaudeLikeEvent(eventName, eventEntries, errors) {
-    for (let index = 0; index < eventEntries.length; index += 1) {
-        const rawEntry = eventEntries[index];
-        const entry = toObject(rawEntry);
-        if (!entry) {
-            errors.push(`hooks.${eventName}[${index}] must be an object`);
-            continue;
-        }
-        if (entry.matcher !== undefined && typeof entry.matcher !== "string") {
-            errors.push(`hooks.${eventName}[${index}].matcher must be a string when present`);
-        }
-        if (!Array.isArray(entry.hooks) || entry.hooks.length === 0) {
-            errors.push(`hooks.${eventName}[${index}].hooks must be a non-empty array`);
-            continue;
-        }
-        for (let hookIndex = 0; hookIndex < entry.hooks.length; hookIndex += 1) {
-            const rawHook = entry.hooks[hookIndex];
-            const hook = toObject(rawHook);
-            if (!hook) {
-                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}] must be an object`);
-                continue;
-            }
-            if (hook.type !== "command") {
-                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].type must be "command"`);
-            }
-            if (!isNonEmptyString(hook.command)) {
-                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].command must be a non-empty string`);
-            }
-            if (hook.timeout !== undefined && !isPositiveNumber(hook.timeout)) {
-                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].timeout must be a positive number when present`);
-            }
-            if (hook.statusMessage !== undefined && !isNonEmptyString(hook.statusMessage)) {
-                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].statusMessage must be a non-empty string when present`);
-            }
-        }
-    }
-}
-export function validateHookDocument(harness, document) {
-    const descriptor = SCHEMA_MAP[harness];
-    const root = toObject(document);
-    if (!root) {
-        return { ok: false, errors: ["hook document must be a JSON object"] };
-    }
-    const errors = [];
-    const version = root.cclawHookSchemaVersion;
-    if (version !== descriptor.schemaVersion) {
-        errors.push(`expected cclawHookSchemaVersion=${descriptor.schemaVersion}, got ${JSON.stringify(version)}`);
-    }
-    if (harness === "cursor" && root.version !== 1) {
-        errors.push(`cursor hooks require version=1, got ${JSON.stringify(root.version)}`);
-    }
-    const hooks = toObject(root.hooks);
-    if (!hooks) {
-        errors.push("missing hooks object");
-    }
-    else {
-        for (const eventName of descriptor.requiredEvents) {
-            const eventValue = hooks[eventName];
-            if (!Array.isArray(eventValue) || eventValue.length === 0) {
-                errors.push(`missing required event array "${eventName}"`);
-                continue;
-            }
-            if (harness === "cursor") {
-                validateCursorEvent(eventName, eventValue, errors);
-            }
-            else {
-                validateClaudeLikeEvent(eventName, eventValue, errors);
-            }
-        }
-    }
-    return {
-        ok: errors.length === 0,
-        errors
-    };
-}

package/dist/hook-schemas/claude-hooks.v1.json

@@ -1,10 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "cclaw://hooks/claude/v1",
-    "harness": "claude",
-    "schemaVersion": 2,
-    "requiredEvents": [
-        "SessionStart",
-        "Stop"
-    ]
-}

package/dist/hook-schemas/codex-hooks.v1.json

@@ -1,10 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "cclaw://hooks/codex/v1",
-    "harness": "codex",
-    "schemaVersion": 2,
-    "requiredEvents": [
-        "SessionStart",
-        "Stop"
-    ]
-}

package/dist/hook-schemas/cursor-hooks.v1.json

@@ -1,13 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "cclaw://hooks/cursor/v1",
-    "harness": "cursor",
-    "schemaVersion": 2,
-    "requiredEvents": [
-        "sessionStart",
-        "sessionResume",
-        "sessionClear",
-        "sessionCompact",
-        "stop"
-    ]
-}

package/dist/init-detect.d.ts

@@ -1,2 +0,0 @@
-import type { HarnessId } from "./types.js";
-export declare function detectHarnesses(projectRoot: string): Promise<HarnessId[]>;

package/dist/init-detect.js

@@ -1,50 +0,0 @@
-import path from "node:path";
-import { exists } from "./fs-utils.js";
-export async function detectHarnesses(projectRoot) {
-    const detected = [];
-    const claudeHints = [
-        path.join(projectRoot, ".claude"),
-        path.join(projectRoot, "CLAUDE.md")
-    ];
-    if (await anyExists(claudeHints)) {
-        detected.push("claude");
-    }
-    const cursorHints = [
-        path.join(projectRoot, ".cursor"),
-        path.join(projectRoot, ".cursor/rules")
-    ];
-    if (await anyExists(cursorHints)) {
-        detected.push("cursor");
-    }
-    const opencodeHints = [
-        path.join(projectRoot, ".opencode"),
-        path.join(projectRoot, "opencode.json"),
-        path.join(projectRoot, "opencode.jsonc"),
-        path.join(projectRoot, ".opencode/opencode.json"),
-        path.join(projectRoot, ".opencode/opencode.jsonc")
-    ];
-    if (await anyExists(opencodeHints)) {
-        detected.push("opencode");
-    }
-    // Codex CLI doesn't require a persistent per-project directory. We
-    // detect via `.agents/skills/` (the universal path Codex 0.89+ reads;
-    // Jan 2026) or the legacy `.codex/` marker left by pre-v0.39 cclaw.
-    // AGENTS.md is intentionally *not* a codex hint because every other
-    // harness in cclaw's list also reads AGENTS.md.
-    const codexHints = [
-        path.join(projectRoot, ".agents/skills"),
-        path.join(projectRoot, ".codex")
-    ];
-    if (await anyExists(codexHints)) {
-        detected.push("codex");
-    }
-    return detected;
-}
-async function anyExists(paths) {
-    for (const candidate of paths) {
-        if (await exists(candidate)) {
-            return true;
-        }
-    }
-    return false;
-}

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

@@ -1,89 +0,0 @@
-import { type FlowState } from "../../flow-state.js";
-import { type FlowStage } from "../../types.js";
-import type { AdvanceStageArgs } from "./parsers.js";
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-interface InternalValidationReport {
-    ok: boolean;
-    stage: FlowStage;
-    delegation: {
-        satisfied: boolean;
-        missing: string[];
-        waived: string[];
-        missingEvidence: string[];
-        missingDispatchProof: string[];
-        legacyInferredCompletions: string[];
-        corruptEventLines: number[];
-        staleWorkers: string[];
-        expectedMode: string;
-        /** True when mandatoryAgentsFor returned [] for the run's track / taskClass. */
-        skippedByTrack: boolean;
-    };
-    gates: {
-        ok: boolean;
-        complete: boolean;
-        issues: string[];
-        missingRequired: string[];
-        missingTriggeredConditional: string[];
-    };
-    completedStages: {
-        ok: boolean;
-        issues: string[];
-    };
-}
-/**
- * entry point — auto-hydrate evidence for an auto-hydratable
- * gate that the agent already included in --passed but for which they
- * forgot to provide --evidence-json. Returns silently when no
- * hydration is possible (no auto-hydratable gate, no artifact, no
- * envelope, etc.).
- *
- * layered `tryAutoHydrateAndSelectReviewLoopGate` on
- * top of this so the gate is also auto-included in selectedGateIds
- * when the artifact yields a valid envelope. Together the two helpers
- * remove the contradiction:
- *   - "omit this gate from --evidence-json so stage-complete can
- *      auto-hydrate it" → "missing --evidence-json entries for passed
- *      gates: design_diagram_freshness".
- */
-export declare function hydrateReviewLoopEvidenceFromArtifact(projectRoot: string, stage: FlowStage, track: FlowState["track"], selectedGateIds: string[], evidenceByGate: Record<string, string>): Promise<void>;
-/**
- * auto-include an auto-hydratable review-loop gate
- * in `selectedGateIds` when:
- *   - The stage has an auto-hydratable gate registered via
- *     `AUTO_REVIEW_LOOP_GATE_BY_STAGE` (currently `design`).
- *   - The artifact yields a valid review-loop envelope via
- *     `extractReviewLoopEnvelopeFromArtifact`.
- *   - The gate is required for the active track.
- *   - The agent has NOT passed the gate yet (so we don't double-add).
- *
- * Returns the (possibly extended) array of selected gate IDs and
- * mutates `evidenceByGate` to include the hydrated envelope.
- *
- * Together with `hydrateReviewLoopEvidenceFromArtifact` this makes the
- * flow consistent: if the artifact contains the envelope, the agent
- * neither has to include the gate in --passed nor pass --evidence-json
- * for it. If the artifact does NOT contain the envelope, the agent
- * gets a clear error pointing at the artifact section to add (via
- * `reviewLoopArtifactFixHint`).
- */
-export declare function tryAutoHydrateAndSelectReviewLoopGate(projectRoot: string, stage: FlowStage, track: FlowState["track"], requiredGateIds: string[], selectedGateIds: string[], evidenceByGate: Record<string, string>): Promise<string[]>;
-export declare function buildValidationReport(projectRoot: string, flowState: FlowState, options?: {
-    allowBlockedReviewRoute?: boolean;
-    extraStageFlags?: string[];
-}): Promise<InternalValidationReport>;
-interface HarvestLearningsResult {
-    ok: boolean;
-    markerWritten: boolean;
-    parsedEntries: number;
-    appendedEntries: number;
-    skippedDuplicates: number;
-    details: string;
-}
-export declare function withLearningsHarvestMarker(artifactMarkdown: string, appendedEntries: number, skippedDuplicates: number): string;
-export declare function harvestStageLearnings(projectRoot: string, stage: FlowStage, track: FlowState["track"]): Promise<HarvestLearningsResult>;
-export declare function runAdvanceStage(projectRoot: string, args: AdvanceStageArgs, io: InternalIo): Promise<number>;
-export {};