task-o-matic-core 0.1.0

package/dist/services/workflow.d.ts

@@ -0,0 +1,107 @@
+import { AIOptions } from "../utils/ai-config-builder";
+import { StreamingOptions } from "../types";
+import { ProgressCallback } from "../types/callbacks";
+import { InitializeResult, DefinePRDResult, RefinePRDResult, GenerateTasksResult, SplitTasksResult } from "../types/workflow-results";
+import { ExecuteLoopOptions, ExecuteLoopResult } from "../types";
+/**
+ * WorkflowService - Business logic for workflow operations
+ * Extracts all workflow logic from the command layer for reusability
+ */
+export declare class WorkflowService {
+    /**
+     * Step 1: Initialize Project
+     * Handles project initialization, AI configuration, and optional bootstrapping
+     */
+    initializeProject(input: {
+        projectName: string;
+        projectDir?: string;
+        initMethod?: "quick" | "custom" | "ai";
+        projectDescription?: string;
+        aiOptions?: AIOptions;
+        stackConfig?: {
+            frontend?: string;
+            backend?: string;
+            database?: string;
+            auth?: boolean;
+        };
+        bootstrap?: boolean;
+        includeDocs?: boolean;
+        streamingOptions?: StreamingOptions;
+        callbacks?: ProgressCallback;
+    }): Promise<InitializeResult>;
+    /**
+     * Step 2: Define PRD
+     * Handles PRD creation through various methods
+     */
+    definePRD(input: {
+        method: "upload" | "manual" | "ai" | "skip";
+        prdFile?: string;
+        prdDescription?: string;
+        prdContent?: string;
+        projectDir: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+        callbacks?: ProgressCallback;
+        multiGeneration?: boolean;
+        multiGenerationModels?: Array<{
+            provider: string;
+            model: string;
+        }>;
+        combineAI?: {
+            provider: string;
+            model: string;
+        };
+    }): Promise<DefinePRDResult>;
+    /**
+     * Step 3: Refine PRD
+     * Handles PRD refinement through manual or AI methods
+     */
+    refinePRD(input: {
+        method: "manual" | "ai" | "skip";
+        prdFile: string;
+        prdContent?: string;
+        feedback?: string;
+        projectDir: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+        callbacks?: ProgressCallback;
+    }): Promise<RefinePRDResult>;
+    /**
+     * Step 4: Generate Tasks
+     * Generates tasks from PRD using the prdService
+     */
+    generateTasks(input: {
+        prdFile: string;
+        method: "standard" | "ai";
+        customInstructions?: string;
+        projectDir: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+        callbacks?: ProgressCallback;
+    }): Promise<GenerateTasksResult>;
+    /**
+     * Step 5: Split Tasks
+     * Splits complex tasks into subtasks
+     */
+    splitTasks(input: {
+        taskIds: string[];
+        splitMethod: "interactive" | "standard" | "custom";
+        customInstructions?: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+        callbacks?: ProgressCallback;
+    }): Promise<SplitTasksResult>;
+    /**
+     * Step 6: Execute Tasks
+     * Executes the generated tasks using the task loop executor
+     */
+    executeTasks(input: {
+        options: ExecuteLoopOptions;
+        callbacks?: ProgressCallback;
+    }): Promise<{
+        success: boolean;
+        result: ExecuteLoopResult;
+    }>;
+}
+export declare const workflowService: WorkflowService;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/services/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/services/workflow.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAQ,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAEjE;;;GAGG;AACH,qBAAa,eAAe;IAC1B;;;OAGG;IACG,iBAAiB,CAAC,KAAK,EAAE;QAC7B,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC;QACvC,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,WAAW,CAAC,EAAE;YACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,IAAI,CAAC,EAAE,OAAO,CAAC;SAChB,CAAC;QACF,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;QACpC,SAAS,CAAC,EAAE,gBAAgB,CAAC;KAC9B,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoN7B;;;OAGG;IACG,SAAS,CAAC,KAAK,EAAE;QACrB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,GAAG,MAAM,CAAC;QAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;QACpC,SAAS,CAAC,EAAE,gBAAgB,CAAC;QAE7B,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,qBAAqB,CAAC,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACnE,SAAS,CAAC,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;KACjD,GAAG,OAAO,CAAC,eAAe,CAAC;IA+N5B;;;OAGG;IACG,SAAS,CAAC,KAAK,EAAE;QACrB,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAAC;QACjC,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;QACpC,SAAS,CAAC,EAAE,gBAAgB,CAAC;KAC9B,GAAG,OAAO,CAAC,eAAe,CAAC;IAgG5B;;;OAGG;IACG,aAAa,CAAC,KAAK,EAAE;QACzB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;QAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;QACpC,SAAS,CAAC,EAAE,gBAAgB,CAAC;KAC9B,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkEhC;;;OAGG;IACG,UAAU,CAAC,KAAK,EAAE;QACtB,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,WAAW,EAAE,aAAa,GAAG,UAAU,GAAG,QAAQ,CAAC;QACnD,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;QACpC,SAAS,CAAC,EAAE,gBAAgB,CAAC;KAC9B,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmD7B;;;OAGG;IACG,YAAY,CAAC,KAAK,EAAE;QACxB,OAAO,EAAE,kBAAkB,CAAC;QAC5B,SAAS,CAAC,EAAE,gBAAgB,CAAC;KAC9B,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,iBAAiB,CAAA;KAAE,CAAC;CAkB7D;AAGD,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/dist/services/workflow.js

@@ -0,0 +1,580 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowService = exports.WorkflowService = void 0;
+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 prd_1 = require("./prd");
+const tasks_1 = require("./tasks");
+const workflow_ai_assistant_1 = require("./workflow-ai-assistant");
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+const task_loop_execution_1 = require("../lib/task-loop-execution");
+/**
+ * WorkflowService - Business logic for workflow operations
+ * Extracts all workflow logic from the command layer for reusability
+ */
+class WorkflowService {
+    /**
+     * Step 1: Initialize Project
+     * Handles project initialization, AI configuration, and optional bootstrapping
+     */
+    async initializeProject(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Initializing project...",
+        });
+        // Determine project directory
+        const projectDir = input.projectDir || (0, path_1.resolve)(process.cwd(), input.projectName);
+        // Create project directory
+        if (!(0, fs_1.existsSync)(projectDir)) {
+            (0, fs_1.mkdirSync)(projectDir, { recursive: true });
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: `Created directory: ${input.projectName}`,
+            });
+        }
+        // Switch to project directory
+        process.chdir(projectDir);
+        config_1.configManager.setWorkingDirectory(projectDir);
+        await config_1.configManager.load();
+        // Initialize task-o-matic directory structure
+        const taskOMaticDir = (0, path_1.join)(projectDir, ".task-o-matic");
+        if (!(0, fs_1.existsSync)(taskOMaticDir)) {
+            (0, fs_1.mkdirSync)(taskOMaticDir, { recursive: true });
+            ["tasks", "prd", "logs"].forEach((dir) => {
+                (0, fs_1.mkdirSync)((0, path_1.join)(taskOMaticDir, dir), { recursive: true });
+            });
+        }
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Configuring AI settings...",
+        });
+        // Get AI configuration
+        const aiProvider = input.aiOptions?.aiProvider || "openrouter";
+        const aiModel = input.aiOptions?.aiModel ||
+            (aiProvider === "openrouter"
+                ? "anthropic/claude-3.5-sonnet"
+                : aiProvider === "anthropic"
+                    ? "claude-sonnet-4.5"
+                    : "gpt-4o");
+        const apiKey = input.aiOptions?.aiKey || process.env.AI_API_KEY || "";
+        // Save AI config to .env
+        const envPath = (0, path_1.join)(projectDir, ".env");
+        let envContent = (0, fs_1.existsSync)(envPath) ? (0, fs_1.readFileSync)(envPath, "utf-8") : "";
+        if (!envContent.includes("AI_PROVIDER=")) {
+            envContent += `AI_PROVIDER=${aiProvider}\n`;
+        }
+        if (!envContent.includes("AI_MODEL=")) {
+            envContent += `AI_MODEL=${aiModel}\n`;
+        }
+        if (input.aiOptions?.aiProviderUrl &&
+            !envContent.includes("AI_PROVIDER_URL=")) {
+            envContent += `AI_PROVIDER_URL=${input.aiOptions.aiProviderUrl}\n`;
+        }
+        const providerKeyName = aiProvider === "openai"
+            ? "OPENAI_API_KEY"
+            : aiProvider === "anthropic"
+                ? "ANTHROPIC_API_KEY"
+                : aiProvider === "openrouter"
+                    ? "OPENROUTER_API_KEY"
+                    : "AI_API_KEY";
+        if (!envContent.includes(`${providerKeyName}=`)) {
+            envContent += `${providerKeyName}=${apiKey}\n`;
+        }
+        (0, fs_1.writeFileSync)(envPath, envContent);
+        // Update process.env and ConfigManager
+        process.env.AI_PROVIDER = aiProvider;
+        process.env.AI_MODEL = aiModel;
+        process.env[providerKeyName] = apiKey;
+        if (input.aiOptions?.aiProviderUrl) {
+            process.env.AI_PROVIDER_URL = input.aiOptions.aiProviderUrl;
+        }
+        config_1.configManager.setAIConfig({
+            provider: aiProvider,
+            model: aiModel,
+            apiKey: apiKey,
+            baseURL: input.aiOptions?.aiProviderUrl,
+        });
+        // Determine stack configuration
+        let stackConfig = {
+            projectName: input.projectName,
+            aiProvider,
+            aiModel,
+        };
+        if (input.initMethod === "ai" && input.projectDescription) {
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: "Getting AI recommendations for stack...",
+            });
+            stackConfig = await workflow_ai_assistant_1.workflowAIAssistant.assistInitConfig({
+                userDescription: input.projectDescription,
+                aiOptions: input.aiOptions,
+                streamingOptions: input.streamingOptions,
+            });
+            // Override with user's choices
+            stackConfig.projectName = input.projectName;
+            stackConfig.aiProvider = aiProvider;
+            stackConfig.aiModel = aiModel;
+        }
+        else if (input.initMethod === "quick") {
+            stackConfig = {
+                ...stackConfig,
+                frontend: "next",
+                backend: "hono",
+                database: "sqlite",
+                auth: true,
+                reasoning: "Modern, well-supported stack",
+            };
+        }
+        else if (input.stackConfig) {
+            stackConfig = { ...stackConfig, ...input.stackConfig };
+        }
+        // Bootstrap if requested
+        let bootstrapped = false;
+        if (input.bootstrap && (stackConfig.frontend || stackConfig.backend)) {
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: "Bootstrapping with Better-T-Stack...",
+            });
+            try {
+                const result = await (0, better_t_stack_cli_1.runBetterTStackCLI)({
+                    projectName: ".",
+                    frontend: stackConfig.frontend || "next",
+                    backend: stackConfig.backend || "hono",
+                    database: stackConfig.database || "sqlite",
+                    noAuth: !stackConfig.auth,
+                    orm: "drizzle",
+                    packageManager: "npm",
+                    runtime: "node",
+                    noInstall: false,
+                    noGit: false,
+                    includeDocs: input.includeDocs,
+                }, projectDir);
+                if (result.success) {
+                    bootstrapped = true;
+                    // Fix config file naming
+                    const dotConfigPath = (0, path_1.join)(taskOMaticDir, ".-bts-config.json");
+                    const realConfigPath = (0, path_1.join)(taskOMaticDir, `${input.projectName}-bts-config.json`);
+                    const stackConfigPath = (0, path_1.join)(taskOMaticDir, "stack.json");
+                    if ((0, fs_1.existsSync)(dotConfigPath)) {
+                        const configContent = JSON.parse((0, fs_1.readFileSync)(dotConfigPath, "utf-8"));
+                        configContent.projectName = input.projectName;
+                        const newContent = JSON.stringify(configContent, null, 2);
+                        (0, fs_1.writeFileSync)(realConfigPath, newContent);
+                        (0, fs_1.writeFileSync)(stackConfigPath, newContent);
+                        const { unlinkSync } = require("fs");
+                        unlinkSync(dotConfigPath);
+                    }
+                }
+            }
+            catch (error) {
+                input.callbacks?.onError?.(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        // Save configuration
+        config_1.configManager.save();
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: "Project initialized successfully",
+        });
+        return {
+            success: true,
+            projectDir,
+            projectName: input.projectName,
+            aiConfig: {
+                provider: aiProvider,
+                model: aiModel,
+                key: apiKey,
+            },
+            stackConfig,
+            bootstrapped,
+        };
+    }
+    /**
+     * Step 2: Define PRD
+     * Handles PRD creation through various methods
+     */
+    async definePRD(input) {
+        const startTime = Date.now();
+        let tokenUsage;
+        let timeToFirstToken;
+        let cost;
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Defining PRD...",
+        });
+        const taskOMaticDir = (0, path_1.join)(input.projectDir, ".task-o-matic");
+        const prdDir = (0, path_1.join)(taskOMaticDir, "prd");
+        if (!(0, fs_1.existsSync)(prdDir)) {
+            (0, fs_1.mkdirSync)(prdDir, { recursive: true });
+        }
+        if (input.method === "skip") {
+            return {
+                success: true,
+                prdFile: "",
+                prdContent: "",
+                method: "skip",
+                stats: {
+                    duration: Date.now() - startTime,
+                },
+            };
+        }
+        let prdContent = "";
+        let prdFilename = "prd.md";
+        if (input.method === "upload" && input.prdFile) {
+            if (!(0, fs_1.existsSync)(input.prdFile)) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, `PRD file not found: ${input.prdFile}`, {
+                    suggestions: [
+                        "Verify the file path is correct",
+                        "Check if file was moved or deleted",
+                    ],
+                });
+            }
+            prdContent = (0, fs_1.readFileSync)(input.prdFile, "utf-8");
+            prdFilename = input.prdFile.split("/").pop() || "prd.md";
+        }
+        else if (input.method === "manual" && input.prdContent) {
+            prdContent = input.prdContent;
+        }
+        else if (input.method === "ai" && input.prdDescription) {
+            // Check if multi-generation is requested
+            if (input.multiGeneration &&
+                input.multiGenerationModels &&
+                input.multiGenerationModels.length > 1) {
+                // Multi-generation mode
+                const results = [];
+                input.callbacks?.onProgress?.({
+                    type: "progress",
+                    message: `Generating ${input.multiGenerationModels.length} PRDs concurrently...`,
+                });
+                // Generate PRDs concurrently
+                const promises = input.multiGenerationModels.map(async (modelConfig, index) => {
+                    const modelId = `${modelConfig.provider}:${modelConfig.model}`;
+                    const result = await prd_1.prdService.generatePRD({
+                        description: input.prdDescription,
+                        outputDir: prdDir,
+                        filename: `prd-${modelConfig.provider}-${modelConfig.model.replace(/\//g, "-")}.md`,
+                        aiOptions: {
+                            aiProvider: modelConfig.provider,
+                            aiModel: modelConfig.model,
+                        },
+                        callbacks: {
+                            onProgress: (event) => {
+                                // Only modify events that have a message property
+                                if (event.type !== "stream-chunk" &&
+                                    event.type !== "reasoning-chunk") {
+                                    input.callbacks?.onProgress?.({
+                                        ...event,
+                                        message: `[${modelId}] ${event.message}`,
+                                    });
+                                }
+                                else {
+                                    input.callbacks?.onProgress?.(event);
+                                }
+                            },
+                        },
+                    });
+                    results.push({
+                        path: result.path,
+                        content: result.content,
+                        stats: result.stats,
+                        modelId,
+                    });
+                    return result;
+                });
+                await Promise.all(promises);
+                // Aggregate metrics
+                tokenUsage = {
+                    prompt: results.reduce((sum, r) => sum + (r.stats.tokenUsage?.prompt || 0), 0),
+                    completion: results.reduce((sum, r) => sum + (r.stats.tokenUsage?.completion || 0), 0),
+                    total: results.reduce((sum, r) => sum + (r.stats.tokenUsage?.total || 0), 0),
+                };
+                timeToFirstToken = Math.min(...results
+                    .map((r) => r.stats.timeToFirstToken || Infinity)
+                    .filter((t) => t !== Infinity));
+                cost = results.reduce((sum, r) => sum + (r.stats.cost || 0), 0);
+                // Combine if requested
+                if (input.combineAI) {
+                    input.callbacks?.onProgress?.({
+                        type: "progress",
+                        message: "Combining PRDs into master PRD...",
+                    });
+                    const prdContents = results.map((r) => r.content);
+                    const masterResult = await prd_1.prdService.combinePRDs({
+                        prds: prdContents,
+                        originalDescription: input.prdDescription,
+                        outputDir: prdDir,
+                        filename: "prd-master.md",
+                        aiOptions: {
+                            aiProvider: input.combineAI.provider,
+                            aiModel: input.combineAI.model,
+                        },
+                        callbacks: input.callbacks,
+                    });
+                    prdContent = masterResult.content;
+                    prdFilename = "prd-master.md";
+                    // Add combination metrics
+                    if (masterResult.stats.tokenUsage) {
+                        tokenUsage.prompt += masterResult.stats.tokenUsage.prompt;
+                        tokenUsage.completion += masterResult.stats.tokenUsage.completion;
+                        tokenUsage.total += masterResult.stats.tokenUsage.total;
+                    }
+                    if (masterResult.stats.cost) {
+                        cost = (cost || 0) + masterResult.stats.cost;
+                    }
+                }
+                else {
+                    // Use the first generated PRD as the main one
+                    prdContent = results[0].content;
+                    prdFilename = `prd-${results[0].modelId
+                        .replace(/:/g, "-")
+                        .replace(/\//g, "-")}.md`;
+                }
+            }
+            else {
+                // Single generation mode
+                const result = await prd_1.prdService.generatePRD({
+                    description: input.prdDescription,
+                    outputDir: prdDir,
+                    filename: prdFilename,
+                    aiOptions: input.aiOptions,
+                    streamingOptions: input.streamingOptions,
+                    callbacks: input.callbacks,
+                });
+                prdContent = result.content;
+                tokenUsage = result.stats.tokenUsage;
+                timeToFirstToken = result.stats.timeToFirstToken;
+                cost = result.stats.cost;
+            }
+        }
+        // Save PRD if not already saved by AI service
+        const prdPath = (0, path_1.join)(prdDir, prdFilename);
+        if (input.method !== "ai") {
+            (0, fs_1.writeFileSync)(prdPath, prdContent);
+            input.callbacks?.onProgress?.({
+                type: "completed",
+                message: `PRD saved to ${prdPath}`,
+            });
+        }
+        const stats = {
+            duration: Date.now() - startTime,
+            ...(tokenUsage && { tokenUsage }),
+            ...(timeToFirstToken && { timeToFirstToken }),
+            ...(cost && { cost }),
+        };
+        return {
+            success: true,
+            prdFile: prdPath,
+            prdContent,
+            method: input.method,
+            stats,
+        };
+    }
+    /**
+     * Step 3: Refine PRD
+     * Handles PRD refinement through manual or AI methods
+     */
+    async refinePRD(input) {
+        const startTime = Date.now();
+        let tokenUsage;
+        let timeToFirstToken;
+        let cost;
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Refining PRD...",
+        });
+        if (input.method === "skip") {
+            return {
+                success: true,
+                prdFile: input.prdFile,
+                prdContent: input.prdContent || (0, fs_1.readFileSync)(input.prdFile, "utf-8"),
+                stats: {
+                    duration: Date.now() - startTime,
+                },
+            };
+        }
+        let refinedContent = input.prdContent || (0, fs_1.readFileSync)(input.prdFile, "utf-8");
+        if (input.method === "manual" && input.prdContent) {
+            refinedContent = input.prdContent;
+        }
+        else if (input.method === "ai" && input.feedback) {
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: "Refining PRD with AI...",
+            });
+            // Capture metrics for AI operations
+            const streamingOptions = {
+                ...input.streamingOptions,
+                onFinish: async (result) => {
+                    if (result.usage) {
+                        tokenUsage = {
+                            prompt: result.usage.inputTokens || result.usage.promptTokens || 0,
+                            completion: result.usage.outputTokens || result.usage.completionTokens || 0,
+                            total: result.usage.totalTokens || 0,
+                        };
+                        // Calculate cost (simplified - would need proper pricing lookup)
+                        if (tokenUsage.total > 0) {
+                            cost = tokenUsage.total * 0.000001; // Placeholder cost calculation
+                        }
+                    }
+                    // Call original onFinish if provided
+                    input.streamingOptions?.onFinish?.(result);
+                },
+                onChunk: (chunk) => {
+                    if (chunk && !timeToFirstToken) {
+                        timeToFirstToken = Date.now() - startTime;
+                    }
+                    // Call original onChunk if provided
+                    input.streamingOptions?.onChunk?.(chunk);
+                },
+            };
+            refinedContent = await workflow_ai_assistant_1.workflowAIAssistant.assistPRDRefinement({
+                currentPRD: refinedContent,
+                userFeedback: input.feedback,
+                aiOptions: input.aiOptions,
+                streamingOptions,
+            });
+        }
+        // Save refined PRD
+        (0, fs_1.writeFileSync)(input.prdFile, refinedContent);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: "PRD refined successfully",
+        });
+        const stats = {
+            duration: Date.now() - startTime,
+            ...(tokenUsage && { tokenUsage }),
+            ...(timeToFirstToken && { timeToFirstToken }),
+            ...(cost && { cost }),
+        };
+        return {
+            success: true,
+            prdFile: input.prdFile,
+            prdContent: refinedContent,
+            stats,
+        };
+    }
+    /**
+     * Step 4: Generate Tasks
+     * Generates tasks from PRD using the prdService
+     */
+    async generateTasks(input) {
+        const startTime = Date.now();
+        let tokenUsage;
+        let timeToFirstToken;
+        let cost;
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Generating tasks from PRD...",
+        });
+        // Capture metrics for AI operations
+        const streamingOptions = {
+            ...input.streamingOptions,
+            onFinish: async (result) => {
+                if (result.usage) {
+                    tokenUsage = {
+                        prompt: result.usage.inputTokens || result.usage.promptTokens || 0,
+                        completion: result.usage.outputTokens || result.usage.completionTokens || 0,
+                        total: result.usage.totalTokens || 0,
+                    };
+                    // Calculate cost (simplified - would need proper pricing lookup)
+                    if (tokenUsage.total > 0) {
+                        cost = tokenUsage.total * 0.000001; // Placeholder cost calculation
+                    }
+                }
+                // Call original onFinish if provided
+                input.streamingOptions?.onFinish?.(result);
+            },
+            onChunk: (chunk) => {
+                if (chunk && !timeToFirstToken) {
+                    timeToFirstToken = Date.now() - startTime;
+                }
+                // Call original onChunk if provided
+                input.streamingOptions?.onChunk?.(chunk);
+            },
+        };
+        const result = await prd_1.prdService.parsePRD({
+            file: input.prdFile,
+            workingDirectory: input.projectDir,
+            aiOptions: input.aiOptions,
+            messageOverride: input.customInstructions,
+            streamingOptions,
+            callbacks: input.callbacks,
+        });
+        const stats = {
+            tasksCreated: result.tasks.length,
+            duration: Date.now() - startTime,
+            ...(tokenUsage && { tokenUsage }),
+            ...(timeToFirstToken && { timeToFirstToken }),
+            ...(cost && { cost }),
+        };
+        return {
+            success: true,
+            tasks: result.tasks,
+            stats,
+        };
+    }
+    /**
+     * Step 5: Split Tasks
+     * Splits complex tasks into subtasks
+     */
+    async splitTasks(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: `Splitting ${input.taskIds.length} tasks...`,
+        });
+        const results = [];
+        for (const taskId of input.taskIds) {
+            try {
+                input.callbacks?.onProgress?.({
+                    type: "progress",
+                    message: `Splitting task ${taskId}...`,
+                });
+                const result = await tasks_1.taskService.splitTask(taskId, input.aiOptions, undefined, // promptOverride
+                input.customInstructions, input.streamingOptions);
+                results.push({
+                    taskId,
+                    subtasks: result.subtasks,
+                });
+            }
+            catch (error) {
+                results.push({
+                    taskId,
+                    subtasks: [],
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: "Task splitting completed",
+        });
+        return {
+            success: true,
+            results,
+        };
+    }
+    /**
+     * Step 6: Execute Tasks
+     * Executes the generated tasks using the task loop executor
+     */
+    async executeTasks(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Executing tasks...",
+        });
+        const result = await (0, task_loop_execution_1.executeTaskLoop)(input.options);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `Execution complete: ${result.completedTasks} completed, ${result.failedTasks} failed`,
+        });
+        return {
+            success: result.failedTasks === 0,
+            result,
+        };
+    }
+}
+exports.WorkflowService = WorkflowService;
+// Export singleton instance
+exports.workflowService = new WorkflowService();