task-o-matic 0.0.6 → 0.0.8

package/dist/commands/workflow.js

@@ -1,5 +1,38 @@
 #!/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 };
 };
@@ -9,27 +42,84 @@ const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const config_1 = require("../lib/config");
-const better_t_stack_cli_1 = require("../lib/better-t-stack-cli");
+const workflow_1 = require("../services/workflow");
 const prd_1 = require("../services/prd");
-const tasks_1 = require("../services/tasks");
-const workflow_ai_assistant_1 = require("../services/workflow-ai-assistant");
+const inquirer_1 = __importDefault(require("inquirer"));
 const workflow_prompts_1 = require("../utils/workflow-prompts");
 const streaming_options_1 = require("../utils/streaming-options");
 const progress_1 = require("../cli/display/progress");
 exports.workflowCommand = new commander_1.Command("workflow")
     .description("Interactive workflow for complete project setup and task management")
+    // Existing AI options
     .option("--stream", "Show streaming AI output")
     .option("--ai-provider <provider>", "AI provider override")
     .option("--ai-model <model>", "AI model override")
     .option("--ai-key <key>", "AI API key override")
-    .action(async (options) => {
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    // Global workflow control
+    .option("--skip-all", "Skip all optional steps (use defaults)")
+    .option("--auto-accept", "Auto-accept all AI suggestions")
+    .option("--config-file <path>", "Load workflow options from JSON file")
+    // Step 1: Initialize
+    .option("--skip-init", "Skip initialization step")
+    .option("--project-name <name>", "Project name")
+    .option("--init-method <method>", "Initialization method: quick, custom, ai")
+    .option("--project-description <desc>", "Project description for AI-assisted init")
+    .option("--use-existing-config", "Use existing configuration if found")
+    .option("--frontend <framework>", "Frontend framework")
+    .option("--backend <framework>", "Backend framework")
+    .option("--database <db>", "Database choice")
+    .option("--auth", "Include authentication")
+    .option("--no-auth", "Exclude authentication")
+    .option("--bootstrap", "Bootstrap with Better-T-Stack")
+    .option("--no-bootstrap", "Skip bootstrapping")
+    // Step 2: Define PRD
+    .option("--skip-prd", "Skip PRD definition")
+    .option("--prd-method <method>", "PRD method: upload, manual, ai, skip")
+    .option("--prd-file <path>", "Path to existing PRD file")
+    .option("--prd-description <desc>", "Product description for AI-assisted PRD")
+    .option("--prd-content <content>", "Direct PRD content")
+    // Step 2.5: PRD Question/Refine (NEW)
+    .option("--skip-prd-question-refine", "Skip PRD question/refine step")
+    .option("--prd-question-refine", "Use question-based PRD refinement")
+    .option("--prd-answer-mode <mode>", "Who answers questions: user, ai")
+    .option("--prd-answer-ai-provider <provider>", "AI provider for answering (optional override)")
+    .option("--prd-answer-ai-model <model>", "AI model for answering (optional override)")
+    .option("--prd-answer-ai-reasoning", "Enable reasoning for AI answering model (if supported)")
+    // Step 3: Refine PRD
+    .option("--skip-refine", "Skip PRD refinement")
+    .option("--refine-method <method>", "Refinement method: manual, ai, skip")
+    .option("--refine-feedback <feedback>", "Feedback for AI refinement")
+    // Step 4: Generate Tasks
+    .option("--skip-generate", "Skip task generation")
+    .option("--generate-method <method>", "Generation method: standard, ai")
+    .option("--generate-instructions <instructions>", "Custom task generation instructions")
+    // Step 5: Split Tasks
+    .option("--skip-split", "Skip task splitting")
+    .option("--split-tasks <ids>", "Comma-separated task IDs to split")
+    .option("--split-all", "Split all tasks")
+    .option("--split-method <method>", "Split method: interactive, standard, custom")
+    .option("--split-instructions <instructions>", "Custom split instructions")
+    .action(async (cliOptions) => {
     try {
+        // Load and merge options from config file if specified
+        const options = await loadWorkflowOptions(cliOptions);
         console.log(chalk_1.default.blue.bold("\n🚀 Task-O-Matic Interactive Workflow\n"));
+        // Show automation status
+        if (options.configFile) {
+            console.log(chalk_1.default.cyan(`📋 Using config: ${options.configFile}`));
+        }
+        if (options.skipAll) {
+            console.log(chalk_1.default.yellow("⚡ Fast mode: Skipping all optional steps"));
+        }
+        if (options.autoAccept) {
+            console.log(chalk_1.default.yellow("✓ Auto-accepting all AI suggestions"));
+        }
         console.log(chalk_1.default.gray("This wizard will guide you through:"));
         console.log(chalk_1.default.gray("  1. Project initialization & bootstrap"));
         console.log(chalk_1.default.gray("  2. PRD definition"));
-        console.log(chalk_1.default.gray("  3. PRD refinement"));
+        console.log(chalk_1.default.gray("  2.5. PRD question & refinement (optional)"));
+        console.log(chalk_1.default.gray("  3. PRD manual refinement (optional)"));
         console.log(chalk_1.default.gray("  4. Task generation"));
         console.log(chalk_1.default.gray("  5. Task splitting\n"));
         const state = {
@@ -37,23 +127,19 @@ exports.workflowCommand = new commander_1.Command("workflow")
             currentStep: "initialize",
             projectDir: process.cwd(),
         };
-        // Store AI options for later use
-        const aiOptions = {
-            aiProvider: options.aiProvider,
-            aiModel: options.aiModel,
-            aiKey: options.aiKey,
-        };
         const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Workflow");
         // Step 1: Initialize/Bootstrap
-        await stepInitialize(state, aiOptions, streamingOptions);
+        await stepInitialize(state, options, streamingOptions);
         // Step 2: Define PRD
-        await stepDefinePRD(state, aiOptions, streamingOptions);
+        await stepDefinePRD(state, options, streamingOptions);
+        // Step 2.5: PRD Question/Refine (NEW)
+        await stepPRDQuestionRefine(state, options, streamingOptions);
         // Step 3: Refine PRD
-        await stepRefinePRD(state, aiOptions, streamingOptions);
+        await stepRefinePRD(state, options, streamingOptions);
         // Step 4: Generate Tasks
-        await stepGenerateTasks(state, aiOptions, streamingOptions);
+        await stepGenerateTasks(state, options, streamingOptions);
         // Step 5: Split Tasks
-        await stepSplitTasks(state, aiOptions, streamingOptions);
+        await stepSplitTasks(state, options, streamingOptions);
         // Complete
         state.currentStep = "complete";
         console.log(chalk_1.default.green.bold("\n✅ Workflow Complete!\n"));
@@ -68,370 +154,417 @@ exports.workflowCommand = new commander_1.Command("workflow")
         process.exit(1);
     }
 });
+/**
+ * Load and merge workflow options from config file if specified
+ */
+async function loadWorkflowOptions(cliOptions) {
+    let options = { ...cliOptions };
+    if (cliOptions.configFile) {
+        try {
+            const configPath = (0, path_1.resolve)(cliOptions.configFile);
+            const { existsSync, readFileSync } = await Promise.resolve().then(() => __importStar(require("fs")));
+            if (existsSync(configPath)) {
+                const configContent = readFileSync(configPath, "utf-8");
+                const fileOptions = JSON.parse(configContent);
+                // CLI options override file options
+                options = { ...fileOptions, ...cliOptions };
+                console.log(chalk_1.default.green(`✓ Loaded workflow config from ${configPath}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`⚠ Config file not found: ${configPath}`));
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`✗ Failed to load config file: ${error}`));
+        }
+    }
+    return options;
+}
+/**
+ * Helper to get pre-answered value or prompt user
+ */
+async function getOrPrompt(preAnswered, promptFn, skipCondition = false) {
+    if (skipCondition) {
+        throw new Error("Step skipped");
+    }
+    if (preAnswered !== undefined) {
+        return preAnswered;
+    }
+    return promptFn();
+}
 /**
  * Step 1: Initialize/Bootstrap
+ * Uses workflowService.initializeProject()
  */
-async function stepInitialize(state, aiOptions, streamingOptions) {
+async function stepInitialize(state, options, streamingOptions) {
     console.log(chalk_1.default.blue.bold("\n📦 Step 1: Project Initialization\n"));
-    // Check if already initialized in current directory
-    const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
-    const alreadyInitialized = (0, fs_1.existsSync)(taskOMaticDir);
-    if (alreadyInitialized) {
-        console.log(chalk_1.default.yellow("✓ Project already initialized"));
-        const useExisting = await (0, workflow_prompts_1.confirmPrompt)("Use existing configuration?", true);
-        if (useExisting) {
-            state.initialized = true;
-            state.currentStep = "define-prd";
-            return;
-        }
+    if (options.skipInit) {
+        console.log(chalk_1.default.yellow("⚠ Skipping initialization (--skip-init)"));
+        state.initialized = false;
+        state.currentStep = "define-prd";
+        return;
     }
-    const shouldInitialize = await (0, workflow_prompts_1.confirmPrompt)("Initialize a new task-o-matic project?", true);
+    const shouldInitialize = await getOrPrompt(options.skipInit === false ? true : undefined, () => (0, workflow_prompts_1.confirmPrompt)("Initialize a new task-o-matic project?", true));
     if (!shouldInitialize) {
         console.log(chalk_1.default.yellow("⚠ Skipping initialization"));
         state.initialized = false;
         state.currentStep = "define-prd";
         return;
     }
-    const projectName = await (0, workflow_prompts_1.textInputPrompt)("What is the name of your project?", "my-app");
-    // Choose initialization method
-    let initMethod = await (0, workflow_prompts_1.selectPrompt)("How would you like to configure your project?", [
+    const projectName = await getOrPrompt(options.projectName, () => (0, workflow_prompts_1.textInputPrompt)("What is the name of your project?", "my-app"));
+    // Determine initialization method
+    const initMethod = await getOrPrompt(options.initMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to configure your project stack?", [
         { name: "Quick start (recommended defaults)", value: "quick" },
         { name: "Custom configuration", value: "custom" },
         { name: "AI-assisted (describe your project)", value: "ai" },
-    ]);
-    let config;
+    ]));
+    let projectDescription;
     if (initMethod === "ai") {
-        console.log(chalk_1.default.cyan("\n🤖 AI-Assisted Configuration\n"));
-        const description = await (0, workflow_prompts_1.textInputPrompt)("Describe your project (e.g., 'A SaaS app for team collaboration with real-time features'):");
-        console.log(chalk_1.default.gray("\n  Analyzing your requirements...\n"));
-        config = await workflow_ai_assistant_1.workflowAIAssistant.assistInitConfig({
-            userDescription: description,
-            aiOptions,
-            streamingOptions,
-        });
-        // Override AI's project name with user's choice if they provided one (though we just asked for it, so we should use it)
-        config.projectName = projectName;
-        console.log(chalk_1.default.green("\n✓ AI Recommendations:"));
-        console.log(chalk_1.default.gray(`  Project: ${config.projectName}`));
-        console.log(chalk_1.default.gray(`  AI Provider: ${config.aiProvider}`));
-        console.log(chalk_1.default.gray(`  Frontend: ${config.frontend || "none"}`));
-        console.log(chalk_1.default.gray(`  Backend: ${config.backend || "none"}`));
-        console.log(chalk_1.default.gray(`  Database: ${config.database || "none"}`));
-        console.log(chalk_1.default.gray(`  Auth: ${config.auth ? "yes" : "no"}`));
-        if (config.reasoning) {
-            console.log(chalk_1.default.gray(`\n  ${config.reasoning}\n`));
-        }
-        const acceptRecommendation = await (0, workflow_prompts_1.confirmPrompt)("Accept these recommendations?", true);
-        if (!acceptRecommendation) {
-            console.log(chalk_1.default.yellow("⚠ Falling back to custom configuration"));
-            initMethod = "custom";
-        }
-    }
-    if (initMethod === "quick") {
-        config = {
-            projectName: projectName,
-            aiProvider: "openrouter",
-            aiModel: "anthropic/claude-3.5-sonnet",
-            frontend: "next",
-            backend: "hono",
-            database: "sqlite",
-            auth: true,
-            reasoning: "Modern, well-supported stack",
-        };
+        projectDescription = await getOrPrompt(options.projectDescription, () => (0, workflow_prompts_1.textInputPrompt)("Describe your project (e.g., 'A SaaS app for team collaboration with real-time features'):"));
     }
-    else if (initMethod === "custom") {
-        config = {
-            projectName: projectName,
-            aiProvider: await (0, workflow_prompts_1.selectPrompt)("AI Provider:", [
-                "openrouter",
-                "anthropic",
-                "openai",
-                "custom",
-            ]),
-            aiModel: await (0, workflow_prompts_1.textInputPrompt)("AI Model:", "anthropic/claude-3.5-sonnet"),
-        };
-        const shouldBootstrap = await (0, workflow_prompts_1.confirmPrompt)("Bootstrap with Better-T-Stack?", true);
+    // Collect stack config for custom mode
+    let stackConfig = {};
+    if (initMethod === "custom") {
+        const shouldBootstrap = await getOrPrompt(options.bootstrap, () => (0, workflow_prompts_1.confirmPrompt)("Bootstrap with Better-T-Stack?", true));
         if (shouldBootstrap) {
-            config.frontend = await (0, workflow_prompts_1.selectPrompt)("Frontend framework:", [
+            stackConfig.frontend = await getOrPrompt(options.frontend, () => (0, workflow_prompts_1.selectPrompt)("Frontend framework:", [
                 "next",
                 "tanstack-router",
                 "react-router",
                 "vite-react",
                 "remix",
-            ]);
-            config.backend = await (0, workflow_prompts_1.selectPrompt)("Backend framework:", [
+            ]));
+            stackConfig.backend = await getOrPrompt(options.backend, () => (0, workflow_prompts_1.selectPrompt)("Backend framework:", [
                 "hono",
                 "express",
                 "elysia",
                 "fastify",
-            ]);
-            config.database = await (0, workflow_prompts_1.selectPrompt)("Database:", [
+            ]));
+            stackConfig.database = await getOrPrompt(options.database, () => (0, workflow_prompts_1.selectPrompt)("Database:", [
                 "sqlite",
                 "postgres",
                 "mysql",
                 "mongodb",
                 "turso",
                 "neon",
-            ]);
-            config.auth = await (0, workflow_prompts_1.confirmPrompt)("Include authentication?", true);
+            ]));
+            stackConfig.auth = await getOrPrompt(options.auth, () => (0, workflow_prompts_1.confirmPrompt)("Include authentication?", true));
         }
     }
-    // Bootstrap Logic
-    let projectDir = process.cwd();
-    let didBootstrap = false;
-    if (config.frontend || config.backend) {
-        const shouldBootstrap = await (0, workflow_prompts_1.confirmPrompt)("Bootstrap project now?", true);
-        if (shouldBootstrap) {
-            console.log(chalk_1.default.cyan("\n  Bootstrapping with Better-T-Stack...\n"));
-            try {
-                const result = await (0, better_t_stack_cli_1.runBetterTStackCLI)({
-                    projectName: config.projectName,
-                    frontend: config.frontend || "next",
-                    backend: config.backend || "hono",
-                    database: config.database || "sqlite",
-                    noAuth: !config.auth,
-                    // Default values for required fields that might be missing from simple config
-                    orm: "drizzle",
-                    packageManager: "npm",
-                    runtime: "node",
-                    noInstall: false,
-                    noGit: false,
-                }, process.cwd());
-                if (result.success) {
-                    console.log(chalk_1.default.green(`\n✓ ${result.message}\n`));
-                    didBootstrap = true;
-                    // Update project directory if a new directory was created
-                    if (result.projectPath) {
-                        projectDir = (0, path_1.resolve)(process.cwd(), result.projectPath);
-                        console.log(chalk_1.default.cyan(`  📂 Switching to project directory: ${projectDir}\n`));
-                        process.chdir(projectDir);
-                        config_1.configManager.setWorkingDirectory(projectDir);
-                        state.projectDir = projectDir;
-                    }
-                }
-                else {
-                    console.log(chalk_1.default.red(`\n✗ Bootstrap failed: ${result.message}\n`));
-                    console.log(chalk_1.default.yellow("You can try running 'task-o-matic init bootstrap' manually later.\n"));
-                }
-            }
-            catch (error) {
-                console.log(chalk_1.default.red(`\n✗ Bootstrap failed: ${error}\n`));
-            }
-        }
-    }
-    // Initialize task-o-matic in the correct directory (projectDir)
-    console.log(chalk_1.default.cyan("\n  Initializing task-o-matic...\n"));
-    // Re-check task-o-matic dir in the new location
-    const newTaskOMaticDir = (0, path_1.join)(projectDir, ".task-o-matic");
-    if (!(0, fs_1.existsSync)(newTaskOMaticDir)) {
-        (0, fs_1.mkdirSync)(newTaskOMaticDir, { recursive: true });
-        ["tasks", "prd", "logs"].forEach((dir) => {
-            (0, fs_1.mkdirSync)((0, path_1.join)(newTaskOMaticDir, dir), { recursive: true });
-        });
-    }
-    // Handle .env configuration
-    const envPath = (0, path_1.join)(projectDir, ".env");
-    let envContent = "";
-    if ((0, fs_1.existsSync)(envPath)) {
-        envContent = (0, fs_1.readFileSync)(envPath, "utf-8");
-    }
-    // Check if we need to ask for API key
-    const providerKeyName = config.aiProvider === "openai"
-        ? "OPENAI_API_KEY"
-        : config.aiProvider === "anthropic"
-            ? "ANTHROPIC_API_KEY"
-            : config.aiProvider === "openrouter"
-                ? "OPENROUTER_API_KEY"
-                : "AI_API_KEY";
-    // Check if key exists in current env OR in the target .env file
-    const hasKeyInEnv = process.env[providerKeyName] || envContent.includes(providerKeyName);
-    if (!hasKeyInEnv) {
-        console.log(chalk_1.default.yellow(`\n⚠️  No API key found for ${config.aiProvider}`));
-        const apiKey = await (0, workflow_prompts_1.textInputPrompt)(`Enter your ${config.aiProvider} API Key:`);
-        // Prepare .env content
-        let newEnvContent = envContent;
-        if (newEnvContent && !newEnvContent.endsWith("\n")) {
-            newEnvContent += "\n";
-        }
-        if (!newEnvContent.includes("AI_PROVIDER=")) {
-            newEnvContent += `AI_PROVIDER=${config.aiProvider}\n`;
-        }
-        if (!newEnvContent.includes("AI_MODEL=")) {
-            newEnvContent += `AI_MODEL=${config.aiModel}\n`;
-        }
-        if (!newEnvContent.includes(`${providerKeyName}=`)) {
-            newEnvContent += `${providerKeyName}=${apiKey}\n`;
-        }
-        (0, fs_1.writeFileSync)(envPath, newEnvContent);
-        console.log(chalk_1.default.green(`✓ Saved configuration to ${envPath}`));
-        // Update process.env for immediate use in this session
-        process.env[providerKeyName] = apiKey;
-        process.env.AI_PROVIDER = config.aiProvider;
-        process.env.AI_MODEL = config.aiModel;
-    }
-    // Save configuration
-    config_1.configManager.setConfig({
-        ai: {
-            provider: config.aiProvider, // Cast to satisfy AIProvider type
-            model: config.aiModel,
-            maxTokens: 32768,
-            temperature: 0.5,
-            apiKey: process.env[providerKeyName], // Ensure key is in config if needed
+    // Determine if we should bootstrap
+    const bootstrap = initMethod === "quick" ||
+        (initMethod === "ai" && options.bootstrap !== false) ||
+        (initMethod === "custom" && Object.keys(stackConfig).length > 0);
+    // Call service
+    const result = await workflow_1.workflowService.initializeProject({
+        projectName,
+        initMethod: initMethod,
+        projectDescription,
+        aiOptions: options,
+        stackConfig,
+        bootstrap,
+        streamingOptions,
+        callbacks: {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
         },
     });
-    config_1.configManager.save();
     console.log(chalk_1.default.green("✓ Project initialized"));
     state.initialized = true;
-    state.projectName = config.projectName;
-    state.aiConfig = {
-        provider: config.aiProvider,
-        model: config.aiModel,
-    };
+    state.projectName = result.projectName;
+    state.projectDir = result.projectDir;
+    state.aiConfig = result.aiConfig;
     state.currentStep = "define-prd";
 }
 /**
  * Step 2: Define PRD
+ * Uses workflowService.definePRD()
  */
-async function stepDefinePRD(state, aiOptions, streamingOptions) {
+async function stepDefinePRD(state, options, streamingOptions) {
     console.log(chalk_1.default.blue.bold("\n📝 Step 2: Define PRD\n"));
-    const prdMethod = await (0, workflow_prompts_1.selectPrompt)("How would you like to define your PRD?", [
+    if (options.skipPrd) {
+        console.log(chalk_1.default.yellow("⚠ Skipping PRD definition (--skip-prd)"));
+        state.currentStep = "refine-prd";
+        return;
+    }
+    const prdMethod = await getOrPrompt(options.prdMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to define your PRD?", [
         { name: "Upload existing file", value: "upload" },
         { name: "Write manually (open editor)", value: "manual" },
         { name: "AI-assisted creation", value: "ai" },
         { name: "Skip (use existing PRD)", value: "skip" },
-    ]);
-    const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
-    const prdDir = (0, path_1.join)(taskOMaticDir, "prd");
+    ]));
     if (prdMethod === "skip") {
         console.log(chalk_1.default.yellow("⚠ Skipping PRD definition"));
         state.currentStep = "refine-prd";
         return;
     }
-    let prdContent = "";
-    let prdFilename = "prd.md";
+    let prdFile;
+    let prdDescription;
+    let prdContent;
     if (prdMethod === "upload") {
-        const filePath = await (0, workflow_prompts_1.textInputPrompt)("Path to PRD file:");
-        if (!(0, fs_1.existsSync)(filePath)) {
-            console.log(chalk_1.default.red(`✗ File not found: ${filePath}`));
-            return stepDefinePRD(state, aiOptions, streamingOptions);
-        }
-        prdContent = (0, fs_1.readFileSync)(filePath, "utf-8");
-        prdFilename = filePath.split("/").pop() || "prd.md";
+        prdFile = await getOrPrompt(options.prdFile, () => (0, workflow_prompts_1.textInputPrompt)("Path to PRD file:"));
     }
     else if (prdMethod === "manual") {
         console.log(chalk_1.default.gray("\n  Opening editor...\n"));
         prdContent = await (0, workflow_prompts_1.editorPrompt)("Write your PRD (save and close editor when done):", "# Product Requirements Document\n\n## Overview\n\n## Objectives\n\n## Features\n\n");
     }
     else if (prdMethod === "ai") {
-        console.log(chalk_1.default.cyan("\n🤖 AI-Assisted PRD Creation\n"));
-        const description = await (0, workflow_prompts_1.textInputPrompt)("Describe your product in detail:");
-        console.log(chalk_1.default.gray("\n  Generating PRD...\n"));
-        prdContent = await workflow_ai_assistant_1.workflowAIAssistant.assistPRDCreation({
-            userDescription: description,
-            aiOptions,
-            streamingOptions,
-        });
+        prdDescription = await getOrPrompt(options.prdDescription, () => (0, workflow_prompts_1.textInputPrompt)("Describe your product in detail:"));
+    }
+    // Call service
+    const result = await workflow_1.workflowService.definePRD({
+        method: prdMethod,
+        prdFile,
+        prdDescription,
+        prdContent,
+        projectDir: state.projectDir,
+        aiOptions: options,
+        streamingOptions,
+        callbacks: {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        },
+    });
+    if (prdMethod === "ai") {
         console.log(chalk_1.default.green("\n✓ PRD generated"));
-        console.log(chalk_1.default.gray("\n" + prdContent.substring(0, 500) + "...\n"));
-        const acceptPRD = await (0, workflow_prompts_1.confirmPrompt)("Accept this PRD?", true);
+        console.log(chalk_1.default.gray("\n" + result.prdContent.substring(0, 500) + "...\n"));
+        const acceptPRD = await getOrPrompt(options.autoAccept ? true : undefined, () => (0, workflow_prompts_1.confirmPrompt)("Accept this PRD?", true));
         if (!acceptPRD) {
             console.log(chalk_1.default.yellow("⚠ Regenerating..."));
-            return stepDefinePRD(state, aiOptions, streamingOptions);
+            return stepDefinePRD(state, options, streamingOptions);
         }
     }
-    // Save PRD
-    const prdPath = (0, path_1.join)(prdDir, prdFilename);
-    (0, fs_1.writeFileSync)(prdPath, prdContent);
-    console.log(chalk_1.default.green(`✓ PRD saved to ${prdPath}`));
-    state.prdFile = prdPath;
-    state.prdContent = prdContent;
+    state.prdFile = result.prdFile;
+    state.prdContent = result.prdContent;
+    state.currentStep = "question-refine-prd";
+}
+/**
+ * Step 2.5: PRD Question/Refine (NEW)
+ * Uses prdService.refinePRDWithQuestions()
+ */
+async function stepPRDQuestionRefine(state, options, streamingOptions) {
+    console.log(chalk_1.default.blue.bold("\n❓ Step 2.5: PRD Question & Refine\n"));
+    if (!state.prdFile) {
+        console.log(chalk_1.default.yellow("⚠ No PRD file found, skipping"));
+        state.currentStep = "refine-prd";
+        return;
+    }
+    if (options.skipPrdQuestionRefine || options.skipAll) {
+        console.log(chalk_1.default.gray("  Skipping question-based refinement"));
+        state.currentStep = "refine-prd";
+        return;
+    }
+    // Ask if user wants question-based refinement
+    const useQuestions = await getOrPrompt(options.prdQuestionRefine, () => (0, workflow_prompts_1.confirmPrompt)("Refine PRD with clarifying questions?", false));
+    if (!useQuestions) {
+        console.log(chalk_1.default.gray("  Skipping question-based refinement"));
+        state.currentStep = "refine-prd";
+        return;
+    }
+    // Ask who should answer: user or AI
+    const answerMode = await getOrPrompt(options.prdAnswerMode, () => (0, workflow_prompts_1.selectPrompt)("Who should answer the questions?", [
+        { name: "I will answer", value: "user" },
+        { name: "AI assistant (uses PRD + stack context)", value: "ai" },
+    ]));
+    let questionAIOptions = undefined;
+    if (answerMode === "ai") {
+        // Ask if they want to use a different AI model for answering
+        const useCustomAI = await getOrPrompt(options.prdAnswerAiProvider !== undefined, () => (0, workflow_prompts_1.confirmPrompt)("Use a different AI model for answering? (e.g., a smarter model)", false));
+        if (useCustomAI) {
+            const provider = await getOrPrompt(options.prdAnswerAiProvider, () => (0, workflow_prompts_1.selectPrompt)("AI Provider for answering:", [
+                { name: "OpenRouter", value: "openrouter" },
+                { name: "Anthropic", value: "anthropic" },
+                { name: "OpenAI", value: "openai" },
+            ]));
+            const model = await getOrPrompt(options.prdAnswerAiModel, () => (0, workflow_prompts_1.textInputPrompt)("AI Model for answering:", provider === "openrouter" ? "anthropic/claude-3.5-sonnet" : ""));
+            questionAIOptions = {
+                aiProvider: provider,
+                aiModel: model,
+            };
+        }
+        // Check if reasoning should be enabled
+        if (options.prdAnswerAiReasoning) {
+            if (!questionAIOptions) {
+                // No custom AI specified, use main AI with reasoning
+                questionAIOptions = {
+                    aiProvider: options.aiProvider,
+                    aiModel: options.aiModel,
+                    aiReasoning: "enabled",
+                };
+            }
+            else {
+                // Custom AI specified, add reasoning to it
+                questionAIOptions.aiReasoning = "enabled";
+            }
+        }
+    }
+    // For user mode, we need to collect answers interactively
+    let answers;
+    if (answerMode === "user") {
+        // First, generate questions
+        console.log(chalk_1.default.cyan("\n  Generating questions...\n"));
+        const questions = await prd_1.prdService.generateQuestions({
+            file: state.prdFile,
+            workingDirectory: state.projectDir,
+            aiOptions: options,
+            streamingOptions,
+            callbacks: {
+                onProgress: progress_1.displayProgress,
+                onError: progress_1.displayError,
+            },
+        });
+        if (questions.length === 0) {
+            console.log(chalk_1.default.yellow("No questions generated - PRD appears complete"));
+            state.currentStep = "refine-prd";
+            return;
+        }
+        console.log(chalk_1.default.blue(`\nPlease answer the following ${questions.length} questions to refine the PRD:\n`));
+        answers = {};
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: "input",
+                    name: "response",
+                    message: `${i + 1}/${questions.length}: ${q}`,
+                    validate: (input) => input.trim().length > 0 || "Please provide an answer",
+                },
+            ]);
+            answers[q] = answer.response;
+        }
+    }
+    // Call service - it will automatically refine after answering
+    console.log(chalk_1.default.cyan("\n  Generating questions and refining PRD...\n"));
+    const result = await prd_1.prdService.refinePRDWithQuestions({
+        file: state.prdFile,
+        questionMode: answerMode,
+        answers, // Only provided for user mode
+        questionAIOptions,
+        workingDirectory: state.projectDir,
+        aiOptions: options,
+        streamingOptions,
+        callbacks: {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        },
+    });
+    console.log(chalk_1.default.green(`\n✓ PRD refined with ${result.questions.length} questions answered`));
+    console.log(chalk_1.default.gray("\n  Questions & Answers:"));
+    result.questions.forEach((q, i) => {
+        console.log(chalk_1.default.cyan(`  Q${i + 1}: ${q}`));
+        console.log(chalk_1.default.gray(`  A${i + 1}: ${result.answers[q]?.substring(0, 100)}...\n`));
+    });
+    // Update state with refined PRD
+    state.prdFile = result.refinedPRDPath;
+    state.prdContent = (0, fs_1.readFileSync)(result.refinedPRDPath, "utf-8");
     state.currentStep = "refine-prd";
 }
 /**
  * Step 3: Refine PRD
+ * Uses workflowService.refinePRD()
  */
-async function stepRefinePRD(state, aiOptions, streamingOptions) {
+async function stepRefinePRD(state, options, streamingOptions) {
     console.log(chalk_1.default.blue.bold("\n✨ Step 3: Refine PRD\n"));
     if (!state.prdFile) {
         console.log(chalk_1.default.yellow("⚠ No PRD file found, skipping refinement"));
         state.currentStep = "generate-tasks";
         return;
     }
-    const shouldRefine = await (0, workflow_prompts_1.confirmPrompt)("Refine your PRD?", false);
+    if (options.skipRefine || options.skipAll) {
+        console.log(chalk_1.default.gray("  Skipping refinement"));
+        state.currentStep = "generate-tasks";
+        return;
+    }
+    const shouldRefine = await getOrPrompt(options.skipRefine === false ? true : undefined, () => (0, workflow_prompts_1.confirmPrompt)("Refine your PRD further?", false));
     if (!shouldRefine) {
         console.log(chalk_1.default.gray("  Skipping refinement"));
         state.currentStep = "generate-tasks";
         return;
     }
-    const refineMethod = await (0, workflow_prompts_1.selectPrompt)("How would you like to refine?", [
+    const refineMethod = await getOrPrompt(options.refineMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to refine?", [
         { name: "Manual editing (open editor)", value: "manual" },
         { name: "AI-assisted refinement", value: "ai" },
         { name: "Skip", value: "skip" },
-    ]);
+    ]));
     if (refineMethod === "skip") {
         state.currentStep = "generate-tasks";
         return;
     }
     let refinedContent = state.prdContent || (0, fs_1.readFileSync)(state.prdFile, "utf-8");
+    let feedback;
     if (refineMethod === "manual") {
         console.log(chalk_1.default.gray("\n  Opening editor...\n"));
         refinedContent = await (0, workflow_prompts_1.editorPrompt)("Edit your PRD (save and close when done):", refinedContent);
     }
     else if (refineMethod === "ai") {
-        console.log(chalk_1.default.cyan("\n🤖 AI-Assisted Refinement\n"));
-        const feedback = await (0, workflow_prompts_1.textInputPrompt)("What would you like to improve? (e.g., 'Add more technical details', 'Focus on MVP features'):");
-        console.log(chalk_1.default.gray("\n  Refining PRD...\n"));
-        refinedContent = await workflow_ai_assistant_1.workflowAIAssistant.assistPRDRefinement({
-            currentPRD: refinedContent,
-            userFeedback: feedback,
-            aiOptions,
-            streamingOptions,
-        });
+        feedback = await getOrPrompt(options.refineFeedback, () => (0, workflow_prompts_1.textInputPrompt)("What would you like to improve? (e.g., 'Add more technical details', 'Focus on MVP features'):"));
+    }
+    // Call service
+    const result = await workflow_1.workflowService.refinePRD({
+        method: refineMethod,
+        prdFile: state.prdFile,
+        prdContent: refineMethod === "manual" ? refinedContent : undefined,
+        feedback,
+        projectDir: state.projectDir,
+        aiOptions: options,
+        streamingOptions,
+        callbacks: {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        },
+    });
+    if (refineMethod === "ai") {
         console.log(chalk_1.default.green("\n✓ PRD refined"));
-        console.log(chalk_1.default.gray("\n" + refinedContent.substring(0, 500) + "...\n"));
-        const acceptRefinement = await (0, workflow_prompts_1.confirmPrompt)("Accept refinements?", true);
+        console.log(chalk_1.default.gray("\n" + result.prdContent.substring(0, 500) + "...\n"));
+        const acceptRefinement = await getOrPrompt(options.autoAccept ? true : undefined, () => (0, workflow_prompts_1.confirmPrompt)("Accept refinements?", true));
         if (!acceptRefinement) {
             console.log(chalk_1.default.yellow("⚠ Keeping original PRD"));
             state.currentStep = "generate-tasks";
             return;
         }
     }
-    // Save refined PRD
-    (0, fs_1.writeFileSync)(state.prdFile, refinedContent);
-    state.prdContent = refinedContent;
+    state.prdContent = result.prdContent;
     console.log(chalk_1.default.green(`✓ PRD updated`));
     state.currentStep = "generate-tasks";
 }
 /**
  * Step 4: Generate Tasks
+ * Uses workflowService.generateTasks()
  */
-async function stepGenerateTasks(state, aiOptions, streamingOptions) {
+async function stepGenerateTasks(state, options, streamingOptions) {
     console.log(chalk_1.default.blue.bold("\n🎯 Step 4: Generate Tasks\n"));
     if (!state.prdFile) {
         console.log(chalk_1.default.yellow("⚠ No PRD file found, skipping task generation"));
         state.currentStep = "split-tasks";
         return;
     }
-    const shouldGenerate = await (0, workflow_prompts_1.confirmPrompt)("Generate tasks from PRD?", true);
+    if (options.skipGenerate || options.skipAll) {
+        console.log(chalk_1.default.gray("  Skipping task generation"));
+        state.currentStep = "split-tasks";
+        return;
+    }
+    const shouldGenerate = await getOrPrompt(options.skipGenerate === false ? true : undefined, () => (0, workflow_prompts_1.confirmPrompt)("Generate tasks from PRD?", true));
     if (!shouldGenerate) {
         console.log(chalk_1.default.gray("  Skipping task generation"));
         state.currentStep = "split-tasks";
         return;
     }
-    const generationMethod = await (0, workflow_prompts_1.selectPrompt)("Choose generation method:", [
+    const generationMethod = await getOrPrompt(options.generateMethod, () => (0, workflow_prompts_1.selectPrompt)("Choose generation method:", [
         { name: "Standard parsing", value: "standard" },
         { name: "AI-assisted with custom instructions", value: "ai" },
-    ]);
+    ]));
     let customInstructions;
     if (generationMethod === "ai") {
-        customInstructions = await (0, workflow_prompts_1.textInputPrompt)("Custom instructions (e.g., 'Focus on MVP features', 'Break into small tasks'):", "");
+        customInstructions = await getOrPrompt(options.generateInstructions, () => (0, workflow_prompts_1.textInputPrompt)("Custom instructions (e.g., 'Focus on MVP features', 'Break into small tasks'):", ""));
     }
     console.log(chalk_1.default.cyan("\n  Parsing PRD and generating tasks...\n"));
-    const result = await prd_1.prdService.parsePRD({
-        file: state.prdFile,
-        workingDirectory: state.projectDir,
-        aiOptions,
-        messageOverride: customInstructions,
+    // Call service
+    const result = await workflow_1.workflowService.generateTasks({
+        prdFile: state.prdFile,
+        method: generationMethod,
+        customInstructions,
+        projectDir: state.projectDir,
+        aiOptions: options,
         streamingOptions,
         callbacks: {
             onProgress: progress_1.displayProgress,
@@ -453,51 +586,96 @@ async function stepGenerateTasks(state, aiOptions, streamingOptions) {
 }
 /**
  * Step 5: Split Complex Tasks
+ * Uses workflowService.splitTasks()
  */
-async function stepSplitTasks(state, aiOptions, streamingOptions) {
+async function stepSplitTasks(state, options, streamingOptions) {
     console.log(chalk_1.default.blue.bold("\n🔀 Step 5: Split Complex Tasks\n"));
     if (!state.tasks || state.tasks.length === 0) {
         console.log(chalk_1.default.yellow("⚠ No tasks found, skipping splitting"));
         return;
     }
-    const shouldSplit = await (0, workflow_prompts_1.confirmPrompt)("Split any complex tasks into subtasks?", false);
-    if (!shouldSplit) {
+    if (options.skipSplit || options.skipAll) {
         console.log(chalk_1.default.gray("  Skipping task splitting"));
         return;
     }
-    // Show tasks with effort estimates
-    const tasksToSplit = await (0, workflow_prompts_1.multiSelectPrompt)("Select tasks to split:", state.tasks.map((t) => ({
-        name: `${t.title}${t.description ? ` - ${t.description.substring(0, 50)}...` : ""}`,
-        value: t.id,
-    })));
+    // Handle --split-tasks and --split-all options
+    let tasksToSplit;
+    if (options.splitAll) {
+        tasksToSplit = state.tasks?.map((t) => t.id) || [];
+        console.log(chalk_1.default.cyan(`  Splitting all ${tasksToSplit.length} tasks`));
+    }
+    else if (options.splitTasks) {
+        tasksToSplit = options.splitTasks.split(",").map((id) => id.trim());
+        console.log(chalk_1.default.cyan(`  Splitting ${tasksToSplit.length} specified tasks`));
+    }
+    else {
+        const shouldSplit = await (0, workflow_prompts_1.confirmPrompt)("Split any complex tasks into subtasks?", false);
+        if (!shouldSplit) {
+            console.log(chalk_1.default.gray("  Skipping task splitting"));
+            return;
+        }
+        tasksToSplit = await (0, workflow_prompts_1.multiSelectPrompt)("Select tasks to split:", state.tasks.map((t) => ({
+            name: `${t.title}${t.description ? ` - ${t.description.substring(0, 50)}...` : ""}`,
+            value: t.id,
+        })));
+    }
     if (tasksToSplit.length === 0) {
         console.log(chalk_1.default.gray("  No tasks selected"));
         return;
     }
-    for (const taskId of tasksToSplit) {
-        const task = state.tasks.find((t) => t.id === taskId);
-        if (!task)
-            continue;
-        console.log(chalk_1.default.cyan(`\n  Splitting: ${task.title}\n`));
-        const splitMethod = await (0, workflow_prompts_1.selectPrompt)("Split method:", [
-            { name: "Standard AI split", value: "standard" },
-            { name: "Custom instructions", value: "custom" },
-        ]);
-        let customInstructions;
-        if (splitMethod === "custom") {
-            customInstructions = await (0, workflow_prompts_1.textInputPrompt)("Custom instructions (e.g., 'Break into 2-4 hour chunks'):", "");
+    let globalSplitMethod = "interactive";
+    let globalCustomInstructions;
+    if (tasksToSplit.length > 1) {
+        globalSplitMethod = await getOrPrompt(options.splitMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to split these tasks?", [
+            { name: "Interactive (ask for each task)", value: "interactive" },
+            { name: "Standard AI split for ALL", value: "standard" },
+            { name: "Same custom instructions for ALL", value: "custom" },
+        ]));
+        if (globalSplitMethod === "custom") {
+            globalCustomInstructions = await getOrPrompt(options.splitInstructions, () => (0, workflow_prompts_1.textInputPrompt)("Custom instructions for ALL tasks (e.g., 'Break into 2-4 hour chunks'):", ""));
         }
-        try {
-            const result = await tasks_1.taskService.splitTask(taskId, aiOptions, undefined, // promptOverride
-            customInstructions, streamingOptions);
-            console.log(chalk_1.default.green(`  ✓ Created ${result.subtasks.length} subtasks`));
-            result.subtasks.forEach((subtask, index) => {
+    }
+    // Collect per-task instructions for interactive mode
+    const taskInstructions = {};
+    if (globalSplitMethod === "interactive") {
+        for (const taskId of tasksToSplit) {
+            const task = state.tasks.find((t) => t.id === taskId);
+            if (!task)
+                continue;
+            console.log(chalk_1.default.cyan(`\n  Task: ${task.title}\n`));
+            const splitMethod = await (0, workflow_prompts_1.selectPrompt)("Split method:", [
+                { name: "Standard AI split", value: "standard" },
+                { name: "Custom instructions", value: "custom" },
+            ]);
+            if (splitMethod === "custom") {
+                taskInstructions[taskId] = await (0, workflow_prompts_1.textInputPrompt)("Custom instructions (e.g., 'Break into 2-4 hour chunks'):", "");
+            }
+        }
+    }
+    // Call service
+    const result = await workflow_1.workflowService.splitTasks({
+        taskIds: tasksToSplit,
+        splitMethod: globalSplitMethod,
+        customInstructions: globalCustomInstructions,
+        aiOptions: options,
+        streamingOptions,
+        callbacks: {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        },
+    });
+    // Display results
+    result.results.forEach((taskResult) => {
+        const task = state.tasks?.find((t) => t.id === taskResult.taskId);
+        if (taskResult.error) {
+            console.log(chalk_1.default.red(`  ✗ Failed to split ${task?.title}: ${taskResult.error}`));
+        }
+        else {
+            console.log(chalk_1.default.green(`  ✓ Split ${task?.title} into ${taskResult.subtasks.length} subtasks`));
+            taskResult.subtasks.forEach((subtask, index) => {
                 console.log(chalk_1.default.gray(`    ${index + 1}. ${subtask.title}`));
             });
         }
-        catch (error) {
-            console.log(chalk_1.default.red(`  ✗ Failed to split task: ${error}`));
-        }
-    }
+    });
     console.log(chalk_1.default.green("\n✓ Task splitting complete"));
 }