task-o-matic 0.0.20 → 0.0.22

package/dist/commands/prd.js

@@ -1,43 +1,11 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prdCommand = void 0;
+exports.parseModelString = parseModelString;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
@@ -45,45 +13,103 @@ const fs_1 = require("fs");
 const prd_1 = require("../services/prd");
 const streaming_options_1 = require("../utils/streaming-options");
 const progress_1 = require("../cli/display/progress");
+const path_1 = require("path");
+const ai_parallel_1 = require("./utils/ai-parallel");
 exports.prdCommand = new commander_1.Command("prd").description("Manage PRDs and generate tasks");
-const task_o_matic_error_1 = require("../utils/task-o-matic-error");
-// Helper to parse model string (provider:model)
+const validation_1 = require("../lib/validation");
+const config_1 = require("../lib/config");
+const path_2 = __importDefault(require("path"));
+// Helper to parse model string ([provider:]model[;reasoning[=budget]])
 function parseModelString(modelStr) {
-    const parts = modelStr.split(":");
-    if (parts.length < 2) {
-        throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, `Invalid model format: ${modelStr}. Expected provider:model`, {
-            suggestions: [
-                "Use the format 'provider:model'",
-                "Example: 'anthropic:claude-3.5-sonnet'",
-            ],
-        });
+    let processingStr = modelStr;
+    let reasoning;
+    // 1. Extract reasoning
+    // Format: ;reasoning or ;reasoning=1000
+    const reasoningMatch = processingStr.match(/;reasoning(?:=(\d+))?$/);
+    if (reasoningMatch) {
+        // If specific budget provided (group 1), use it.
+        // Otherwise default to "2000" as requested.
+        reasoning = reasoningMatch[1] ? reasoningMatch[1] : "2000";
+        // Remove the reasoning suffix from the string
+        processingStr = processingStr.substring(0, reasoningMatch.index);
+    }
+    // 2. Extract provider and model
+    // We look for the first colon.
+    const firstColonIndex = processingStr.indexOf(":");
+    if (firstColonIndex === -1) {
+        // No colon -> It's just a model name (provider inferred from env/defaults later)
+        return {
+            provider: undefined,
+            model: processingStr,
+            reasoning,
+        };
     }
-    return { provider: parts[0], model: parts[1] };
+    // Has colon. Check if the part before is a valid provider.
+    const potentialProvider = processingStr.substring(0, firstColonIndex);
+    const potentialModel = processingStr.substring(firstColonIndex + 1);
+    if ((0, validation_1.isValidAIProvider)(potentialProvider)) {
+        // It is a known provider
+        return {
+            provider: potentialProvider,
+            model: potentialModel,
+            reasoning,
+        };
+    }
+    // Not a known provider. Treat the whole thing as the model name.
+    // This handles cases like "google/gemini...:free" where "google/gemini..." isn't a provider key.
+    // Or just "model:with:colons".
+    return {
+        provider: undefined,
+        model: processingStr,
+        reasoning,
+    };
 }
 // Create PRD command
 exports.prdCommand
     .command("create")
     .description("Generate PRD(s) from a product description")
     .argument("<description>", "Product description")
-    .option("--ai <provider:model...>", "AI model(s) to use for generation (can specify multiple)")
+    .option("--ai <models...>", "AI model(s) to use. Format: [provider:]model[;reasoning[=budget]]. Example: openrouter:openai/gpt-5;reasoning=2000")
     .option("--combine-ai <provider:model>", "AI model to combine multiple PRDs into master PRD")
     .option("--output-dir <path>", "Directory to save PRDs", ".task-o-matic/prd")
+    .option("--ai-reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
     .option("--stream", "Enable streaming output (only for single AI)")
     .action(async (description, options) => {
     try {
-        const aiModels = options.ai || ["openrouter:anthropic/claude-3.5-sonnet"];
+        // Load configuration to get defaults
+        await config_1.configManager.load();
+        const aiConfig = config_1.configManager.getAIConfig();
+        let defaultModelStr = `${aiConfig.provider}:${aiConfig.model}`;
+        // Handle default reasoning configuration
+        if (aiConfig.reasoning) {
+            defaultModelStr += ";reasoning";
+            if (aiConfig.reasoning.maxTokens) {
+                defaultModelStr += `=${aiConfig.reasoning.maxTokens}`;
+            }
+        }
+        const cliModels = Array.isArray(options.ai)
+            ? options.ai
+            : options.ai
+                ? [options.ai]
+                : [];
+        // If CLI models provided, append them to default. If not, just use default.
+        // Logic: Default is ALWAYS included unless explicitly disabled (feature for later?)
+        // Current requirement: "I WANT BOTH"
+        const aiModels = [...new Set([defaultModelStr, ...cliModels])];
         const isSingleModel = aiModels.length === 1;
         // For single model, support streaming
-        if (isSingleModel) {
+        if (isSingleModel && !options.combineAi) {
             const modelConfig = parseModelString(aiModels[0]);
             const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Generating PRD");
             const result = await prd_1.prdService.generatePRD({
                 description,
                 outputDir: options.outputDir,
-                filename: `prd-${modelConfig.provider}-${modelConfig.model.replace(/\//g, "-")}.md`,
+                filename: `prd-${modelConfig.provider ? `${modelConfig.provider}-` : ""}${modelConfig.model.replace(/[:/]/g, "-")}.md`,
                 aiOptions: {
                     aiProvider: modelConfig.provider,
                     aiModel: modelConfig.model,
+                    // CLI flag overrides model string config
+                    aiReasoning: options.aiReasoning || modelConfig.reasoning,
                 },
                 streamingOptions,
                 callbacks: {
@@ -102,107 +128,56 @@ exports.prdCommand
             }
         }
         else {
-            // Multiple models - use benchmark-style display
-            console.log(chalk_1.default.blue(`\nGenerating ${aiModels.length} PRDs concurrently...\n`));
-            const modelMap = new Map();
-            const modelStatus = new Map();
-            const results = [];
-            // Print initial lines
-            aiModels.forEach((m, i) => {
-                modelMap.set(m, i);
-                modelStatus.set(m, "Waiting...");
-                console.log(chalk_1.default.dim(`- ${m}: Waiting...`));
-            });
-            const totalModels = aiModels.length;
-            // Generate PRDs concurrently
-            const promises = aiModels.map(async (modelStr) => {
-                const modelConfig = parseModelString(modelStr);
-                const index = modelMap.get(modelStr);
-                // Update status: Starting
-                const up = totalModels - index;
-                process.stdout.write(`\x1B[${up}A`);
-                process.stdout.write(`\x1B[2K`);
-                process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.yellow("Starting...")}\r`);
-                process.stdout.write(`\x1B[${up}B`);
-                try {
-                    const result = await prd_1.prdService.generatePRD({
-                        description,
-                        outputDir: options.outputDir,
-                        filename: `prd-${modelConfig.provider}-${modelConfig.model.replace(/\//g, "-")}.md`,
-                        aiOptions: {
-                            aiProvider: modelConfig.provider,
-                            aiModel: modelConfig.model,
-                        },
-                        callbacks: {
-                            onProgress: (event) => {
-                                if (event.type === "progress") {
-                                    const up = totalModels - index;
-                                    process.stdout.write(`\x1B[${up}A`);
-                                    process.stdout.write(`\x1B[2K`);
-                                    process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.blue(event.message)}\r`);
-                                    process.stdout.write(`\x1B[${up}B`);
-                                }
-                            },
-                        },
-                    });
-                    // Update status: Completed
-                    const up2 = totalModels - index;
-                    process.stdout.write(`\x1B[${up2}A`);
-                    process.stdout.write(`\x1B[2K`);
-                    process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.green(`Completed (${result.stats.duration}ms)`)}\r`);
-                    process.stdout.write(`\x1B[${up2}B`);
-                    results.push({
-                        modelId: modelStr,
-                        path: result.path,
-                        stats: result.stats,
-                    });
-                    return result;
-                }
-                catch (error) {
-                    const up2 = totalModels - index;
-                    process.stdout.write(`\x1B[${up2}A`);
-                    process.stdout.write(`\x1B[2K`);
-                    process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.red(`Failed: ${error instanceof Error ? error.message : String(error)}`)}\r`);
-                    process.stdout.write(`\x1B[${up2}B`);
-                    throw error;
-                }
-            });
-            await Promise.all(promises);
-            // Display summary
-            console.log(chalk_1.default.green(`\n✓ Generated ${results.length} PRDs\n`));
-            console.log(chalk_1.default.bold(`${"Model".padEnd(40)} | ${"Duration".padEnd(10)} | ${"TTFT".padEnd(10)} | ${"Tokens".padEnd(10)}`));
-            console.log("-".repeat(80));
-            results.forEach((r) => {
-                const duration = `${r.stats.duration}ms`;
-                const ttft = r.stats.timeToFirstToken
-                    ? `${r.stats.timeToFirstToken}ms`
-                    : "N/A";
-                const tokens = r.stats.tokenUsage
-                    ? r.stats.tokenUsage.total.toString()
-                    : "N/A";
-                console.log(`${r.modelId.padEnd(40)} | ${duration.padEnd(10)} | ${ttft.padEnd(10)} | ${tokens.padEnd(10)}`);
-            });
-            // Combine if requested
-            if (options.combineAi) {
-                console.log(chalk_1.default.blue("\nCombining PRDs into master PRD..."));
-                const combineModelConfig = parseModelString(options.combineAi);
-                const prdContents = results.map((r) => (0, fs_1.readFileSync)(r.path, "utf-8"));
-                const masterResult = await prd_1.prdService.combinePRDs({
-                    prds: prdContents,
-                    originalDescription: description,
+            // Multiple models or combine request - use parallel utility
+            const results = await (0, ai_parallel_1.runAIParallel)(aiModels, async (modelConfig, streamingOptions) => {
+                const result = await prd_1.prdService.generatePRD({
+                    description,
                     outputDir: options.outputDir,
-                    filename: "prd-master.md",
+                    filename: `prd-${modelConfig.provider ? `${modelConfig.provider}-` : ""}${modelConfig.model.replace(/[:/]/g, "-")}.md`,
                     aiOptions: {
-                        aiProvider: combineModelConfig.provider,
-                        aiModel: combineModelConfig.model,
+                        aiProvider: modelConfig.provider,
+                        aiModel: modelConfig.model,
+                        aiReasoning: options.aiReasoning || modelConfig.reasoning,
                     },
+                    streamingOptions,
                     callbacks: {
-                        onProgress: progress_1.displayProgress,
-                        onError: progress_1.displayError,
+                        onProgress: (event) => {
+                            /* handled by parallel util mostly, but could hook here */
+                        },
                     },
                 });
-                console.log(chalk_1.default.green(`\n✓ Master PRD created: ${masterResult.path}`));
-                console.log(chalk_1.default.cyan(`  Duration: ${masterResult.stats.duration}ms`));
+                // Wrap in expected structure
+                return {
+                    data: result,
+                    stats: result.stats,
+                };
+            }, {
+                description: "Generating PRDs",
+                showSummary: true,
+            });
+            // Combine if requested
+            if (options.combineAi) {
+                const prdContents = results.map((r) => r.data.content);
+                // Helper to get reasoning from combine string if present
+                const combineModelConfig = parseModelString(options.combineAi);
+                const reasoning = options.aiReasoning || combineModelConfig.reasoning;
+                const masterPath = await (0, ai_parallel_1.combinePRDs)(prdContents, description, options.combineAi, options.stream, reasoning);
+                // Need to manually save since combinePRDs utility returns content string or path?
+                // Wait, the utility I wrote returns string (content).
+                // Actually, let's correct the utility usage or the utility itself.
+                // Looking at the utility: it calls `aiOperations.combinePRDs` which returns string (content).
+                // But `prdService.combinePRDs` (old code) saved the file.
+                // I should probably use `prdService.combinePRDs` INSIDE the utility or here?
+                // The utility uses `aiOperations`. So I get content back. I need to save it.
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                const filename = "prd-master.md"; // Force master name or unique? Default to prd-master.md as per old code.
+                const savePath = path_2.default.join(options.outputDir, filename);
+                // Ensure dir exists
+                if (!(0, fs_1.existsSync)(options.outputDir)) {
+                    (0, fs_1.mkdirSync)(options.outputDir, { recursive: true });
+                }
+                (0, fs_1.writeFileSync)(savePath, masterPath); // masterPath is actually content here based on my utility return type
+                console.log(chalk_1.default.green(`\n✓ Master PRD created: ${savePath}`));
             }
         }
     }
@@ -219,6 +194,7 @@ exports.prdCommand
     .requiredOption("--description <text>", "Original product description")
     .requiredOption("--ai <provider:model>", "AI model to use for combining")
     .option("--output <path>", "Output file path", "prd-master.md")
+    .option("--ai-reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
     .option("--stream", "Enable streaming output")
     .action(async (options) => {
     try {
@@ -233,6 +209,7 @@ exports.prdCommand
             aiOptions: {
                 aiProvider: modelConfig.provider,
                 aiModel: modelConfig.model,
+                aiReasoning: options.aiReasoning || modelConfig.reasoning,
             },
             streamingOptions,
             callbacks: {
@@ -257,6 +234,8 @@ exports.prdCommand
     .command("parse")
     .description("Parse a PRD file into structured tasks")
     .requiredOption("--file <path>", "Path to PRD file")
+    .option("--ai <models...>", "AI model(s) to use. Format: [provider:]model[;reasoning[=budget]]")
+    .option("--combine-ai <provider:model>", "AI model to combine multiple parsed results")
     .option("--prompt <prompt>", "Override prompt")
     .option("--message <message>", "User message")
     .option("--ai-provider <provider>", "AI provider override")
@@ -271,51 +250,182 @@ exports.prdCommand
         // Determine working directory from current process location
         // Service layer should receive this explicitly, not use process.cwd()
         const workingDirectory = process.cwd();
-        const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Parsing");
-        const result = await prd_1.prdService.parsePRD({
-            file: options.file,
-            workingDirectory, // Pass working directory explicitly to service
-            enableFilesystemTools: options.tools,
-            aiOptions: {
-                aiProvider: options.aiProvider,
-                aiModel: options.aiModel,
-                aiKey: options.aiKey,
-                aiProviderUrl: options.aiProviderUrl,
-                aiReasoning: options.aiReasoning,
-            },
-            promptOverride: options.prompt,
-            messageOverride: options.message,
-            streamingOptions,
-            callbacks: {
-                onProgress: progress_1.displayProgress,
-                onError: progress_1.displayError,
-            },
-        });
-        console.log("");
-        console.log(chalk_1.default.blue(`📊 PRD Parsing Summary:`));
-        console.log(chalk_1.default.cyan(`  Tasks created: ${result.stats.tasksCreated}`));
-        console.log(chalk_1.default.cyan(`  Duration: ${result.stats.duration}ms`));
-        console.log(chalk_1.default.cyan(`  AI Model: ${result.stats.aiModel}`));
-        console.log(chalk_1.default.blue("\n📋 Processing Steps:"));
-        result.steps.forEach((step) => {
-            const icon = step.status === "completed" ? "✓" : "✗";
-            console.log(`  ${icon} ${step.step} (${step.duration}ms)`);
-            if (step.details) {
-                console.log(chalk_1.default.gray(`     ${JSON.stringify(step.details)}`));
+        // Support multi-model if array of models provided in options.ai (added to command option below)
+        const cliModels = Array.isArray(options.ai)
+            ? options.ai
+            : options.ai
+                ? [options.ai]
+                : [];
+        // If just single model or no model specified (uses service default), use old flow OR simple parallel entry
+        // But wait, the parse command options define --ai-provider, --ai-model separately in old code.
+        // I need to update the command definition to support --ai like create/split.
+        // Let's assume I updated the options in the definition (will do in next chunk).
+        // If we have "ai" models list, we use parallel.
+        if (cliModels.length > 0 || options.combineAi) {
+            // Parallel execution
+            const modelsToUse = cliModels.length > 0
+                ? cliModels
+                : [`${options.aiProvider}:${options.aiModel}`];
+            const results = await (0, ai_parallel_1.runAIParallel)(modelsToUse, async (modelConfig, streamingOptions) => {
+                const result = await prd_1.prdService.parsePRD({
+                    file: options.file,
+                    workingDirectory,
+                    enableFilesystemTools: options.tools,
+                    aiOptions: {
+                        aiProvider: modelConfig.provider,
+                        aiModel: modelConfig.model,
+                        aiReasoning: options.aiReasoning || modelConfig.reasoning,
+                    },
+                    promptOverride: options.prompt,
+                    messageOverride: options.message,
+                    streamingOptions,
+                    callbacks: {
+                        onProgress: (event) => { },
+                    },
+                });
+                // Save intermediate result
+                const safeModel = (modelConfig.model || "")
+                    .replace(/[^a-z0-9]/gi, "-")
+                    .toLowerCase();
+                const filename = `tasks-${modelConfig.provider}-${safeModel}.json`;
+                const tasksDir = path_2.default.join(process.cwd(), ".task-o-matic", "tasks");
+                if (!(0, fs_1.existsSync)(tasksDir)) {
+                    (0, fs_1.mkdirSync)(tasksDir, { recursive: true });
+                }
+                const outputPath = path_2.default.join(tasksDir, filename);
+                try {
+                    (0, fs_1.writeFileSync)(outputPath, JSON.stringify(result.tasks, null, 2));
+                    // console.log(chalk.dim(`   Saved: ${filename}`)); // Too verbose for parallel output?
+                }
+                catch (e) {
+                    // ignore write error
+                }
+                return {
+                    data: result,
+                    stats: result.stats,
+                };
+            }, {
+                description: "Parsing PRD",
+                showSummary: true,
+            });
+            // Phase 2: Cleanup intermediate tasks.json to prevent duplicates
+            const tasksJsonPath = (0, path_1.join)(workingDirectory, ".task-o-matic", "tasks.json");
+            if ((0, fs_1.existsSync)(tasksJsonPath)) {
+                try {
+                    (0, fs_1.unlinkSync)(tasksJsonPath);
+                    // console.log(chalk.dim("Cleaned up intermediate tasks.json"));
+                }
+                catch (e) {
+                    console.warn(chalk_1.default.yellow("Warning: Failed to cleanup tasks.json"));
+                }
             }
-        });
-        // Show created tasks
-        console.log(chalk_1.default.blue("\n✨ Created Tasks:"));
-        result.tasks.forEach((task, index) => {
-            console.log(`${index + 1}. ${chalk_1.default.bold(task.title)} (${task.id})`);
-            if (task.description) {
-                console.log(chalk_1.default.gray(`   ${task.description.substring(0, 100)}${task.description.length > 100 ? "..." : ""}`));
+            if (options.combineAi && results.length > 0) {
+                const taskLists = results.map((r) => r.data.tasks);
+                const combineModelConfig = parseModelString(options.combineAi);
+                console.log(chalk_1.default.blue(`\nCombining ${taskLists.length} task lists with ${combineModelConfig.model}...`));
+                // Construct the message with drafts
+                let draftsMessage = "Here are draft task lists generated by multiple models. Please combine them into the best possible single list ensuring strict schema compliance:\n\n";
+                results.forEach((r, idx) => {
+                    // Try to identify model from earlier scope or just use index
+                    // We can reconstruct model string or just label "Model N"
+                    draftsMessage += `--- Model ${idx + 1} Draft ---\n${JSON.stringify(r.data.tasks, null, 2)}\n\n`;
+                });
+                // Phase 3: Service-Based Combination
+                // Calls prdService.parsePRD which will validate AND save the final tasks to the clean tasks.json
+                const result = await prd_1.prdService.parsePRD({
+                    file: options.file,
+                    workingDirectory,
+                    enableFilesystemTools: options.tools,
+                    aiOptions: {
+                        aiProvider: combineModelConfig.provider,
+                        aiModel: combineModelConfig.model,
+                        aiReasoning: options.aiReasoning || combineModelConfig.reasoning,
+                    },
+                    promptOverride: options.prompt, // Pass original prompt if any
+                    messageOverride: draftsMessage, // Inject drafts
+                    streamingOptions: (0, streaming_options_1.createStreamingOptions)(options.stream, "Combining"),
+                    callbacks: {
+                        onProgress: progress_1.displayProgress,
+                        onError: progress_1.displayError,
+                    },
+                });
+                console.log(chalk_1.default.green(`\n✓ Combined and saved ${result.tasks.length} tasks.`));
             }
-            if (task.estimatedEffort) {
-                console.log(chalk_1.default.cyan(`   Effort: ${task.estimatedEffort}`));
+            else if (results.length > 0) {
+                // No combine requested, but we deleted tasks.json.
+                // We use the service to save the "best" (first) result to ensure IDs and dependencies are preserved.
+                // We do this by feeding the tasks back to the service as a "draft" to strictly follow.
+                const bestResult = results[0].data;
+                console.log(chalk_1.default.yellow("\n⚠️  Multiple models used without --combine-ai. Saving result from first model."));
+                const draftsMessage = `Here is the pre-generated task list. Please validate and save it exactly as is, preserving all IDs and dependencies:\n\n${JSON.stringify(bestResult.tasks, null, 2)}`;
+                await prd_1.prdService.parsePRD({
+                    file: options.file,
+                    workingDirectory,
+                    enableFilesystemTools: options.tools,
+                    aiOptions: {
+                        aiProvider: options.aiProvider, // Use default or overridden local options
+                        aiModel: options.aiModel,
+                        aiReasoning: options.aiReasoning,
+                    },
+                    promptOverride: options.prompt,
+                    messageOverride: draftsMessage,
+                    streamingOptions: (0, streaming_options_1.createStreamingOptions)(options.stream, "Saving"),
+                    callbacks: {
+                        onProgress: progress_1.displayProgress,
+                        onError: progress_1.displayError,
+                    },
+                });
+                console.log(chalk_1.default.green(`✓ Saved ${bestResult.tasks.length} tasks.`));
             }
+        }
+        else {
+            // Fallback to original single flow
+            const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Parsing");
+            const result = await prd_1.prdService.parsePRD({
+                file: options.file,
+                workingDirectory, // Pass working directory explicitly to service
+                enableFilesystemTools: options.tools,
+                aiOptions: {
+                    aiProvider: options.aiProvider,
+                    aiModel: options.aiModel,
+                    aiKey: options.aiKey,
+                    aiProviderUrl: options.aiProviderUrl,
+                    aiReasoning: options.aiReasoning,
+                },
+                promptOverride: options.prompt,
+                messageOverride: options.message,
+                streamingOptions,
+                callbacks: {
+                    onProgress: progress_1.displayProgress,
+                    onError: progress_1.displayError,
+                },
+            });
             console.log("");
-        });
+            console.log(chalk_1.default.blue(`📊 PRD Parsing Summary:`));
+            console.log(chalk_1.default.cyan(`  Tasks created: ${result.stats.tasksCreated}`));
+            console.log(chalk_1.default.cyan(`  Duration: ${result.stats.duration}ms`));
+            console.log(chalk_1.default.cyan(`  AI Model: ${result.stats.aiModel}`));
+            console.log(chalk_1.default.blue("\n📋 Processing Steps:"));
+            result.steps.forEach((step) => {
+                const icon = step.status === "completed" ? "✓" : "✗";
+                console.log(`  ${icon} ${step.step} (${step.duration}ms)`);
+                if (step.details) {
+                    console.log(chalk_1.default.gray(`     ${JSON.stringify(step.details)}`));
+                }
+            });
+            // Show created tasks
+            console.log(chalk_1.default.blue("\n✨ Created Tasks:"));
+            result.tasks.forEach((task, index) => {
+                console.log(`${index + 1}. ${chalk_1.default.bold(task.title)} (${task.id})`);
+                if (task.description) {
+                    console.log(chalk_1.default.gray(`   ${task.description.substring(0, 100)}${task.description.length > 100 ? "..." : ""}`));
+                }
+                if (task.estimatedEffort) {
+                    console.log(chalk_1.default.cyan(`   Effort: ${task.estimatedEffort}`));
+                }
+                console.log("");
+            });
+        }
     }
     catch (error) {
         (0, progress_1.displayError)(error);
@@ -413,8 +523,7 @@ exports.prdCommand
             },
         });
         const outputPath = options.output || "prd-questions.json";
-        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
-        fs.writeFileSync(outputPath, JSON.stringify({ questions }, null, 2));
+        (0, fs_1.writeFileSync)(outputPath, JSON.stringify({ questions }, null, 2));
         console.log("");
         console.log(chalk_1.default.green(`✓ Generated ${questions.length} questions`));
         console.log(chalk_1.default.cyan(`Saved to: ${outputPath}`));
@@ -447,12 +556,11 @@ exports.prdCommand
     .action(async (options) => {
     try {
         const workingDirectory = process.cwd();
-        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
         let questions = [];
         // If questions file provided, load it
-        if (options.questions && fs.existsSync(options.questions)) {
+        if (options.questions && (0, fs_1.existsSync)(options.questions)) {
             console.log(chalk_1.default.blue(`Loading questions from ${options.questions}...`));
-            const content = fs.readFileSync(options.questions, "utf-8");
+            const content = (0, fs_1.readFileSync)(options.questions, "utf-8");
             const data = JSON.parse(content);
             questions = data.questions || [];
         }

package/dist/commands/tasks/split.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/split.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,eAAO,MAAM,YAAY,SAsHpB,CAAC"}
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/split.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0BpC,eAAO,MAAM,YAAY,SA+RtB,CAAC"}