cclaw-cli 7.7.1 → 8.1.1

package/dist/track-heuristics.js

@@ -1,154 +0,0 @@
-import { FLOW_TRACKS } from "./types.js";
-// Built-in vocabulary per track. Kept in one place so tests, docs, and the
-// /cc skill prose can snapshot the exact same strings.
-const DEFAULT_RULES = {
-    quick: {
-        triggers: [
-            "bug",
-            "bugfix",
-            "fix",
-            "hotfix",
-            "patch",
-            "typo",
-            "regression",
-            "copy change",
-            "rename",
-            "bump",
-            "upgrade dep",
-            "config tweak",
-            "docs only",
-            "comment",
-            "lint",
-            "format",
-            "small",
-            "tiny",
-            "one-liner",
-            "revert"
-        ]
-    },
-    medium: {
-        triggers: [
-            "add endpoint",
-            "add field",
-            "extend existing",
-            "wire integration",
-            "small migration",
-            "new screen following existing pattern"
-        ]
-    },
-    standard: {
-        triggers: [
-            "new feature",
-            "refactor",
-            "migration",
-            "platform",
-            "architecture",
-            "schema",
-            "integrate",
-            "workflow",
-            "onboarding"
-        ]
-    }
-};
-// Fixed evaluation order: narrow-to-broad. Overriding this was never wired
-// into runtime, so cclaw no longer offers that knob.
-const EVALUATION_ORDER = ["standard", "medium", "quick"];
-const DEFAULT_FALLBACK = "standard";
-const ADAPTIVE_ELICITATION_STAGES = new Set(["brainstorm", "scope", "design"]);
-const QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE = {
-    lean: { min: 3, recommended: 4, hardCapWarning: 6 },
-    guided: { min: 5, recommended: 7, hardCapWarning: 10 },
-    deep: { min: 7, recommended: 10, hardCapWarning: 14 }
-};
-function hasToken(promptLower, token) {
-    return promptLower.includes(token.toLowerCase());
-}
-function matchRule(promptLower, rule) {
-    if (!rule)
-        return [];
-    const matches = [];
-    for (const trigger of rule.triggers ?? []) {
-        if (hasToken(promptLower, trigger)) {
-            matches.push(trigger);
-        }
-    }
-    return [...new Set(matches)];
-}
-function isValidTrack(value) {
-    return FLOW_TRACKS.includes(value);
-}
-function mergeRules(base, overrides) {
-    const merged = { ...base };
-    const over = overrides?.tracks;
-    if (!over)
-        return merged;
-    for (const track of FLOW_TRACKS) {
-        const rule = over[track];
-        if (!rule)
-            continue;
-        merged[track] = {
-            triggers: rule.triggers ?? merged[track].triggers,
-            veto: rule.veto ?? merged[track].veto
-        };
-    }
-    return merged;
-}
-function resolveFallback(config) {
-    return config?.fallback && isValidTrack(config.fallback) ? config.fallback : DEFAULT_FALLBACK;
-}
-/**
- * Reference implementation of the track classifier the /cc skill prose
- * describes. Tests pin its behavior so the built-in defaults stay honest.
- * This function is not called from cclaw runtime — `/cc` routing happens in
- * the LLM. If you wire this in later, update README to drop the
- * "advisory" language.
- */
-export function resolveTrackFromPrompt(prompt, config) {
-    const promptLower = prompt.toLowerCase();
-    const rules = mergeRules(DEFAULT_RULES, config);
-    const fallback = resolveFallback(config);
-    for (const track of EVALUATION_ORDER) {
-        const rule = rules[track];
-        const vetoes = rule.veto ?? [];
-        if (vetoes.some((token) => hasToken(promptLower, token))) {
-            continue;
-        }
-        const matched = matchRule(promptLower, rule);
-        if (matched.length > 0) {
-            return {
-                track,
-                reason: `matched ${track} heuristic (${matched.join(", ")})`,
-                matchedTokens: matched,
-                confidence: matched.length > 1 ? "high" : "medium",
-                overrideGuidance: track === "quick"
-                    ? "Use medium/standard instead when product framing, architecture, schema, migration, security, or unclear scope appears; quick skips ceremony, not safety."
-                    : track === "medium"
-                        ? "Use standard if architecture, data model, security boundary, or migration risk is uncertain."
-                        : "Use medium or quick only when the blast radius and architecture are already known."
-            };
-        }
-    }
-    return {
-        track: fallback,
-        reason: `no explicit match, fallback=${fallback}`,
-        matchedTokens: [],
-        confidence: "low",
-        overrideGuidance: "Confirm or override before state is written; choose quick only for known low-blast-radius work, medium for known architecture with product framing, standard for uncertainty."
-    };
-}
-export function questionBudgetHint(modeOrTrack, stage) {
-    if (!ADAPTIVE_ELICITATION_STAGES.has(stage)) {
-        return { min: 0, recommended: 0, hardCapWarning: 0 };
-    }
-    if (modeOrTrack === "lean" || modeOrTrack === "guided" || modeOrTrack === "deep") {
-        return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE[modeOrTrack];
-    }
-    if (modeOrTrack === "quick")
-        return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE.lean;
-    return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE.guided;
-}
-export const TRACK_HEURISTICS_DEFAULTS = {
-    fallback: DEFAULT_FALLBACK,
-    evaluationOrder: EVALUATION_ORDER,
-    tracks: DEFAULT_RULES
-};

package/dist/util/slice-id.d.ts

@@ -1,58 +0,0 @@
-/**
- * Slice-ID helpers.
- *
- * 7.6.0 — relaxed strict `/^S-\d+$/` to allow lettered sub-slices
- * (`S-36a`, `S-36b`, …) so plan amendments can insert work between
- * existing numeric slices without renumbering.
- *
- * Canonical shape: `S-<integer>(<lowercase-letter>[<lowercase-or-digit>...])?`
- *
- * Sort order (used everywhere we list slice ids):
- *   1. numeric chunk ascending
- *   2. lexical suffix ascending (no suffix sorts before any suffix)
- *
- * So: `S-1 < S-2 < S-10 < S-36 < S-36a < S-36b < S-37`.
- *
- * Surface:
- *   - `SLICE_ID_PATTERN`   — anchored regex source string for embedding
- *   - `SLICE_ID_REGEX`     — anchored RegExp for tests
- *   - `parseSliceId`       — strict parse → `{ numeric, suffix }` or null
- *   - `isSliceId`          — boolean shape check
- *   - `compareSliceIds`    — sort comparator
- *   - `sortSliceIds`       — convenience wrapper around `compareSliceIds`
- */
-/** Anchored, case-insensitive regex source for slice ids. */
-export declare const SLICE_ID_PATTERN = "^S-(\\d+)([a-z][a-z0-9]*)?$";
-/** Anchored, case-insensitive RegExp instance for slice ids. */
-export declare const SLICE_ID_REGEX: RegExp;
-export interface ParsedSliceId {
-    /** Canonical normalized form, e.g. `S-36a`. */
-    id: string;
-    /** Numeric chunk as a number (e.g. `S-36a` → `36`). */
-    numeric: number;
-    /** Lowercase suffix (e.g. `S-36a` → `"a"`). Empty string when absent. */
-    suffix: string;
-}
-/**
- * Strict parse of a slice id token.
- *
- * Returns `null` when the input is not a slice id. Whitespace and
- * surrounding markdown decorations (backticks, brackets, quotes) are
- * stripped before parsing so callers can pass cells from markdown
- * tables verbatim.
- */
-export declare function parseSliceId(raw: unknown): ParsedSliceId | null;
-/**
- * Boolean shape check. Lowercase-or-uppercase `S-` prefix accepted; the
- * canonical form is uppercase.
- */
-export declare function isSliceId(raw: unknown): boolean;
-/**
- * Comparator that orders slice ids by numeric chunk first, then by
- * suffix (no-suffix sorts before any suffix). Non-slice tokens fall
- * back to a stable lexical comparison so callers can pass mixed input
- * without crashing.
- */
-export declare function compareSliceIds(a: string, b: string): number;
-/** Convenience wrapper: returns a new sorted array using `compareSliceIds`. */
-export declare function sortSliceIds(ids: readonly string[]): string[];

package/dist/util/slice-id.js

@@ -1,89 +0,0 @@
-/**
- * Slice-ID helpers.
- *
- * 7.6.0 — relaxed strict `/^S-\d+$/` to allow lettered sub-slices
- * (`S-36a`, `S-36b`, …) so plan amendments can insert work between
- * existing numeric slices without renumbering.
- *
- * Canonical shape: `S-<integer>(<lowercase-letter>[<lowercase-or-digit>...])?`
- *
- * Sort order (used everywhere we list slice ids):
- *   1. numeric chunk ascending
- *   2. lexical suffix ascending (no suffix sorts before any suffix)
- *
- * So: `S-1 < S-2 < S-10 < S-36 < S-36a < S-36b < S-37`.
- *
- * Surface:
- *   - `SLICE_ID_PATTERN`   — anchored regex source string for embedding
- *   - `SLICE_ID_REGEX`     — anchored RegExp for tests
- *   - `parseSliceId`       — strict parse → `{ numeric, suffix }` or null
- *   - `isSliceId`          — boolean shape check
- *   - `compareSliceIds`    — sort comparator
- *   - `sortSliceIds`       — convenience wrapper around `compareSliceIds`
- */
-/** Anchored, case-insensitive regex source for slice ids. */
-export const SLICE_ID_PATTERN = "^S-(\\d+)([a-z][a-z0-9]*)?$";
-/** Anchored, case-insensitive RegExp instance for slice ids. */
-export const SLICE_ID_REGEX = new RegExp(SLICE_ID_PATTERN, "iu");
-/**
- * Strict parse of a slice id token.
- *
- * Returns `null` when the input is not a slice id. Whitespace and
- * surrounding markdown decorations (backticks, brackets, quotes) are
- * stripped before parsing so callers can pass cells from markdown
- * tables verbatim.
- */
-export function parseSliceId(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const stripped = raw.trim().replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "");
-    const match = SLICE_ID_REGEX.exec(stripped);
-    if (!match)
-        return null;
-    const numericPart = match[1] ?? "";
-    const suffixPart = (match[2] ?? "").toLowerCase();
-    const numeric = Number(numericPart);
-    if (!Number.isFinite(numeric) || !Number.isInteger(numeric))
-        return null;
-    const id = suffixPart.length > 0 ? `S-${numericPart}${suffixPart}` : `S-${numericPart}`;
-    return { id, numeric, suffix: suffixPart };
-}
-/**
- * Boolean shape check. Lowercase-or-uppercase `S-` prefix accepted; the
- * canonical form is uppercase.
- */
-export function isSliceId(raw) {
-    return parseSliceId(raw) !== null;
-}
-/**
- * Comparator that orders slice ids by numeric chunk first, then by
- * suffix (no-suffix sorts before any suffix). Non-slice tokens fall
- * back to a stable lexical comparison so callers can pass mixed input
- * without crashing.
- */
-export function compareSliceIds(a, b) {
-    const pa = parseSliceId(a);
-    const pb = parseSliceId(b);
-    if (pa && pb) {
-        if (pa.numeric !== pb.numeric)
-            return pa.numeric - pb.numeric;
-        if (pa.suffix === pb.suffix)
-            return 0;
-        if (pa.suffix === "")
-            return -1;
-        if (pb.suffix === "")
-            return 1;
-        return pa.suffix < pb.suffix ? -1 : 1;
-    }
-    if (pa)
-        return -1;
-    if (pb)
-        return 1;
-    if (a === b)
-        return 0;
-    return a < b ? -1 : 1;
-}
-/** Convenience wrapper: returns a new sorted array using `compareSliceIds`. */
-export function sortSliceIds(ids) {
-    return [...ids].sort(compareSliceIds);
-}

package/dist/worktree-manager.d.ts

@@ -1,20 +0,0 @@
-export interface WorktreeManagerOptions {
-    projectRoot?: string;
-    worktreeRoot?: string;
-}
-export declare class WorktreeUnsupportedError extends Error {
-    readonly code = "worktree_unavailable";
-    constructor(message: string);
-}
-export declare class WorktreeMergeConflictError extends Error {
-    readonly code = "worktree_merge_conflict";
-    constructor(message: string);
-}
-export declare function createSliceWorktree(sliceId: string, baseRef: string, _claimedPaths: string[], options?: WorktreeManagerOptions): Promise<{
-    path: string;
-    ref: string;
-}>;
-export declare function commitAndMergeBack(worktreePath: string, _message: string, options?: WorktreeManagerOptions): Promise<{
-    commitSha: string;
-}>;
-export declare function cleanupWorktree(worktreePath: string, options?: WorktreeManagerOptions): Promise<void>;

package/dist/worktree-manager.js

@@ -1,108 +0,0 @@
-import { execFile } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { DEFAULT_TDD_WORKTREE_ROOT } from "./config.js";
-import { exists } from "./fs-utils.js";
-const execFileAsync = promisify(execFile);
-export class WorktreeUnsupportedError extends Error {
-    code = "worktree_unavailable";
-    constructor(message) {
-        super(message);
-        this.name = "WorktreeUnsupportedError";
-    }
-}
-export class WorktreeMergeConflictError extends Error {
-    code = "worktree_merge_conflict";
-    constructor(message) {
-        super(message);
-        this.name = "WorktreeMergeConflictError";
-    }
-}
-function sanitizeSliceId(sliceId) {
-    return sliceId.trim().replace(/[^A-Za-z0-9._-]+/gu, "-");
-}
-function resolveProjectRoot(options) {
-    return options?.projectRoot ?? process.cwd();
-}
-function resolveWorktreeRoot(projectRoot, options) {
-    const root = typeof options?.worktreeRoot === "string" && options.worktreeRoot.trim().length > 0
-        ? options.worktreeRoot.trim()
-        : DEFAULT_TDD_WORKTREE_ROOT;
-    return path.resolve(projectRoot, root);
-}
-async function resolveMainRepoRootFromWorktree(worktreePath) {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: worktreePath });
-    const commonDir = stdout.trim();
-    if (commonDir.length === 0) {
-        throw new Error(`Cannot resolve git common-dir from worktree ${worktreePath}`);
-    }
-    return path.dirname(commonDir);
-}
-export async function createSliceWorktree(sliceId, baseRef, _claimedPaths, options = {}) {
-    const projectRoot = resolveProjectRoot(options);
-    const ref = baseRef.trim().length > 0 ? baseRef.trim() : "HEAD";
-    const worktreeRoot = resolveWorktreeRoot(projectRoot, options);
-    const safeSliceId = sanitizeSliceId(sliceId);
-    if (safeSliceId.length === 0) {
-        throw new WorktreeUnsupportedError("Cannot create worktree: empty slice id.");
-    }
-    const worktreePath = path.join(worktreeRoot, safeSliceId);
-    try {
-        await execFileAsync("git", ["rev-parse", "--git-dir"], { cwd: projectRoot });
-    }
-    catch {
-        throw new WorktreeUnsupportedError("Cannot create worktree: repository has no .git metadata.");
-    }
-    await fs.mkdir(worktreeRoot, { recursive: true });
-    if (await exists(worktreePath)) {
-        if (await exists(path.join(worktreePath, ".git"))) {
-            return { path: worktreePath, ref };
-        }
-        await fs.rm(worktreePath, { recursive: true, force: true });
-    }
-    try {
-        await execFileAsync("git", ["worktree", "add", "--detach", worktreePath, ref], {
-            cwd: projectRoot
-        });
-    }
-    catch (error) {
-        throw new WorktreeUnsupportedError(`Cannot create worktree for ${sliceId}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return { path: worktreePath, ref };
-}
-export async function commitAndMergeBack(worktreePath, _message, options = {}) {
-    const projectRoot = options.projectRoot ?? await resolveMainRepoRootFromWorktree(worktreePath);
-    try {
-        const { stdout: mainHeadStdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
-            cwd: projectRoot
-        });
-        const mainHead = mainHeadStdout.trim();
-        await execFileAsync("git", ["rebase", mainHead], { cwd: worktreePath });
-        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: worktreePath });
-        const commitSha = stdout.trim();
-        await execFileAsync("git", ["fetch", worktreePath, "HEAD"], { cwd: projectRoot });
-        await execFileAsync("git", ["merge", "--ff-only", "FETCH_HEAD"], { cwd: projectRoot });
-        return { commitSha };
-    }
-    catch (error) {
-        throw new WorktreeMergeConflictError(`worktree_merge_conflict: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export async function cleanupWorktree(worktreePath, options = {}) {
-    if (!(await exists(worktreePath)))
-        return;
-    const projectRoot = options.projectRoot ?? await resolveMainRepoRootFromWorktree(worktreePath).catch(() => null);
-    if (projectRoot) {
-        try {
-            await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], {
-                cwd: projectRoot
-            });
-            return;
-        }
-        catch {
-            // fall through to rm fallback below
-        }
-    }
-    await fs.rm(worktreePath, { recursive: true, force: true });
-}