@popoverai/dotrequirements 0.22.0 → 0.24.0

package/dist/codebase-to-spec/pack.js

@@ -0,0 +1,127 @@
+/**
+ * Pack stage: produce compressed and uncompressed views of a codebase.
+ *
+ * Wraps Repomix's programmatic API to write:
+ * - `.dotrequirements-cache/overview.txt` — compressed (tree-sitter signatures)
+ * - `.dotrequirements-cache/source.txt` — uncompressed (full source for slices)
+ *
+ * Requirements covered:
+ * - CTS-PACK-1: Pack stage produces compressed and uncompressed views
+ * - CTS-PACK-2: Engineer can extend the ignore list per project
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The curated default ignore list. These patterns are applied in addition to
+ * `.gitignore` and any project-level `.dotrequirements-ignore`.
+ *
+ * Sized to remove obvious non-behavioral noise: generated code, package
+ * manifests/lockfiles, vendored libraries, build artifacts, large binaries.
+ */
+export const DEFAULT_IGNORES = [
+    // Vendored dependencies
+    "node_modules/**",
+    "vendor/**",
+    ".pnp.*",
+    // Build outputs
+    "dist/**",
+    "build/**",
+    "out/**",
+    ".next/**",
+    ".nuxt/**",
+    ".svelte-kit/**",
+    ".turbo/**",
+    ".parcel-cache/**",
+    // Generated code
+    "**/*.generated.*",
+    "**/_generated/**",
+    "**/__generated__/**",
+    "**/*.pb.ts",
+    "**/*.pb.go",
+    // Lockfiles
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lockb",
+    "composer.lock",
+    "Gemfile.lock",
+    "poetry.lock",
+    "uv.lock",
+    "Cargo.lock",
+    // Coverage and test artifacts
+    "coverage/**",
+    ".nyc_output/**",
+    ".next-cache/**",
+    // IDE / editor
+    ".idea/**",
+    ".vscode/**",
+    // OS files
+    ".DS_Store",
+    "Thumbs.db",
+    // Project caches we own
+    ".dotrequirements-cache/**",
+];
+/**
+ * Read project-level ignore patterns from `.dotrequirements-ignore` (and
+ * `.dotreqignore` as a shorthand), if either exists. Returns an empty array if
+ * no file is present.
+ */
+export function readProjectIgnores(projectRoot) {
+    const candidates = [".dotrequirements-ignore", ".dotreqignore"];
+    for (const name of candidates) {
+        const p = join(projectRoot, name);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8");
+            return content
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith("#"));
+        }
+    }
+    return [];
+}
+/**
+ * Run Repomix twice over the same scope: once compressed, once uncompressed.
+ *
+ * We use Repomix's programmatic API rather than `npx repomix` so the CLI does
+ * not require a separate install and so we can control config precisely.
+ *
+ * NOTE: Repomix's TypeScript API is invoked via `runCli`. We invoke it as the
+ * library exposes it; the surface is small enough that this wraps cleanly.
+ */
+export async function runPack(options) {
+    const { projectRoot, paths, scope, extraIgnores = [] } = options;
+    const ignores = [
+        ...DEFAULT_IGNORES,
+        ...readProjectIgnores(projectRoot),
+        ...extraIgnores,
+    ];
+    const target = scope ? join(projectRoot, scope) : projectRoot;
+    // Import dynamically — Repomix is heavy and we don't want to load it at CLI
+    // boot time for unrelated commands.
+    const repomix = await import("repomix");
+    const { runCli } = repomix;
+    // Run compressed (overview)
+    await runCli([target], projectRoot, {
+        output: paths.overview,
+        style: "plain",
+        compress: true,
+        ignore: ignores.join(","),
+    });
+    // Run uncompressed (source)
+    await runCli([target], projectRoot, {
+        output: paths.source,
+        style: "plain",
+        compress: false,
+        ignore: ignores.join(","),
+    });
+    // Count "File:" headers in the uncompressed pack to report file count
+    const sourceContent = readFileSync(paths.source, "utf-8");
+    const fileCount = (sourceContent.match(/^File: /gm) ?? []).length;
+    return {
+        overviewPath: paths.overview,
+        sourcePath: paths.source,
+        fileCount,
+    };
+}
+//# sourceMappingURL=pack.js.map

package/dist/codebase-to-spec/planner.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Planner functions (initial and revise).
+ *
+ * Two modes correspond to two places the planner is invoked:
+ * - initial: first outline from the compressed pack (CTS-PLAN-1)
+ * - revise:  address reviewer feedback — works for both
+ *            `requires-another-review` (CTS-PLAN-5) and
+ *            `approved-with-revisions` (CTS-PLAN-4). The orchestration
+ *            decides whether to loop back to the reviewer or proceed to
+ *            fan-out.
+ *
+ * Each mode is stateless — a fresh claude -p session per call.
+ */
+import { type ClaudeRunner } from "./claude.js";
+import { type Outline, type OutlineReview } from "./schemas.js";
+export interface PlannerContext {
+    /** Path to the compressed pack file (readable by the spawned agent). */
+    overviewPath: string;
+    /** Directories the agent should have read access to (e.g., the cache dir). */
+    addDirs: string[];
+    /** Optional claude runner override (for tests). */
+    runner?: ClaudeRunner;
+    /** Optional model override. */
+    model?: string;
+}
+/**
+ * Run the planner in initial mode and return a parsed outline.
+ * Requirement: CTS-PLAN-1
+ */
+export declare function runInitialPlanner(ctx: PlannerContext): Promise<Outline>;
+/**
+ * Run the planner in revise mode — produce a new outline that addresses the
+ * reviewer's output. Handles both verdicts that trigger another planner pass:
+ * `requires-another-review` (categorized findings, judgment-based) and
+ * `approved-with-revisions` (explicit revisions list). The same prompt handles
+ * both shapes; the prompt switches behavior based on what's in the review.
+ *
+ * Requirements: CTS-PLAN-4, CTS-PLAN-5
+ */
+export declare function runRevisingPlanner(ctx: PlannerContext, priorOutline: Outline, review: OutlineReview): Promise<Outline>;
+//# sourceMappingURL=planner.d.ts.map

package/dist/codebase-to-spec/planner.js

@@ -0,0 +1,76 @@
+/**
+ * Planner functions (initial and revise).
+ *
+ * Two modes correspond to two places the planner is invoked:
+ * - initial: first outline from the compressed pack (CTS-PLAN-1)
+ * - revise:  address reviewer feedback — works for both
+ *            `requires-another-review` (CTS-PLAN-5) and
+ *            `approved-with-revisions` (CTS-PLAN-4). The orchestration
+ *            decides whether to loop back to the reviewer or proceed to
+ *            fan-out.
+ *
+ * Each mode is stateless — a fresh claude -p session per call.
+ */
+import { runClaude } from "./claude.js";
+import { PLANNER_INITIAL_PROMPT } from "./prompts/planner-initial.js";
+import { PLANNER_REVISE_PROMPT } from "./prompts/planner-revise.js";
+import { OUTLINE_JSON_SCHEMA, parseOutline, } from "./schemas.js";
+/**
+ * Run the planner in initial mode and return a parsed outline.
+ * Requirement: CTS-PLAN-1
+ */
+export async function runInitialPlanner(ctx) {
+    const runner = ctx.runner ?? runClaude;
+    const result = await runner({
+        systemPrompt: PLANNER_INITIAL_PROMPT,
+        userMessage: `The compressed packed codebase is at: ${ctx.overviewPath}\n\nRead it and produce the outline JSON described in your system prompt.`,
+        model: ctx.model,
+        tools: ["Read"],
+        addDirs: ctx.addDirs,
+        jsonSchema: OUTLINE_JSON_SCHEMA,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`Planner failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    return parseOutline(result.stdout);
+}
+/**
+ * Run the planner in revise mode — produce a new outline that addresses the
+ * reviewer's output. Handles both verdicts that trigger another planner pass:
+ * `requires-another-review` (categorized findings, judgment-based) and
+ * `approved-with-revisions` (explicit revisions list). The same prompt handles
+ * both shapes; the prompt switches behavior based on what's in the review.
+ *
+ * Requirements: CTS-PLAN-4, CTS-PLAN-5
+ */
+export async function runRevisingPlanner(ctx, priorOutline, review) {
+    const runner = ctx.runner ?? runClaude;
+    const userMessage = [
+        `The compressed packed codebase is at: ${ctx.overviewPath}`,
+        ``,
+        `## Prior outline`,
+        `\`\`\`json`,
+        JSON.stringify(priorOutline, null, 2),
+        `\`\`\``,
+        ``,
+        `## Reviewer output`,
+        `\`\`\`json`,
+        JSON.stringify(review, null, 2),
+        `\`\`\``,
+        ``,
+        `Produce a revised outline JSON that addresses the reviewer's output. Output JSON only.`,
+    ].join("\n");
+    const result = await runner({
+        systemPrompt: PLANNER_REVISE_PROMPT,
+        userMessage,
+        model: ctx.model,
+        tools: ["Read"],
+        addDirs: ctx.addDirs,
+        jsonSchema: OUTLINE_JSON_SCHEMA,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`Revising planner failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    return parseOutline(result.stdout);
+}
+//# sourceMappingURL=planner.js.map

package/dist/codebase-to-spec/present.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Present stage: write the final spec to .requirements/.
+ *
+ * - When the outline has 5+ areas, split into per-area files
+ *   (`.requirements/<sanitized-area-name>.requirements.md`).
+ * - When the outline has fewer than 5 areas, write a single document at
+ *   `.requirements/<sanitized-title>.requirements.md`.
+ * - Overwrite handling depends on interactive vs non-interactive mode.
+ *
+ * Requirements covered:
+ * - CTS-PRESENT-1: Final spec written to .requirements/, split when 5+ areas
+ * - CTS-PRESENT-2: Interactive overwrite prompt with three choices
+ * - CTS-PRESENT-3: Non-interactive overwrites require --overwrite or --skip-existing
+ */
+import type { Outline } from "./schemas.js";
+export declare const AREA_SPLIT_THRESHOLD = 5;
+export type OverwritePolicy = "prompt" | "overwrite" | "skip-existing" | "fail-fast";
+export interface PresentOptions {
+    outline: Outline;
+    finalSpecPath: string;
+    /** Project root (.requirements/ will be created under this). */
+    projectRoot: string;
+    overwritePolicy: OverwritePolicy;
+}
+export interface PresentResult {
+    /** Paths written under .requirements/ (or those that would have been written, in fail cases). */
+    outputPaths: string[];
+    /** Per-file action taken. */
+    actions: PresentAction[];
+    /** True if every file landed successfully. */
+    allWritten: boolean;
+    /** Reason for failure, if `allWritten` is false in fail-fast mode. */
+    conflictPath?: string;
+}
+export interface PresentAction {
+    path: string;
+    action: "created" | "overwrote" | "skipped" | "merged" | "refused";
+}
+/**
+ * Resolve the output path(s) the present stage would write to.
+ */
+export declare function planPresentPaths(outline: Outline, projectRoot: string): {
+    mode: "single" | "split";
+    paths: {
+        area?: string;
+        outPath: string;
+    }[];
+};
+/**
+ * Split a composed spec into per-area sections.
+ *
+ * The compose stage writes:
+ *
+ *     ---
+ *     frontmatter
+ *     ---
+ *
+ *     # Title
+ *
+ *     Summary.
+ *
+ *     ---
+ *
+ *     ## Area One
+ *     ...
+ *
+ *     ---
+ *
+ *     ## Area Two
+ *     ...
+ *
+ * We split on `\n---\n\n## ` and pair each chunk with its area heading.
+ */
+export declare function splitComposedSpec(composed: string, outline: Outline): Map<string, string>;
+/**
+ * Build a single-file requirements document from the composed spec.
+ * The composed spec IS this document (with the right frontmatter and structure).
+ * We just read it and return it.
+ */
+export declare function buildSingleFileDoc(composedSpec: string): string;
+/**
+ * Build a per-area requirements document for split mode.
+ */
+export declare function buildAreaDoc(outline: Outline, areaName: string, areaBody: string): string;
+/**
+ * Run the present stage.
+ *
+ * Returns a list of actions taken per path. In fail-fast mode, if any path
+ * would conflict, the function returns early with `conflictPath` set and
+ * `allWritten = false` — no files are written in this case (preserving the
+ * "no file overwritten without choice" guarantee from CTS-PRESENT-2.1).
+ */
+export declare function runPresent(options: PresentOptions): Promise<PresentResult>;
+//# sourceMappingURL=present.d.ts.map

package/dist/codebase-to-spec/present.js

@@ -0,0 +1,288 @@
+/**
+ * Present stage: write the final spec to .requirements/.
+ *
+ * - When the outline has 5+ areas, split into per-area files
+ *   (`.requirements/<sanitized-area-name>.requirements.md`).
+ * - When the outline has fewer than 5 areas, write a single document at
+ *   `.requirements/<sanitized-title>.requirements.md`.
+ * - Overwrite handling depends on interactive vs non-interactive mode.
+ *
+ * Requirements covered:
+ * - CTS-PRESENT-1: Final spec written to .requirements/, split when 5+ areas
+ * - CTS-PRESENT-2: Interactive overwrite prompt with three choices
+ * - CTS-PRESENT-3: Non-interactive overwrites require --overwrite or --skip-existing
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseRequirementsFile } from "../schema/parser.js";
+import { sanitizeAreaName } from "./fan-out.js";
+import { promptOverwriteChoice } from "./interactive.js";
+export const AREA_SPLIT_THRESHOLD = 5;
+/**
+ * Resolve the output path(s) the present stage would write to.
+ */
+export function planPresentPaths(outline, projectRoot) {
+    const requirementsDir = join(projectRoot, ".requirements");
+    if (outline.areas.length >= AREA_SPLIT_THRESHOLD) {
+        return {
+            mode: "split",
+            paths: outline.areas.map((area) => ({
+                area: area.name,
+                outPath: join(requirementsDir, `${sanitizeAreaName(area.name)}.requirements.md`),
+            })),
+        };
+    }
+    return {
+        mode: "single",
+        paths: [
+            {
+                outPath: join(requirementsDir, `${sanitizeAreaName(outline.title)}.requirements.md`),
+            },
+        ],
+    };
+}
+/**
+ * Split a composed spec into per-area sections.
+ *
+ * The compose stage writes:
+ *
+ *     ---
+ *     frontmatter
+ *     ---
+ *
+ *     # Title
+ *
+ *     Summary.
+ *
+ *     ---
+ *
+ *     ## Area One
+ *     ...
+ *
+ *     ---
+ *
+ *     ## Area Two
+ *     ...
+ *
+ * We split on `\n---\n\n## ` and pair each chunk with its area heading.
+ */
+export function splitComposedSpec(composed, outline) {
+    const sections = new Map();
+    // Strip frontmatter (already used) and grab everything from the first '## ' onward.
+    const fmEnd = composed.indexOf("\n---\n", 4);
+    // Find the first H2.
+    const firstH2 = composed.indexOf("\n## ");
+    if (firstH2 === -1) {
+        // No areas in the composed spec — fall back to empty sections.
+        return sections;
+    }
+    const afterTitle = composed.slice(firstH2);
+    // Split on '\n---\n\n## ' so each chunk starts with '## <area name>'.
+    // (We split-include the first chunk by prepending it manually.)
+    const chunks = afterTitle.split(/\n---\n\n## /);
+    // The first chunk already starts with '\n## ' from the original; normalize:
+    chunks[0] = chunks[0].replace(/^\n?## /, "");
+    // Subsequent chunks start with the area heading text directly (we stripped '## ').
+    for (const chunk of chunks) {
+        const firstNewline = chunk.indexOf("\n");
+        if (firstNewline === -1)
+            continue;
+        const heading = chunk.slice(0, firstNewline).trim();
+        const body = chunk.slice(firstNewline + 1);
+        // Match heading to outline area (exact match by name).
+        const area = outline.areas.find((a) => a.name === heading);
+        if (area) {
+            sections.set(area.name, body.trim());
+        }
+    }
+    // Also handle the trivial case where compose wrote `## Area` immediately
+    // after the title (no `---` separator). Unused for current compose output
+    // but defensive.
+    // Suppress unused-var warning for fmEnd:
+    void fmEnd;
+    return sections;
+}
+/**
+ * Build a single-file requirements document from the composed spec.
+ * The composed spec IS this document (with the right frontmatter and structure).
+ * We just read it and return it.
+ */
+export function buildSingleFileDoc(composedSpec) {
+    return composedSpec;
+}
+/**
+ * Build a per-area requirements document for split mode.
+ */
+export function buildAreaDoc(outline, areaName, areaBody) {
+    const area = outline.areas.find((a) => a.name === areaName);
+    const escapedTitle = `${outline.title}: ${areaName}`
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"');
+    const parts = [
+        "---",
+        "document:",
+        `  title: "${escapedTitle}"`,
+        `  defaultPrefix: ${outline.defaultPrefix}`,
+        "---",
+        "",
+        `# ${outline.title}: ${areaName}`,
+        "",
+    ];
+    // The planner's drive-by area.description is intentionally not surfaced
+    // here. The specifier's deeper, persona-grounded area description (written
+    // into the partial body) is the one readers see.
+    void area;
+    parts.push(areaBody.trim());
+    parts.push("");
+    return parts.join("\n");
+}
+/**
+ * Apply an overwrite policy to determine what action to take for a path.
+ */
+async function resolveOverwriteAction(policy, path) {
+    if (!existsSync(path)) {
+        // No conflict — caller will create.
+        return "overwrite";
+    }
+    switch (policy) {
+        case "overwrite":
+            return "overwrite";
+        case "skip-existing":
+            return "skip";
+        case "fail-fast":
+            return "refused";
+        case "prompt": {
+            const choice = await promptOverwriteChoice(path);
+            if (choice === "cancel")
+                return "refused";
+            return choice;
+        }
+    }
+}
+/**
+ * Merge new content into an existing requirements file.
+ *
+ * Strategy: append the new file's requirement blocks below the existing
+ * content, with a separator comment. Existing requirements are preserved
+ * verbatim.
+ */
+function mergeContent(existingPath, newContent) {
+    const existing = readFileSync(existingPath, "utf-8").trimEnd();
+    // Strip frontmatter from newContent (it would conflict with existing frontmatter)
+    const fmMatch = newContent.match(/^---\n[\s\S]+?\n---\n+/);
+    const body = fmMatch
+        ? newContent.slice(fmMatch[0].length).trimStart()
+        : newContent;
+    return [
+        existing,
+        "",
+        "",
+        "<!-- Merged content appended by `dotrequirements cts present`. Review and integrate. -->",
+        "",
+        body,
+    ].join("\n");
+}
+/**
+ * Validate a path's content against the dotrequirements schema. Returns an
+ * error message string, or undefined if valid.
+ */
+function validateContent(content) {
+    try {
+        parseRequirementsFile(content);
+        return undefined;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}
+/**
+ * Run the present stage.
+ *
+ * Returns a list of actions taken per path. In fail-fast mode, if any path
+ * would conflict, the function returns early with `conflictPath` set and
+ * `allWritten = false` — no files are written in this case (preserving the
+ * "no file overwritten without choice" guarantee from CTS-PRESENT-2.1).
+ */
+export async function runPresent(options) {
+    const { outline, finalSpecPath, projectRoot, overwritePolicy } = options;
+    const composedSpec = readFileSync(finalSpecPath, "utf-8");
+    const plan = planPresentPaths(outline, projectRoot);
+    // Compute the content for each output up front.
+    const planned = [];
+    if (plan.mode === "single") {
+        planned.push({
+            outPath: plan.paths[0].outPath,
+            content: buildSingleFileDoc(composedSpec),
+        });
+    }
+    else {
+        const sections = splitComposedSpec(composedSpec, outline);
+        for (const { area, outPath } of plan.paths) {
+            const body = sections.get(area) ??
+                "_(no content for this area was found in the composed spec)_";
+            planned.push({ outPath, content: buildAreaDoc(outline, area, body) });
+        }
+    }
+    // In fail-fast mode, scan for any conflict before writing anything.
+    if (overwritePolicy === "fail-fast") {
+        for (const { outPath } of planned) {
+            if (existsSync(outPath)) {
+                return {
+                    outputPaths: planned.map((p) => p.outPath),
+                    actions: [],
+                    allWritten: false,
+                    conflictPath: outPath,
+                };
+            }
+        }
+    }
+    const actions = [];
+    let allWritten = true;
+    for (const { outPath, content } of planned) {
+        const choice = await resolveOverwriteAction(overwritePolicy, outPath);
+        const dir = dirname(outPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        if (choice === "refused") {
+            // In prompt mode, the user cancelled the prompt.
+            actions.push({ path: outPath, action: "refused" });
+            allWritten = false;
+            continue;
+        }
+        if (choice === "skip") {
+            actions.push({ path: outPath, action: "skipped" });
+            continue;
+        }
+        if (choice === "merge" && existsSync(outPath)) {
+            const merged = mergeContent(outPath, content);
+            const validationError = validateContent(merged);
+            if (validationError) {
+                // Fallback: leave the existing file alone and warn.
+                actions.push({ path: outPath, action: "skipped" });
+                allWritten = false;
+                continue;
+            }
+            writeFileSync(outPath, merged, "utf-8");
+            actions.push({ path: outPath, action: "merged" });
+            continue;
+        }
+        // Overwrite or create
+        const validationError = validateContent(content);
+        if (validationError) {
+            allWritten = false;
+            actions.push({ path: outPath, action: "refused" });
+            continue;
+        }
+        const action = existsSync(outPath)
+            ? "overwrote"
+            : "created";
+        writeFileSync(outPath, content, "utf-8");
+        actions.push({ path: outPath, action });
+    }
+    return {
+        outputPaths: planned.map((p) => p.outPath),
+        actions,
+        allWritten,
+    };
+}
+//# sourceMappingURL=present.js.map

package/dist/codebase-to-spec/progress.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Structured progress emitter for codebase-to-spec.
+ *
+ * Emits one line per event to stdout. Wrappers (the skill, CI tooling) parse
+ * these lines to render progress in their own UX.
+ *
+ * Format: `[CTS] <stage>/<step> <message>` where <stage>/<step> identifies the
+ * pipeline location and <message> is human-readable.
+ *
+ * Requirements covered:
+ * - CTS-CLI-5: CLI emissions are part of the public contract (stable format)
+ * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
+ */
+export type Stage = "pack" | "plan" | "outline-review" | "specify" | "compose" | "spec-review" | "present";
+export interface ProgressEvent {
+    stage: Stage;
+    step?: string;
+    message: string;
+    /** Optional structured data — included on JSON lines but not on plain text lines. */
+    data?: Record<string, unknown>;
+}
+export interface ProgressEmitter {
+    emit(event: ProgressEvent): void;
+}
+export declare class StdoutProgress implements ProgressEmitter {
+    emit(event: ProgressEvent): void;
+}
+/** Capturing emitter for tests. */
+export declare class CapturingProgress implements ProgressEmitter {
+    events: ProgressEvent[];
+    emit(event: ProgressEvent): void;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/codebase-to-spec/progress.js

@@ -0,0 +1,28 @@
+/**
+ * Structured progress emitter for codebase-to-spec.
+ *
+ * Emits one line per event to stdout. Wrappers (the skill, CI tooling) parse
+ * these lines to render progress in their own UX.
+ *
+ * Format: `[CTS] <stage>/<step> <message>` where <stage>/<step> identifies the
+ * pipeline location and <message> is human-readable.
+ *
+ * Requirements covered:
+ * - CTS-CLI-5: CLI emissions are part of the public contract (stable format)
+ * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
+ */
+import { stdout } from "node:process";
+export class StdoutProgress {
+    emit(event) {
+        const stagePath = event.step ? `${event.stage}/${event.step}` : event.stage;
+        stdout.write(`[CTS] ${stagePath} ${event.message}\n`);
+    }
+}
+/** Capturing emitter for tests. */
+export class CapturingProgress {
+    events = [];
+    emit(event) {
+        this.events.push(event);
+    }
+}
+//# sourceMappingURL=progress.js.map