cclaw-cli 7.7.1 → 8.1.1

package/dist/artifact-paths.js

@@ -1,261 +1,32 @@
-import fs from "node:fs/promises";
 import path from "node:path";
-import { stageSchema } from "./content/stage-schema.js";
-import { RUNTIME_ROOT } from "./constants.js";
-import { exists } from "./fs-utils.js";
-const LEGACY_ARTIFACT_GRACE_CYCLES = 2;
-const DEFAULT_TOPIC_SLUG = "topic";
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function splitExt(fileName) {
-    const ext = path.extname(fileName);
-    if (!ext) {
-        return { stem: fileName, ext: "" };
-    }
-    return { stem: fileName.slice(0, -ext.length), ext };
-}
-function appendCollisionSuffix(fileName, index) {
-    const { stem, ext } = splitExt(fileName);
-    return `${stem}-${index}${ext}`;
-}
-export function isSlugArtifactPattern(filePattern) {
-    return filePattern.includes("<slug>");
-}
-export function legacyArtifactFileName(filePattern) {
-    if (!isSlugArtifactPattern(filePattern)) {
-        return filePattern;
-    }
-    return filePattern.replace(/-<slug>/gu, "");
-}
+import { FLOWS_ROOT, SHIPPED_DIR_REL_PATH } from "./constants.js";
+export const ARTIFACT_FILE_NAMES = {
+    plan: "plan.md",
+    build: "build.md",
+    review: "review.md",
+    ship: "ship.md",
+    decisions: "decisions.md",
+    learnings: "learnings.md"
+};
 export function slugifyArtifactTopic(topic) {
-    const normalized = topic
+    const slug = topic
         .toLowerCase()
         .trim()
-        .replace(/[`"'“”‘’()[\]{}<>]/gu, " ")
+        .replace(/[`"'()[\]{}<>]/gu, " ")
         .replace(/[^a-z0-9]+/gu, "-")
         .replace(/^-+/u, "")
         .replace(/-+$/u, "");
-    if (normalized.length === 0) {
-        return DEFAULT_TOPIC_SLUG;
-    }
-    return normalized.slice(0, 48);
-}
-function slugPatternRegex(filePattern) {
-    const [left, right] = filePattern.split("<slug>");
-    return new RegExp(`^${escapeRegExp(left ?? "")}[a-z0-9]+(?:-[a-z0-9]+)*(?:-\\d+)?${escapeRegExp(right ?? "")}$`, "u");
-}
-function searchRoots(projectRoot) {
-    return [
-        {
-            absDir: path.join(projectRoot, RUNTIME_ROOT, "artifacts"),
-            relPrefix: path.join(RUNTIME_ROOT, "artifacts")
-        },
-        {
-            absDir: projectRoot,
-            relPrefix: ""
-        }
-    ];
-}
-function candidateFromRoot(root, fileName) {
-    return {
-        relPath: root.relPrefix ? path.join(root.relPrefix, fileName) : fileName,
-        absPath: path.join(root.absDir, fileName)
-    };
+    return (slug || "task").slice(0, 64);
 }
-async function inferTopicFromIdeaArtifact(projectRoot) {
-    const ideaPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "00-idea.md");
-    if (!(await exists(ideaPath))) {
-        return null;
-    }
-    try {
-        const raw = await fs.readFile(ideaPath, "utf8");
-        const lines = raw.split(/\r?\n/gu);
-        const userPromptHeading = lines.findIndex((line) => /^##\s+user prompt\b/iu.test(line.trim()));
-        if (userPromptHeading >= 0) {
-            for (let i = userPromptHeading + 1; i < lines.length; i += 1) {
-                const line = lines[i].trim();
-                if (line.length === 0)
-                    continue;
-                if (/^##\s+/u.test(line))
-                    break;
-                const candidate = line.replace(/^[-*>\s#]+/u, "").trim();
-                if (candidate.length > 0) {
-                    return candidate;
-                }
-            }
-        }
-        const metadataLine = /^(?:class|track|stack|reclassification)\s*:/iu;
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                continue;
-            if (metadataLine.test(trimmed))
-                continue;
-            if (/^##\s+/u.test(trimmed))
-                continue;
-            const candidate = trimmed.replace(/^[-*>\s#]+/u, "").trim();
-            if (candidate.length > 0) {
-                return candidate;
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
+export function activeArtifactDir(projectRoot, slug) {
+    return path.join(projectRoot, FLOWS_ROOT, slug);
 }
-async function resolvedTopicSlug(projectRoot, stage, explicitTopic) {
-    if (explicitTopic && explicitTopic.trim().length > 0) {
-        return slugifyArtifactTopic(explicitTopic);
-    }
-    const inferred = await inferTopicFromIdeaArtifact(projectRoot);
-    if (inferred && inferred.trim().length > 0) {
-        return slugifyArtifactTopic(inferred);
-    }
-    return slugifyArtifactTopic(stage);
+export function activeArtifactPath(projectRoot, stage, slug) {
+    return path.join(activeArtifactDir(projectRoot, slug), ARTIFACT_FILE_NAMES[stage]);
 }
-async function collectExistingCandidates(projectRoot, filePattern, legacyFile) {
-    const roots = searchRoots(projectRoot);
-    const candidates = [];
-    const hasSlugPattern = isSlugArtifactPattern(filePattern);
-    const matcher = hasSlugPattern ? slugPatternRegex(filePattern) : null;
-    for (const root of roots) {
-        if (hasSlugPattern && matcher) {
-            let entries = [];
-            try {
-                entries = await fs.readdir(root.absDir);
-            }
-            catch {
-                entries = [];
-            }
-            for (const entry of entries) {
-                if (!matcher.test(entry))
-                    continue;
-                const { relPath, absPath } = candidateFromRoot(root, entry);
-                let mtimeMs = 0;
-                try {
-                    const stat = await fs.stat(absPath);
-                    mtimeMs = stat.mtimeMs;
-                }
-                catch {
-                    continue;
-                }
-                candidates.push({
-                    fileName: entry,
-                    relPath,
-                    absPath,
-                    mtimeMs,
-                    legacy: false
-                });
-            }
-        }
-        else {
-            const { relPath, absPath } = candidateFromRoot(root, filePattern);
-            if (await exists(absPath)) {
-                let mtimeMs = 0;
-                try {
-                    const stat = await fs.stat(absPath);
-                    mtimeMs = stat.mtimeMs;
-                }
-                catch {
-                    mtimeMs = 0;
-                }
-                candidates.push({
-                    fileName: filePattern,
-                    relPath,
-                    absPath,
-                    mtimeMs,
-                    legacy: false
-                });
-            }
-        }
-        if (legacyFile && LEGACY_ARTIFACT_GRACE_CYCLES > 0) {
-            const { relPath, absPath } = candidateFromRoot(root, legacyFile);
-            if (await exists(absPath)) {
-                let mtimeMs = 0;
-                try {
-                    const stat = await fs.stat(absPath);
-                    mtimeMs = stat.mtimeMs;
-                }
-                catch {
-                    mtimeMs = 0;
-                }
-                candidates.push({
-                    fileName: legacyFile,
-                    relPath,
-                    absPath,
-                    mtimeMs,
-                    legacy: true
-                });
-            }
-        }
-    }
-    candidates.sort((a, b) => {
-        if (b.mtimeMs !== a.mtimeMs) {
-            return b.mtimeMs - a.mtimeMs;
-        }
-        if (a.legacy !== b.legacy) {
-            return a.legacy ? 1 : -1;
-        }
-        return a.fileName.localeCompare(b.fileName);
-    });
-    return candidates;
+export function shippedArtifactDir(projectRoot, slug) {
+    return path.join(projectRoot, SHIPPED_DIR_REL_PATH, slug);
 }
-export async function resolveArtifactPath(stage, context) {
-    const track = context.track ?? "standard";
-    const intent = context.intent ?? "read";
-    const filePattern = stageSchema(stage, track).artifactFile;
-    const hasSlugPattern = isSlugArtifactPattern(filePattern);
-    const legacyFile = hasSlugPattern ? legacyArtifactFileName(filePattern) : null;
-    const existing = await collectExistingCandidates(context.projectRoot, filePattern, legacyFile);
-    if (intent === "read" && existing.length > 0) {
-        const picked = existing[0];
-        return {
-            stage,
-            fileName: picked.fileName,
-            relPath: picked.relPath,
-            absPath: picked.absPath,
-            source: "existing",
-            legacy: picked.legacy
-        };
-    }
-    const artifactRoot = path.join(context.projectRoot, RUNTIME_ROOT, "artifacts");
-    if (!hasSlugPattern) {
-        return {
-            stage,
-            fileName: filePattern,
-            relPath: path.join(RUNTIME_ROOT, "artifacts", filePattern),
-            absPath: path.join(artifactRoot, filePattern),
-            source: "generated",
-            legacy: false
-        };
-    }
-    const topicSlug = await resolvedTopicSlug(context.projectRoot, stage, context.topic);
-    const baseFileName = filePattern.replace("<slug>", topicSlug);
-    if (intent === "read") {
-        return {
-            stage,
-            fileName: baseFileName,
-            relPath: path.join(RUNTIME_ROOT, "artifacts", baseFileName),
-            absPath: path.join(artifactRoot, baseFileName),
-            source: "generated",
-            legacy: false
-        };
-    }
-    let candidate = baseFileName;
-    let index = 2;
-    // Keep incrementing while a matching file exists under active artifacts root.
-    while (await exists(path.join(artifactRoot, candidate))) {
-        candidate = appendCollisionSuffix(baseFileName, index);
-        index += 1;
-    }
-    return {
-        stage,
-        fileName: candidate,
-        relPath: path.join(RUNTIME_ROOT, "artifacts", candidate),
-        absPath: path.join(artifactRoot, candidate),
-        source: "generated",
-        legacy: false
-    };
+export function shippedArtifactPath(projectRoot, slug, stage) {
+    return path.join(shippedArtifactDir(projectRoot, slug), ARTIFACT_FILE_NAMES[stage]);
 }

package/dist/cancel.d.ts

@@ -0,0 +1,16 @@
+import { type ArtifactStage } from "./artifact-paths.js";
+export interface CancelOptions {
+    reason?: string;
+    cancelledAt?: string;
+}
+export interface CancelResult {
+    slug: string;
+    cancelledDir: string;
+    movedArtifacts: ArtifactStage[];
+    reason: string;
+}
+export declare class CancelError extends Error {
+}
+export declare function cancelledArtifactDir(projectRoot: string, slug: string): string;
+export declare function cancelActiveRun(projectRoot: string, options?: CancelOptions): Promise<CancelResult>;
+export declare function listCancelled(projectRoot: string): Promise<string[]>;

package/dist/cancel.js

@@ -0,0 +1,66 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ARTIFACT_FILE_NAMES, activeArtifactDir, activeArtifactPath } from "./artifact-paths.js";
+import { CANCELLED_DIR_REL_PATH } from "./constants.js";
+import { ensureDir, exists, removePath, writeFileSafe } from "./fs-utils.js";
+import { syncFrontmatter } from "./artifact-frontmatter.js";
+import { readFlowState, resetFlowState } from "./run-persistence.js";
+export class CancelError extends Error {
+}
+export function cancelledArtifactDir(projectRoot, slug) {
+    return path.join(projectRoot, CANCELLED_DIR_REL_PATH, slug);
+}
+async function moveIfExists(source, destination) {
+    if (!(await exists(source)))
+        return false;
+    await ensureDir(path.dirname(destination));
+    await fs.rename(source, destination);
+    return true;
+}
+const ALL_STAGES = ["plan", "build", "review", "ship", "decisions", "learnings"];
+export async function cancelActiveRun(projectRoot, options = {}) {
+    const state = await readFlowState(projectRoot);
+    if (!state.currentSlug) {
+        throw new CancelError("No active slug; nothing to cancel.");
+    }
+    const slug = state.currentSlug;
+    const reason = options.reason?.trim() || "user cancelled";
+    const cancelledAt = options.cancelledAt ?? new Date().toISOString();
+    for (const stage of ["plan", "build", "review", "ship"]) {
+        const filePath = activeArtifactPath(projectRoot, stage, slug);
+        if (await exists(filePath)) {
+            try {
+                await syncFrontmatter(projectRoot, slug, stage, {});
+            }
+            catch {
+                // ignore frontmatter parse errors during cancel; we still move the file
+            }
+        }
+    }
+    const target = cancelledArtifactDir(projectRoot, slug);
+    await ensureDir(target);
+    const moved = [];
+    for (const stage of ALL_STAGES) {
+        const source = activeArtifactPath(projectRoot, stage, slug);
+        const destination = path.join(target, ARTIFACT_FILE_NAMES[stage]);
+        if (await moveIfExists(source, destination))
+            moved.push(stage);
+    }
+    const manifest = `---\nslug: ${slug}\nstage: cancelled\nstatus: cancelled\ncancelled_at: ${cancelledAt}\nreason: ${JSON.stringify(reason)}\n---\n\n# ${slug} — cancelled\n\n${reason}\n\n## Artifacts\n\n${moved.map((stage) => `- ${ARTIFACT_FILE_NAMES[stage]}`).join("\n") || "_No artifacts were active at cancel time._"}\n`;
+    await writeFileSafe(path.join(target, "manifest.md"), manifest);
+    const activeDir = activeArtifactDir(projectRoot, slug);
+    if (await exists(activeDir)) {
+        const remaining = await fs.readdir(activeDir);
+        if (remaining.length === 0)
+            await removePath(activeDir);
+    }
+    await resetFlowState(projectRoot);
+    return { slug, cancelledDir: target, movedArtifacts: moved, reason };
+}
+export async function listCancelled(projectRoot) {
+    const dir = path.join(projectRoot, CANCELLED_DIR_REL_PATH);
+    if (!(await exists(dir)))
+        return [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}

package/dist/cli.d.ts

@@ -1,28 +1,3 @@
 #!/usr/bin/env node
-import type { FlowTrack, HarnessId } from "./types.js";
-import type { ArchiveDisposition } from "./runs.js";
-export { parseHarnessSelectionAnswer } from "./harness-selection.js";
-type CommandName = "init" | "sync" | "upgrade" | "uninstall" | "archive" | "internal";
-interface ParsedArgs {
-    command?: CommandName;
-    harnesses?: HarnessId[];
-    track?: FlowTrack;
-    dryRun?: boolean;
-    interactive?: boolean;
-    syncCheck?: boolean;
-    archiveName?: string;
-    archiveSkipRetro?: boolean;
-    archiveSkipRetroReason?: string;
-    archiveDisposition?: ArchiveDisposition;
-    archiveDispositionReason?: string;
-    /** Hidden plumbing command (`cclaw internal ...`) arguments. */
-    internalArgs?: string[];
-    showHelp?: boolean;
-    showVersion?: boolean;
-}
-export declare function usage(): string;
-declare function parseHarnesses(raw: string): HarnessId[];
-declare function parseTrack(raw: string): FlowTrack;
-declare function parseArchiveDisposition(raw: string): ArchiveDisposition;
-declare function parseArgs(argv: string[]): ParsedArgs;
-export { parseArgs, parseArchiveDisposition, parseHarnesses, parseTrack };
+import { type CliContext } from "./types.js";
+export declare function runCli(argv: string[], context: CliContext): Promise<number>;