cclaw-cli 7.7.1 → 8.1.1

package/dist/logger.js

@@ -1,6 +1,15 @@
-export function info(ctx, message) {
-    ctx.stdout.write(`[cclaw] ${message}\n`);
+let stdout = process.stdout;
+let stderr = process.stderr;
+export function configureLogger(out, err) {
+    stdout = out;
+    stderr = err;
 }
-export function error(ctx, message) {
-    ctx.stderr.write(`[cclaw:error] ${message}\n`);
+export function info(message) {
+    stdout.write(`${message}\n`);
+}
+export function warn(message) {
+    stderr.write(`${message}\n`);
+}
+export function error(message) {
+    stderr.write(`${message}\n`);
 }

package/dist/orchestrator-routing.d.ts

@@ -0,0 +1,29 @@
+import { type ArtifactFrontmatter } from "./artifact-frontmatter.js";
+import type { RoutingClass } from "./types.js";
+export interface ExistingPlanMatch {
+    slug: string;
+    origin: "active" | "shipped" | "cancelled";
+    filePath: string;
+    score: number;
+    frontmatter?: ArtifactFrontmatter;
+    acProgress?: {
+        committed: number;
+        pending: number;
+        total: number;
+    };
+    lastSpecialist?: ArtifactFrontmatter["last_specialist"];
+    refines?: string | null;
+    securityFlag?: boolean;
+}
+export interface RoutingClassification {
+    class: RoutingClass;
+    signals: string[];
+    notes: string[];
+}
+export declare function classifyRouting(task: string): RoutingClassification;
+export declare function findMatchingPlans(projectRoot: string, task: string): Promise<ExistingPlanMatch[]>;
+export interface RoutingProposal {
+    classification: RoutingClassification;
+    matches: ExistingPlanMatch[];
+}
+export declare function proposeRouting(projectRoot: string, task: string): Promise<RoutingProposal>;

package/dist/orchestrator-routing.js

@@ -0,0 +1,156 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { slugifyArtifactTopic } from "./artifact-paths.js";
+import { exists, listSubdirs } from "./fs-utils.js";
+import { CANCELLED_DIR_REL_PATH, FLOWS_ROOT, SHIPPED_DIR_REL_PATH } from "./constants.js";
+import { parseArtifact } from "./artifact-frontmatter.js";
+const STOP_WORDS = new Set([
+    "the", "a", "an", "to", "of", "in", "on", "for", "and", "or", "is", "are",
+    "with", "from", "this", "that", "it", "i", "we", "you", "be", "will",
+    "make", "do", "have", "has", "should", "could", "would", "can", "let", "let's"
+]);
+const TRIVIAL_SIGNALS = /(?:typo|rename file|rename function|reformat|format only|fix indent|copy edit|copy-edit|wording|comment fix|wording in)/iu;
+const LARGE_SIGNALS = /(?:refactor|migration|architecture|architectur(?:al|y)|multi[- ]component|across (?:the |multiple )|whole (?:project|app|service|backend|frontend)|across services|saga|distributed|threat model|security[- ]critical|payment|auth(?:entication)?|authoriz(?:ation|ation)|gdpr|pci|sso|sensitive data)/iu;
+export function classifyRouting(task) {
+    const text = task.trim();
+    const signals = [];
+    const notes = [];
+    if (LARGE_SIGNALS.test(text))
+        signals.push("large-keyword");
+    if (TRIVIAL_SIGNALS.test(text) && text.length < 200)
+        signals.push("trivial-keyword");
+    if (text.split(/\s+/u).length > 60)
+        signals.push("long-prompt");
+    if (/(\band\b.*){3,}/iu.test(text))
+        signals.push("multi-and");
+    if (signals.includes("large-keyword"))
+        notes.push("matched architectural / sensitive keyword");
+    if (signals.includes("multi-and"))
+        notes.push("multiple `and` connectors suggest >1 task");
+    if (signals.includes("long-prompt"))
+        notes.push("prompt longer than 60 words");
+    if (signals.includes("trivial-keyword"))
+        notes.push("matched trivial keyword");
+    if (signals.includes("large-keyword") || signals.includes("multi-and") || signals.includes("long-prompt")) {
+        return { class: "large-risky", signals, notes };
+    }
+    if (signals.includes("trivial-keyword")) {
+        return { class: "trivial", signals, notes };
+    }
+    return { class: "small-medium", signals, notes };
+}
+function tokenize(value, limit = 4096) {
+    return new Set(value
+        .slice(0, limit)
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/gu, " ")
+        .split(/\s+/u)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 2 && !STOP_WORDS.has(part)));
+}
+function jaccard(left, right) {
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const value of left)
+        if (right.has(value))
+            intersection += 1;
+    const union = left.size + right.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+async function readBody(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function summariseAc(ac) {
+    if (!Array.isArray(ac))
+        return { committed: 0, pending: 0, total: 0 };
+    const committed = ac.filter((item) => item.status === "committed").length;
+    return { committed, pending: ac.length - committed, total: ac.length };
+}
+async function tryParseFrontmatter(filePath) {
+    const raw = await readBody(filePath);
+    if (!raw)
+        return null;
+    try {
+        return parseArtifact(raw, filePath).frontmatter;
+    }
+    catch {
+        return null;
+    }
+}
+async function buildMatch(filePath, origin, taskSlugTokens, taskWords) {
+    const slug = path.basename(path.dirname(filePath));
+    const slugScore = jaccard(taskSlugTokens, new Set(slug.split("-")));
+    const body = await readBody(filePath);
+    const bodyScore = jaccard(taskWords, tokenize(body));
+    const score = Math.max(slugScore, bodyScore);
+    const threshold = origin === "active" ? 0.15 : 0.16;
+    if (score < threshold)
+        return null;
+    const frontmatter = (await tryParseFrontmatter(filePath)) ?? undefined;
+    return {
+        slug,
+        origin,
+        filePath,
+        score,
+        frontmatter,
+        acProgress: frontmatter ? summariseAc(frontmatter.ac) : undefined,
+        lastSpecialist: frontmatter?.last_specialist ?? null,
+        refines: frontmatter?.refines ?? null,
+        securityFlag: frontmatter?.security_flag === true
+    };
+}
+const RESERVED_FLOW_DIRS = new Set(["shipped", "cancelled"]);
+export async function findMatchingPlans(projectRoot, task) {
+    const taskWords = tokenize(task);
+    const slugFromTask = slugifyArtifactTopic(task);
+    const taskSlugTokens = new Set(slugFromTask.split("-"));
+    const matches = [];
+    const flowsRoot = path.join(projectRoot, FLOWS_ROOT);
+    if (await exists(flowsRoot)) {
+        for (const dir of await listSubdirs(flowsRoot)) {
+            const dirName = path.basename(dir);
+            if (RESERVED_FLOW_DIRS.has(dirName))
+                continue;
+            const planPath = path.join(dir, "plan.md");
+            if (!(await exists(planPath)))
+                continue;
+            const match = await buildMatch(planPath, "active", taskSlugTokens, taskWords);
+            if (match)
+                matches.push(match);
+        }
+    }
+    const shippedRoot = path.join(projectRoot, SHIPPED_DIR_REL_PATH);
+    if (await exists(shippedRoot)) {
+        for (const dir of await listSubdirs(shippedRoot)) {
+            const planPath = path.join(dir, "plan.md");
+            if (!(await exists(planPath)))
+                continue;
+            const match = await buildMatch(planPath, "shipped", taskSlugTokens, taskWords);
+            if (match)
+                matches.push(match);
+        }
+    }
+    const cancelledRoot = path.join(projectRoot, CANCELLED_DIR_REL_PATH);
+    if (await exists(cancelledRoot)) {
+        for (const dir of await listSubdirs(cancelledRoot)) {
+            const planPath = path.join(dir, "plan.md");
+            if (!(await exists(planPath)))
+                continue;
+            const match = await buildMatch(planPath, "cancelled", taskSlugTokens, taskWords);
+            if (match)
+                matches.push(match);
+        }
+    }
+    return matches.sort((a, b) => b.score - a.score);
+}
+export async function proposeRouting(projectRoot, task) {
+    const classification = classifyRouting(task);
+    const matches = await findMatchingPlans(projectRoot, task);
+    return { classification, matches };
+}

package/dist/run-persistence.d.ts

@@ -1,118 +1,7 @@
-import { type FlowState } from "./flow-state.js";
-import type { FlowStage } from "./types.js";
-export declare class InvalidStageTransitionError extends Error {
-    readonly from: FlowStage;
-    readonly to: FlowStage;
-    constructor(from: FlowStage, to: FlowStage, message: string);
-}
-export interface WriteFlowStateOptions {
-    /**
-     * When true, skip prior-state validation. Used for run archival, initial
-     * bootstrap, or explicit recovery; never set from normal stage handlers.
-     */
-    allowReset?: boolean;
-    /**
-     * When true, skip the internal directory-lock acquisition. The caller
-     * MUST already hold `flowStateLockPath(projectRoot)` for the duration
-     * of this call. Used by run-archive to keep the full archive +
-     * flow-state reset inside one atomic lock window.
-     */
-    skipLock?: boolean;
-    /**
-     * Free-form writer identifier persisted in the `.flow-state.guard.json`
-     * sidecar. Helps operators trace which subsystem wrote a given state
-     * (e.g. `advance-stage`, `start-flow`, `run-archive`). Defaults to
-     * `cclaw-cli` when omitted.
-     */
-    writerSubsystem?: string;
-}
-export interface ReadFlowStateOptions {
-    /**
-     * Reserved compatibility switch from older runtimes. The repair layer was removed,
-     * so this flag is now a no-op and only preserved for API stability.
-     */
-    repairFeatureSystem?: boolean;
-}
-export interface FlowStateGuardSidecar {
-    sha256: string;
-    writtenAt: string;
-    writerSubsystem: string;
-    runId: string;
-}
-export interface FlowStateGuardMismatchDetails {
-    expectedSha: string;
-    actualSha: string;
-    lastWriter: string;
-    writtenAt: string;
-    runId: string;
-    statePath: string;
-    guardPath: string;
-    repairCommand: string;
-}
-export declare class FlowStateGuardMismatchError extends Error {
-    readonly expectedSha: string;
-    readonly actualSha: string;
-    readonly lastWriter: string;
-    readonly writtenAt: string;
-    readonly runId: string;
-    readonly statePath: string;
-    readonly guardPath: string;
-    readonly repairCommand: string;
-    constructor(details: FlowStateGuardMismatchDetails);
-}
-export declare class CorruptFlowStateError extends Error {
-    readonly statePath: string;
-    readonly quarantinedPath: string;
-    constructor(statePath: string, quarantinedPath: string, cause: unknown);
-}
-/**
- * Verify the on-disk flow-state against the sha256 sidecar. Throws
- * `FlowStateGuardMismatchError` when manual editing is detected. Safe to
- * call on projects that have never written a sidecar: a missing sidecar is
- * treated as "legacy runtime" and the check silently succeeds.
- */
-export declare function verifyFlowStateGuard(projectRoot: string): Promise<void>;
-export declare function readFlowState(projectRoot: string, options?: ReadFlowStateOptions): Promise<FlowState>;
-/**
- * Guarded read wrapper used by runtime hook scripts and the repair CLI.
- * Unlike `readFlowState`, it enforces the sha256 sidecar before returning:
- * a manual edit to flow-state.json fails fast with
- * `FlowStateGuardMismatchError`.
- */
-export declare function readFlowStateGuarded(projectRoot: string, options?: ReadFlowStateOptions): Promise<FlowState>;
-export declare function writeFlowState(projectRoot: string, state: FlowState, options?: WriteFlowStateOptions): Promise<void>;
-/**
- * Named entry point for the write-guard workstream. Equivalent to
- * `writeFlowState`: the write always produces the sha256 sidecar via
- * the internal implementation so every existing writer inherits the
- * guard without rewriting callsites.
- */
-export declare function writeFlowStateGuarded(projectRoot: string, state: FlowState, options?: WriteFlowStateOptions): Promise<void>;
-export interface FlowStateRepairResult {
-    sidecar: FlowStateGuardSidecar;
-    repairLogPath: string;
-    guardPath: string;
-    /** Stages that were retro-backfilled into completedStageMeta during repair. */
-    completedStageMetaBackfilled: FlowStage[];
-}
-/**
- * Recompute the write-guard sidecar from the current on-disk flow-state
- * contents and append an audit entry to `.cclaw/.flow-state-repair.log`.
- * The reason is required so no repair happens without an operator-visible
- * rationale. Intended to be called only from the explicit
- * `cclaw-cli internal flow-state-repair` subcommand.
- */
-export declare function repairFlowStateGuard(projectRoot: string, reason: string): Promise<FlowStateRepairResult>;
-export declare function flowStateGuardSidecarPathFor(projectRoot: string): string;
-export declare function flowStateRepairLogPathFor(projectRoot: string): string;
-/**
- * Exposed path helper so callers that need to serialize a multi-step
- * state operation with flow-state writes (e.g. run archival) can
- * acquire the SAME lock directory used internally by `writeFlowState`.
- */
-export declare function flowStateLockPathFor(projectRoot: string): string;
-interface EnsureRunSystemOptions {
-    createIfMissing?: boolean;
-}
-export declare function ensureRunSystem(projectRoot: string, options?: EnsureRunSystemOptions): Promise<FlowState>;
-export {};
+import { type FlowStateV8 } from "./flow-state.js";
+export declare function flowStatePath(projectRoot: string): string;
+export declare function ensureRunSystem(projectRoot: string): Promise<void>;
+export declare function readFlowState(projectRoot: string): Promise<FlowStateV8>;
+export declare function writeFlowState(projectRoot: string, state: FlowStateV8): Promise<void>;
+export declare function resetFlowState(projectRoot: string): Promise<void>;
+export declare function patchFlowState(projectRoot: string, patch: Partial<FlowStateV8>): Promise<FlowStateV8>;