@popoverai/dotrequirements 0.23.0 → 0.24.0

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/browsertest.js

@@ -1,30 +1,30 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { getProjectInfo, readProjectSettings, } from '../utils/project-settings.js';
-import { loadAllRequirements, getRequirementTree, formatRequirement, } from '../mcp/requirements.js';
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { formatRequirement, getRequirementTree, loadAllRequirements, } from "../mcp/requirements.js";
+import { getProjectInfo, readProjectSettings, } from "../utils/project-settings.js";
 const execFileAsync = promisify(execFile);
 function extractResults(parsed) {
     if (Array.isArray(parsed))
         return parsed;
-    if (parsed && typeof parsed === 'object') {
+    if (parsed && typeof parsed === "object") {
         const obj = parsed;
         // { results: [...] } format
         if (Array.isArray(obj.results))
             return obj.results;
         // { structured_output: { results: [...] } } format
-        if (obj.structured_output && typeof obj.structured_output === 'object') {
+        if (obj.structured_output && typeof obj.structured_output === "object") {
             const so = obj.structured_output;
             if (Array.isArray(so.results))
                 return so.results;
         }
     }
-    throw new Error('Unexpected browser-automation output format');
+    throw new Error("Unexpected browser-automation output format");
 }
 export async function browserTestCommand(requirementKey, url, options) {
     // 1. Find project and load settings
     const projectInfo = getProjectInfo();
     if (!projectInfo) {
-        console.error('Error: No dotrequirements project found.');
+        console.error("Error: No dotrequirements project found.");
         console.log('Run "dotrequirements init" to create one.');
         process.exit(1);
     }
@@ -40,7 +40,7 @@ export async function browserTestCommand(requirementKey, url, options) {
     // 2. Determine URL
     const targetURL = url || settings?.defaultURL;
     if (!targetURL) {
-        console.error('Error: No URL provided and no defaultURL in project-settings.json.');
+        console.error("Error: No URL provided and no defaultURL in project-settings.json.");
         console.log('Either provide a URL argument or add "defaultURL" to .requirements/project-settings.json');
         process.exit(1);
     }
@@ -49,23 +49,23 @@ export async function browserTestCommand(requirementKey, url, options) {
     const modelApiKey = settings?.browserTest?.modelApiKey;
     const geminiApiKey = settings?.browserTest?.geminiApiKey;
     if (!modelName && !modelApiKey && !geminiApiKey) {
-        console.error('Error: no browser-test model configured in project-settings.json.');
-        console.log('Add a block like:\n' +
+        console.error("Error: no browser-test model configured in project-settings.json.");
+        console.log("Add a block like:\n" +
             '  "browserTest": {\n' +
             '    "modelName": "gateway/anthropic/claude-haiku-4-5",\n' +
             '    "modelApiKey": "..."\n' +
-            '  }\n' +
-            'to .requirements/project-settings.json. See the docs for supported models.');
+            "  }\n" +
+            "to .requirements/project-settings.json. See the docs for supported models.");
         process.exit(1);
     }
     if ((modelName && !modelApiKey) || (modelApiKey && !modelName)) {
-        console.error('Error: browserTest.modelName and browserTest.modelApiKey must be set together.');
+        console.error("Error: browserTest.modelName and browserTest.modelApiKey must be set together.");
         process.exit(1);
     }
     // 4. Load requirements
     const { flattened } = await loadAllRequirements(projectInfo.rootPath);
     if (flattened.length === 0) {
-        console.error('Error: No requirements found in .requirements/');
+        console.error("Error: No requirements found in .requirements/");
         process.exit(1);
     }
     // 5. Find the requirement tree
@@ -86,7 +86,8 @@ export async function browserTestCommand(requirementKey, url, options) {
         env.GEMINI_API_KEY = geminiApiKey;
     }
     if (settings?.browserTest?.vercelBypassSecret) {
-        env.VERCEL_AUTOMATION_BYPASS_SECRET = settings.browserTest.vercelBypassSecret;
+        env.VERCEL_AUTOMATION_BYPASS_SECRET =
+            settings.browserTest.vercelBypassSecret;
     }
     if (settings?.browserTest?.browserbaseApiKey) {
         env.BROWSERBASE_API_KEY = settings.browserTest.browserbaseApiKey;
@@ -99,8 +100,14 @@ export async function browserTestCommand(requirementKey, url, options) {
         console.log(`Testing ${requirementKey} against ${targetURL}...\n`);
     }
     try {
-        const modelFlags = modelName ? ['--modelName', modelName] : [];
-        const { stdout } = await execFileAsync('npx', ['@popoverai/browser-automation', 'test', ...modelFlags, targetURL, ...assertions], { env, maxBuffer: 10 * 1024 * 1024 });
+        const modelFlags = modelName ? ["--modelName", modelName] : [];
+        const { stdout } = await execFileAsync("npx", [
+            "@popoverai/browser-automation",
+            "test",
+            ...modelFlags,
+            targetURL,
+            ...assertions,
+        ], { env, maxBuffer: 10 * 1024 * 1024 });
         // 9. Parse results
         let results;
         try {
@@ -108,7 +115,7 @@ export async function browserTestCommand(requirementKey, url, options) {
             results = extractResults(parsed);
         }
         catch (parseErr) {
-            console.error('Error: Could not parse browser-automation output');
+            console.error("Error: Could not parse browser-automation output");
             console.error(parseErr.message);
             console.error(stdout);
             process.exit(1);
@@ -121,7 +128,7 @@ export async function browserTestCommand(requirementKey, url, options) {
             displayResults(requirementTree, results);
         }
         // 11. Exit with appropriate code
-        const failedCount = results.filter((r) => r.status !== 'passed').length;
+        const failedCount = results.filter((r) => r.status !== "passed").length;
         if (failedCount > 0) {
             process.exit(1);
         }
@@ -143,7 +150,7 @@ export async function browserTestCommand(requirementKey, url, options) {
             }
             catch {
                 // Not JSON, show raw output
-                console.error('browser-automation error:');
+                console.error("browser-automation error:");
                 if (error.stdout)
                     console.error(error.stdout);
                 if (error.stderr)
@@ -170,14 +177,14 @@ function displayResults(requirements, results) {
             failedCount++;
             continue;
         }
-        const indent = '  '.repeat(req.path.length);
-        const label = req.label ? ` (${req.label})` : '';
-        const icon = result.status === 'passed' ? '\u2713' : '\u2717';
+        const indent = "  ".repeat(req.path.length);
+        const label = req.label ? ` (${req.label})` : "";
+        const icon = result.status === "passed" ? "\u2713" : "\u2717";
         console.log(`${indent}${icon} ${req.id}${label}: ${req.content}`);
-        if (result.status !== 'passed' && result.notes) {
+        if (result.status !== "passed" && result.notes) {
             console.log(`${indent}  \u2192 ${result.notes}`);
         }
-        if (result.status === 'passed') {
+        if (result.status === "passed") {
             passedCount++;
         }
         else {
@@ -197,7 +204,7 @@ function outputJson(requirements, results) {
         id: req.id,
         label: req.label || null,
         content: req.content,
-        status: results[i]?.status || 'blocked',
+        status: results[i]?.status || "blocked",
         notes: results[i]?.notes || null,
     }));
     console.log(JSON.stringify(combined, null, 2));

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