@popoverai/dotrequirements 0.23.0 → 0.24.1

package/dist/commands/ai-setup.js

@@ -0,0 +1,441 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import prompts from "prompts";
+import { brand } from "../utils/brand.js";
+import { appendOrUpdateSection, buildNoGitRepoMessage, findDotrequirementsSection, findGitRoot, getContextFileName, } from "../utils/context-file.js";
+import { loadTemplate } from "../utils/templates.js";
+/**
+ * Load the context file section template
+ */
+function loadContextFileSection() {
+    return loadTemplate("context-file-section.md");
+}
+/**
+ * Install workflow guidance to the appropriate context file for a platform
+ */
+async function installContextFileSection(platform) {
+    const fileName = getContextFileName(platform);
+    if (!fileName) {
+        console.error(`\n❌ Unknown platform: ${platform}`);
+        return;
+    }
+    const gitRoot = await findGitRoot();
+    if (!gitRoot) {
+        console.log(`\n${buildNoGitRepoMessage(fileName)}\n`);
+        return;
+    }
+    const contextFilePath = join(gitRoot, fileName);
+    const sectionContent = loadContextFileSection();
+    // Check if file exists and has existing section
+    let existingSection = null;
+    if (existsSync(contextFilePath)) {
+        const content = readFileSync(contextFilePath, "utf-8");
+        const section = findDotrequirementsSection(content);
+        if (section) {
+            existingSection = section.content;
+        }
+    }
+    // Prompt user
+    const action = existingSection
+        ? "Update"
+        : existsSync(contextFilePath)
+            ? "Add to"
+            : "Create";
+    const response = await prompts({
+        type: "confirm",
+        name: "install",
+        message: `${action} ${fileName} with dotrequirements workflow guidance?`,
+        initial: true,
+    });
+    if (!response.install) {
+        console.log("");
+        return;
+    }
+    // If updating, show what will change
+    if (existingSection) {
+        const confirmUpdate = await prompts({
+            type: "confirm",
+            name: "confirm",
+            message: "Existing dotrequirements section found. Replace it?",
+            initial: true,
+        });
+        if (!confirmUpdate.confirm) {
+            console.log("   Skipped.\n");
+            return;
+        }
+    }
+    try {
+        const result = appendOrUpdateSection(contextFilePath, sectionContent);
+        const actionVerb = result.action === "created"
+            ? "Created"
+            : result.action === "appended"
+                ? "Added to"
+                : "Updated";
+        console.log(`✅ ${actionVerb} ${contextFilePath}\n`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to update ${fileName}`);
+        console.log(`   Error: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}
+/**
+ * AI setup command - configures the MCP server for AI assistants
+ */
+export async function aiSetupCommand() {
+    console.log(`🔧 Setting up ${brand} MCP server\n`);
+    // Interactive client selector
+    const response = await prompts({
+        type: "select",
+        name: "client",
+        message: "Which AI assistant are you using?",
+        choices: [
+            { title: "Claude Code", value: "claude-code" },
+            { title: "Claude Desktop", value: "claude-desktop" },
+            { title: "Cursor", value: "cursor" },
+            { title: "Google Antigravity", value: "antigravity" },
+            { title: "OpenAI Codex", value: "codex" },
+            { title: "GitHub Copilot", value: "github-copilot" },
+            { title: "Other (custom path)", value: "other" },
+        ],
+        initial: 0,
+    });
+    if (!response.client) {
+        console.log("\nSetup cancelled.");
+        return;
+    }
+    switch (response.client) {
+        case "claude-code":
+            await setupClaudeCode();
+            break;
+        case "claude-desktop":
+            await setupClaudeDesktop();
+            break;
+        case "cursor":
+            await setupCursor();
+            break;
+        case "antigravity":
+            await setupAntigravity();
+            break;
+        case "codex":
+            await setupCodex();
+            break;
+        case "github-copilot":
+            await setupGitHubCopilot();
+            break;
+        case "other":
+            await setupOther();
+            break;
+        default:
+            console.log(`\n❌ ${response.client} is not yet supported.`);
+            console.log("Please refer to the documentation for manual setup.");
+    }
+}
+async function setupClaudeCode() {
+    console.log("\n📦 Configuring MCP for Claude Code...\n");
+    const command = `claude mcp add-json dotrequirements '{"type":"stdio","command":"npx","args":["-y","@popoverai/dotrequirements","mcp"]}'`;
+    let mcpConfigured = false;
+    try {
+        execSync(command, { stdio: "pipe" });
+        console.log("✅ MCP configured successfully for Claude Code!");
+        mcpConfigured = true;
+    }
+    catch (error) {
+        const execError = error;
+        const stderr = execError.stderr?.toString() || "";
+        const errorMessage = execError.message || "";
+        const combinedError = stderr + errorMessage;
+        if (combinedError.includes("already exists")) {
+            console.log("✅ MCP server already configured for Claude Code");
+            mcpConfigured = true;
+        }
+        else {
+            console.error("❌ Failed to configure MCP automatically.");
+            console.log("\nYou can manually run:");
+            console.log(`  ${command}`);
+            if (stderr) {
+                console.log(`\nError: ${stderr}`);
+            }
+        }
+    }
+    if (mcpConfigured) {
+        console.log("\n⚠️  Important: Restart Claude Code for changes to take effect.");
+        console.log("\nYou can now ask your AI assistant to help write requirements!\n");
+        await installContextFileSection("claude-code");
+    }
+}
+async function setupClaudeDesktop() {
+    console.log("\n📦 Configuring MCP for Claude Desktop...\n");
+    // Determine config path based on OS
+    const platform = process.platform;
+    let configPath;
+    let configDir;
+    if (platform === "darwin") {
+        configDir = join(homedir(), "Library", "Application Support", "Claude");
+        configPath = join(configDir, "claude_desktop_config.json");
+    }
+    else if (platform === "win32") {
+        const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        configDir = join(appData, "Claude");
+        configPath = join(configDir, "claude_desktop_config.json");
+    }
+    else {
+        console.error("❌ Claude Desktop is only supported on macOS and Windows.");
+        console.log("\nFor Linux, please manually configure the MCP server.");
+        return;
+    }
+    const mcpServerConfig = {
+        command: "npx",
+        args: ["-y", "@popoverai/dotrequirements", "mcp"],
+        env: {
+            REQUIREMENTS_DIR: process.cwd(),
+        },
+    };
+    try {
+        if (!existsSync(configDir)) {
+            console.log("Creating Claude Desktop config directory...");
+            mkdirSync(configDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(configPath)) {
+            try {
+                const existingContent = readFileSync(configPath, "utf-8");
+                if (existingContent.trim()) {
+                    config = JSON.parse(existingContent);
+                }
+            }
+            catch {
+                console.log("⚠️  Existing config file is invalid, creating fresh config...");
+                config = {};
+            }
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers.dotrequirements = mcpServerConfig;
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`✅ MCP configured successfully!`);
+        console.log(`   Config file: ${configPath}`);
+        console.log(`   REQUIREMENTS_DIR: ${process.cwd()}\n`);
+        console.log("⚠️  Important: Quit and restart Claude Desktop for changes to take effect.");
+        console.log("              (Cmd+Q on macOS, not just close the window)\n");
+        console.log("You can now ask Claude Desktop to help write requirements!\n");
+        // Claude Desktop doesn't use skills like Claude Code, so we skip that step
+    }
+    catch (error) {
+        console.error("❌ Failed to configure MCP automatically.");
+        console.log(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+        console.log("\nYou can manually edit the config file at:");
+        console.log(`  ${configPath}\n`);
+        console.log("Add the following configuration:");
+        const manualConfig = {
+            mcpServers: {
+                dotrequirements: mcpServerConfig,
+            },
+        };
+        console.log(JSON.stringify(manualConfig, null, 2));
+    }
+}
+async function setupCursor() {
+    console.log("\n📦 Configuring MCP for Cursor (project-specific)...\n");
+    const configPath = join(process.cwd(), ".cursor", "mcp.json");
+    const configDir = join(process.cwd(), ".cursor");
+    const mcpServerConfig = {
+        command: "npx",
+        args: ["-y", "@popoverai/dotrequirements", "mcp"],
+    };
+    try {
+        if (!existsSync(configDir)) {
+            console.log("Creating Cursor config directory...");
+            mkdirSync(configDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(configPath)) {
+            try {
+                const existingContent = readFileSync(configPath, "utf-8");
+                if (existingContent.trim()) {
+                    config = JSON.parse(existingContent);
+                }
+            }
+            catch {
+                console.log("⚠️  Existing config file is invalid, creating fresh config...");
+                config = {};
+            }
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers.dotrequirements = mcpServerConfig;
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`✅ MCP configured successfully!`);
+        console.log(`   Config file: ${configPath}\n`);
+        console.log("⚠️  Important: Reload or restart Cursor for changes to take effect.");
+        console.log("\nYou can now ask your AI assistant to help write requirements!\n");
+        await installContextFileSection("cursor");
+    }
+    catch (error) {
+        console.error("❌ Failed to configure MCP automatically.");
+        console.log(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+        console.log("\nYou can manually edit the config file at:");
+        console.log(`  ${configPath}\n`);
+        console.log("Add the following configuration:");
+        const manualConfig = {
+            mcpServers: {
+                dotrequirements: mcpServerConfig,
+            },
+        };
+        console.log(JSON.stringify(manualConfig, null, 2));
+    }
+}
+async function setupAntigravity() {
+    console.log("\n📦 Configuring MCP for Google Antigravity...\n");
+    const configPath = join(homedir(), ".gemini", "antigravity", "mcp_config.json");
+    const configDir = join(homedir(), ".gemini", "antigravity");
+    // Check if we're in a dotrequirements project directory
+    const envLocalPath = join(process.cwd(), ".env.local");
+    let projectId = null;
+    let projectPath = null;
+    if (existsSync(envLocalPath)) {
+        try {
+            const envContent = readFileSync(envLocalPath, "utf-8");
+            const lines = envContent.split("\n");
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("DOTREQUIREMENTS_PROJECT_ID=")) {
+                    projectId = trimmed.split("=")[1]?.trim().replace(/['"]/g, "");
+                    projectPath = process.cwd();
+                    break;
+                }
+            }
+        }
+        catch {
+            // .env.local exists but couldn't read it - continue with global setup
+        }
+    }
+    try {
+        if (!existsSync(configDir)) {
+            console.log("Creating Antigravity config directory...");
+            mkdirSync(configDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(configPath)) {
+            try {
+                const existingContent = readFileSync(configPath, "utf-8");
+                if (existingContent.trim()) {
+                    config = JSON.parse(existingContent);
+                }
+            }
+            catch {
+                console.log("⚠️  Existing config file is invalid, creating fresh config...");
+                config = {};
+            }
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        if (!config.mcpServers.dotrequirements) {
+            config.mcpServers.dotrequirements = {
+                command: "npx",
+                args: ["-y", "@popoverai/dotrequirements", "mcp"],
+                env: {},
+            };
+        }
+        // biome-ignore lint/suspicious/noExplicitAny: `config` is parsed JSON from a user-owned MCP config file; its shape isn't ours to type fully. We only need the `env` bag, which we narrow ad-hoc here.
+        const dotreqServer = config.mcpServers.dotrequirements;
+        if (!dotreqServer.env) {
+            dotreqServer.env = {};
+        }
+        if (projectId && projectPath) {
+            const envKey = `PROJ_${projectId}`;
+            dotreqServer.env[envKey] = projectPath;
+            console.log(`✅ Added project to MCP config: ${envKey}`);
+            console.log(`   Path: ${projectPath}\n`);
+        }
+        else {
+            console.log(`ℹ️  Not in a ${brand} project directory (no .env.local with DOTREQUIREMENTS_PROJECT_ID found)`);
+            console.log("   Setting up global MCP server only.\n");
+        }
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`✅ MCP configured successfully!`);
+        console.log(`   Config file: ${configPath}\n`);
+        console.log("⚠️  Important: Reload or restart Google Antigravity for changes to take effect.");
+        console.log("\nYou can now ask your AI assistant to help write requirements!");
+        if (projectId) {
+            console.log(`\n💡 To add more projects, run \`dotreq ai-setup\` from each project directory.\n`);
+        }
+        else {
+            console.log("");
+        }
+        await installContextFileSection("antigravity");
+    }
+    catch (error) {
+        console.error("❌ Failed to configure MCP automatically.");
+        console.log(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+        console.log("\nYou can manually edit the config file at:");
+        console.log(`  ${configPath}`);
+    }
+}
+async function setupCodex() {
+    console.log("\n📦 Configuring MCP for OpenAI Codex...\n");
+    const command = `codex mcp add dotrequirements -- npx -y @popoverai/dotrequirements mcp`;
+    try {
+        execSync(command, { stdio: "inherit" });
+        console.log("\n✅ MCP configured successfully for Codex!");
+        console.log("\n⚠️  Important: Restart Codex for changes to take effect.");
+        console.log("\nYou can now ask your AI assistant to help write requirements!\n");
+        await installContextFileSection("codex");
+    }
+    catch {
+        console.error("\n❌ Failed to configure MCP automatically.");
+        console.log("\nYou can manually run:");
+        console.log(`  ${command}`);
+        console.log("\nOr manually edit ~/.codex/config.toml and add:");
+        console.log("[mcp_servers.dotrequirements]");
+        console.log('command = "npx"');
+        console.log('args = ["-y", "@popoverai/dotrequirements", "mcp"]');
+    }
+}
+async function setupGitHubCopilot() {
+    console.log("\n📦 Configuring skills for GitHub Copilot...\n");
+    console.log("ℹ️  GitHub Copilot discovers MCP servers from your IDE configuration.");
+    console.log("   Please configure the MCP server in VS Code settings or GitHub settings.\n");
+    console.log("   MCP server command: npx -y @popoverai/dotrequirements mcp\n");
+    await installContextFileSection("github-copilot");
+}
+async function setupOther() {
+    console.log("\n📦 Custom Context File Setup\n");
+    console.log("ℹ️  Workflow guidance is added to a context file at your project root.");
+    console.log("   Common file names by platform:");
+    console.log("   - CLAUDE.md   (Claude Code)");
+    console.log("   - AGENTS.md   (Cursor, Codex, GitHub Copilot)");
+    console.log("   - GEMINI.md   (Antigravity)\n");
+    const response = await prompts({
+        type: "select",
+        name: "file",
+        message: "Which context file should we update?",
+        choices: [
+            { title: "AGENTS.md (most compatible)", value: "AGENTS.md" },
+            { title: "CLAUDE.md", value: "CLAUDE.md" },
+            { title: "GEMINI.md", value: "GEMINI.md" },
+        ],
+        initial: 0,
+    });
+    if (!response.file) {
+        console.log("\nSetup cancelled.");
+        return;
+    }
+    console.log("\n📝 MCP Server Setup\n");
+    console.log("Configure your AI assistant to run the MCP server:");
+    console.log("   Command: npx");
+    console.log("   Args: -y @popoverai/dotrequirements mcp\n");
+    // Determine platform based on file choice for the install function
+    const platformMap = {
+        "CLAUDE.md": "claude-code",
+        "AGENTS.md": "cursor", // Any AGENTS.md platform works
+        "GEMINI.md": "antigravity",
+    };
+    const platform = platformMap[response.file];
+    await installContextFileSection(platform);
+}
+//# sourceMappingURL=ai-setup.js.map

package/dist/commands/codebase-to-spec/compose.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `dotrequirements codebase-to-spec compose` subcommand.
+ *
+ * Assembles per-area partials into a single composed Markdown document.
+ *
+ * Requirements covered:
+ * - CTS-CLI-2: granular `compose` subcommand
+ * - CTS-COMPOSE-1, CTS-COMPOSE-2
+ */
+export interface ComposeCmdOptions {
+    projectRoot?: string;
+}
+export declare function composeCommand(options?: ComposeCmdOptions): Promise<void>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/commands/codebase-to-spec/compose.js

@@ -0,0 +1,57 @@
+/**
+ * `dotrequirements codebase-to-spec compose` subcommand.
+ *
+ * Assembles per-area partials into a single composed Markdown document.
+ *
+ * Requirements covered:
+ * - CTS-CLI-2: granular `compose` subcommand
+ * - CTS-COMPOSE-1, CTS-COMPOSE-2
+ */
+import { existsSync } from "node:fs";
+import { cachePaths } from "../../codebase-to-spec/cache.js";
+import { runCompose } from "../../codebase-to-spec/compose.js";
+import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
+import { StdoutProgress } from "../../codebase-to-spec/progress.js";
+import { findProjectRoot } from "../../utils/project-settings.js";
+import { readFinalOutline } from "./plan-loop.js";
+export async function composeCommand(options = {}) {
+    const progress = new StdoutProgress();
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.outlineFinal)) {
+        process.stderr.write(`Missing outline at ${paths.outlineFinal}. Run \`dotrequirements cts plan-loop\` first.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    const outline = readFinalOutline(projectRoot);
+    progress.emit({
+        stage: "compose",
+        step: "start",
+        message: `Composing spec from ${outline.areas.length} area partials`,
+    });
+    const result = runCompose({
+        outline,
+        partialPathFor: (sanitized) => paths.partial(sanitized),
+        composedPath: paths.composedSpec,
+    });
+    progress.emit({
+        stage: "compose",
+        step: "done",
+        message: `Composed spec → ${result.composedPath} (${result.partialsIncluded} partials included, ${result.partialsMissing} missing)`,
+        data: {
+            partialsIncluded: result.partialsIncluded,
+            partialsMissing: result.partialsMissing,
+        },
+    });
+    if (result.validationError) {
+        process.stderr.write(`Composed spec failed validation:\n${result.validationError}\n`);
+        process.exitCode = ExitCode.StageFailed;
+        return;
+    }
+    progress.emit({
+        stage: "compose",
+        step: "validation-ok",
+        message: "Composed spec passed schema validation",
+    });
+}
+//# sourceMappingURL=compose.js.map

package/dist/commands/codebase-to-spec/edit-loop.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `dotrequirements codebase-to-spec edit-loop` subcommand.
+ *
+ * Runs the spec review + editor loop over the composed spec.
+ *
+ * Requirements covered:
+ * - CTS-CLI-2: granular `edit-loop` subcommand
+ * - CTS-EDIT-1..6: end-to-end loop behavior
+ */
+export interface EditLoopCmdOptions {
+    maxTurns?: number;
+    model?: string;
+    projectRoot?: string;
+}
+export declare function editLoopCommand(rawOptions?: EditLoopCmdOptions): Promise<void>;
+//# sourceMappingURL=edit-loop.d.ts.map

package/dist/commands/codebase-to-spec/edit-loop.js

@@ -0,0 +1,83 @@
+/**
+ * `dotrequirements codebase-to-spec edit-loop` subcommand.
+ *
+ * Runs the spec review + editor loop over the composed spec.
+ *
+ * Requirements covered:
+ * - CTS-CLI-2: granular `edit-loop` subcommand
+ * - CTS-EDIT-1..6: end-to-end loop behavior
+ */
+import { copyFileSync, existsSync, writeFileSync } from "node:fs";
+import { cachePaths } from "../../codebase-to-spec/cache.js";
+import { DEFAULT_EDIT_LOOP_MAX_TURNS, runEditLoop, } from "../../codebase-to-spec/edit-loop.js";
+import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
+import { StdoutProgress } from "../../codebase-to-spec/progress.js";
+import { findProjectRoot } from "../../utils/project-settings.js";
+export async function editLoopCommand(rawOptions = {}) {
+    const progress = new StdoutProgress();
+    const projectRoot = rawOptions.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    const maxTurns = rawOptions.maxTurns ?? DEFAULT_EDIT_LOOP_MAX_TURNS;
+    if (!existsSync(paths.composedSpec)) {
+        process.stderr.write(`Missing composed spec at ${paths.composedSpec}. Run \`dotrequirements cts compose\` first.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    if (!existsSync(paths.source)) {
+        process.stderr.write(`Missing uncompressed pack at ${paths.source}. Run \`dotrequirements cts pack\` first.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    progress.emit({
+        stage: "spec-review",
+        step: "start",
+        message: `Starting spec review + edit loop (max-turns=${maxTurns})`,
+    });
+    let result;
+    try {
+        result = await runEditLoop({
+            composedSpecPath: paths.composedSpec,
+            specVersionFor: (turn) => paths.specVersion(turn),
+            fullPackPath: paths.source,
+            addDirs: [paths.root],
+            maxTurns,
+            model: rawOptions.model,
+            progress,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`\nEdit loop failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = ExitCode.StageFailed;
+        return;
+    }
+    // Persist per-turn reviewer output (JSON).
+    result.reviewsByTurn.forEach((review, idx) => {
+        writeFileSync(paths.specReviewTurn(idx + 1), `${JSON.stringify(review, null, 2)}\n`, "utf-8");
+    });
+    if (result.hitMaxTurns) {
+        progress.emit({
+            stage: "spec-review",
+            step: "max-turns-hit",
+            message: `Loop hit max-turns (${maxTurns}) without converging. Using latest spec anyway.`,
+            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
+        });
+        process.exitCode = ExitCode.MaxTurnsHit;
+    }
+    else {
+        progress.emit({
+            stage: "spec-review",
+            step: "done",
+            message: `Edit loop converged at turn ${result.turnsUsed} with verdict: ${result.finalVerdict}`,
+            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
+        });
+    }
+    // Copy the final post-edit spec to a stable path so downstream stages
+    // (present) and external tooling have a predictable location.
+    copyFileSync(result.finalSpecPath, paths.specFinal);
+    progress.emit({
+        stage: "spec-review",
+        step: "final-spec",
+        message: `Final spec → ${paths.specFinal}`,
+    });
+}
+//# sourceMappingURL=edit-loop.js.map

package/dist/commands/codebase-to-spec/fan-out.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `dotrequirements codebase-to-spec fan-out` subcommand.
+ *
+ * Runs the specifier for every area in the cached outline, in parallel up to
+ * a bounded concurrency limit, with retry-once on failure.
+ *
+ * Requirements covered:
+ * - CTS-CLI-2: granular `fan-out` subcommand
+ * - CTS-SPEC-1.2: bounded concurrent execution
+ * - CTS-SPEC-5: failure detection + retry + non-blocking continuation
+ */
+export interface FanOutCmdOptions {
+    concurrency?: number;
+    model?: string;
+    cliBinary?: string;
+    projectRoot?: string;
+}
+export declare function fanOutCommand(options?: FanOutCmdOptions): Promise<void>;
+//# sourceMappingURL=fan-out.d.ts.map