task-o-matic-core 0.1.0

package/dist/services/workflow-ai-assistant.d.ts

@@ -0,0 +1,74 @@
+import { StreamingOptions } from "../types";
+import { AIOptions } from "../utils/ai-config-builder";
+/**
+ * WorkflowAIAssistant - AI-powered decision making for workflow steps
+ * Helps users make configuration choices using natural language
+ */
+export declare class WorkflowAIAssistant {
+    /**
+     * Assist with initialization and bootstrap configuration
+     */
+    assistInitConfig(input: {
+        userDescription: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<{
+        projectName: string;
+        aiProvider: string;
+        aiModel: string;
+        frontend?: string;
+        backend?: string;
+        database?: string;
+        auth?: boolean;
+        reasoning: string;
+    }>;
+    /**
+     * Generate a PRD from user's product description
+     */
+    assistPRDCreation(input: {
+        userDescription: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+    /**
+     * Suggest improvements to an existing PRD
+     */
+    assistPRDRefinement(input: {
+        currentPRD: string;
+        userFeedback: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+    /**
+     * Help prioritize and organize tasks
+     */
+    assistTaskPrioritization(input: {
+        tasks: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+        userGuidance: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<{
+        prioritizedTasks: Array<{
+            id: string;
+            priority: number;
+            reasoning: string;
+        }>;
+        recommendations: string;
+    }>;
+    /**
+     * Generate custom instructions for task splitting
+     */
+    assistTaskSplitting(input: {
+        taskTitle: string;
+        taskContent?: string;
+        userGuidance: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+}
+export declare const workflowAIAssistant: WorkflowAIAssistant;
+//# sourceMappingURL=workflow-ai-assistant.d.ts.map

package/dist/services/workflow-ai-assistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-ai-assistant.d.ts","sourceRoot":"","sources":["../../src/services/workflow-ai-assistant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,EAAiB,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAQtE;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE;QAC5B,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAgEF;;OAEG;IACG,iBAAiB,CAAC,KAAK,EAAE;QAC7B,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;IAYnB;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;IAoCnB;;OAEG;IACG,wBAAwB,CAAC,KAAK,EAAE;QACpC,KAAK,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAClE,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC;QACV,gBAAgB,EAAE,KAAK,CAAC;YACtB,EAAE,EAAE,MAAM,CAAC;YACX,QAAQ,EAAE,MAAM,CAAC;YACjB,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC,CAAC;QACH,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IAwEF;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE;QAC/B,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;CAwCpB;AAGD,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}

package/dist/services/workflow-ai-assistant.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowAIAssistant = exports.WorkflowAIAssistant = void 0;
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const ai_config_builder_1 = require("../utils/ai-config-builder");
+const prompt_builder_1 = require("../lib/prompt-builder");
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+/**
+ * WorkflowAIAssistant - AI-powered decision making for workflow steps
+ * Helps users make configuration choices using natural language
+ */
+class WorkflowAIAssistant {
+    /**
+     * Assist with initialization and bootstrap configuration
+     */
+    async assistInitConfig(input) {
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "project-init-suggestion",
+            type: "user",
+            variables: {
+                USER_DESCRIPTION: input.userDescription,
+            },
+        });
+        if (!promptResult.success) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, `Failed to build project init prompt: ${promptResult.error}`);
+        }
+        const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "project-init-suggestion",
+            type: "system",
+            variables: {},
+        });
+        const result = await (0, ai_service_factory_1.getAIOperations)().streamText(promptResult.prompt, aiConfig, systemPromptResult.prompt, undefined, input.streamingOptions);
+        // Parse AI response
+        try {
+            const jsonMatch = result.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, "No JSON found in AI response for init config", {
+                    context: "The AI did not return a valid JSON object.",
+                    suggestions: [
+                        "Try a different model or provider.",
+                        "Check the prompt for clarity.",
+                    ],
+                });
+            }
+            return JSON.parse(jsonMatch[0]);
+        }
+        catch (error) {
+            // Fallback to sensible defaults
+            return {
+                projectName: "my-project",
+                aiProvider: "openrouter",
+                aiModel: "anthropic/claude-3.5-sonnet",
+                frontend: "next",
+                backend: "hono",
+                database: "sqlite",
+                auth: true,
+                reasoning: "Using modern, well-supported defaults",
+            };
+        }
+    }
+    /**
+     * Generate a PRD from user's product description
+     */
+    async assistPRDCreation(input) {
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        return (0, ai_service_factory_1.getAIOperations)().generatePRD(input.userDescription, aiConfig, undefined, undefined, input.streamingOptions);
+    }
+    /**
+     * Suggest improvements to an existing PRD
+     */
+    async assistPRDRefinement(input) {
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "prd-improvement",
+            type: "user",
+            variables: {
+                CURRENT_PRD: input.currentPRD,
+                USER_FEEDBACK: input.userFeedback,
+            },
+        });
+        if (!promptResult.success) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, `Failed to build PRD improvement prompt: ${promptResult.error}`);
+        }
+        const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "prd-improvement",
+            type: "system",
+            variables: {},
+        });
+        const result = await (0, ai_service_factory_1.getAIOperations)().streamText(promptResult.prompt, aiConfig, systemPromptResult.prompt, undefined, input.streamingOptions);
+        return result;
+    }
+    /**
+     * Help prioritize and organize tasks
+     */
+    async assistTaskPrioritization(input) {
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const tasksDescription = input.tasks
+            .map((t, i) => `${i + 1}. [${t.id}] ${t.title}${t.description ? `: ${t.description}` : ""}`)
+            .join("\n");
+        const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "task-prioritization",
+            type: "user",
+            variables: {
+                TASKS_DESCRIPTION: tasksDescription,
+                USER_GUIDANCE: input.userGuidance,
+            },
+        });
+        if (!promptResult.success) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, `Failed to build task prioritization prompt: ${promptResult.error}`);
+        }
+        const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "task-prioritization",
+            type: "system",
+            variables: {},
+        });
+        const result = await (0, ai_service_factory_1.getAIOperations)().streamText(promptResult.prompt, aiConfig, systemPromptResult.prompt, undefined, input.streamingOptions);
+        // Parse AI response
+        try {
+            const jsonMatch = result.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, "No JSON found in AI response for task prioritization", {
+                    context: "The AI did not return a valid JSON object.",
+                    suggestions: [
+                        "Try a different model or provider.",
+                        "Check the prompt for clarity.",
+                    ],
+                });
+            }
+            return JSON.parse(jsonMatch[0]);
+        }
+        catch (error) {
+            // Fallback: return tasks in original order
+            return {
+                prioritizedTasks: input.tasks.map((t, i) => ({
+                    id: t.id,
+                    priority: i + 1,
+                    reasoning: "Default ordering",
+                })),
+                recommendations: "Review and adjust priorities as needed",
+            };
+        }
+    }
+    /**
+     * Generate custom instructions for task splitting
+     */
+    async assistTaskSplitting(input) {
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const taskContentText = input.taskContent
+            ? `Description: ${input.taskContent}`
+            : "";
+        const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "task-splitting-assistance",
+            type: "user",
+            variables: {
+                TASK_TITLE: input.taskTitle,
+                TASK_CONTENT: taskContentText,
+                USER_GUIDANCE: input.userGuidance,
+            },
+        });
+        if (!promptResult.success) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, `Failed to build task splitting prompt: ${promptResult.error}`);
+        }
+        const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "task-splitting-assistance",
+            type: "system",
+            variables: {},
+        });
+        const result = await (0, ai_service_factory_1.getAIOperations)().streamText(promptResult.prompt, aiConfig, systemPromptResult.prompt, undefined, input.streamingOptions);
+        return result;
+    }
+}
+exports.WorkflowAIAssistant = WorkflowAIAssistant;
+// Export singleton instance
+exports.workflowAIAssistant = new WorkflowAIAssistant();

package/dist/services/workflow-benchmark.d.ts

@@ -0,0 +1,34 @@
+import { AIOptions } from "../utils/ai-config-builder";
+import { StreamingOptions } from "../types";
+import { WorkflowBenchmarkInput, WorkflowBenchmarkResult } from "../lib/benchmark/types";
+/**
+ * WorkflowBenchmarkService - Executes complete workflows for benchmarking
+ * Creates isolated environments for each model to ensure fair comparison
+ */
+export declare class WorkflowBenchmarkService {
+    /**
+     * Execute a complete workflow for benchmarking purposes
+     */
+    executeWorkflow(input: WorkflowBenchmarkInput, aiOptions: AIOptions, streamingOptions?: StreamingOptions): Promise<WorkflowBenchmarkResult["output"]>;
+    /**
+     * Create a temporary project directory for benchmarking
+     */
+    private createTempProjectDir;
+    /**
+     * Clean up temporary project directory
+     */
+    private cleanupTempProjectDir;
+    /**
+     * Apply the results from a selected benchmark to the actual project
+     */
+    applyBenchmarkResult(selectedResult: WorkflowBenchmarkResult, targetProjectDir: string, originalResponses: WorkflowBenchmarkInput["collectedResponses"]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Validate workflow benchmark input
+     */
+    validateInput(input: any): input is WorkflowBenchmarkInput;
+}
+export declare const workflowBenchmarkService: WorkflowBenchmarkService;
+//# sourceMappingURL=workflow-benchmark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-benchmark.d.ts","sourceRoot":"","sources":["../../src/services/workflow-benchmark.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAQ,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAIzF;;;GAGG;AACH,qBAAa,wBAAwB;IACnC;;OAEG;IACG,eAAe,CACnB,KAAK,EAAE,sBAAsB,EAC7B,SAAS,EAAE,SAAS,EACpB,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAiL7C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;OAEG;IACG,oBAAoB,CACxB,cAAc,EAAE,uBAAuB,EACvC,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,sBAAsB,CAAC,oBAAoB,CAAC,GAC9D,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAyFjD;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,sBAAsB;CAU3D;AAED,eAAO,MAAM,wBAAwB,0BAAiC,CAAC"}

package/dist/services/workflow-benchmark.js

@@ -0,0 +1,318 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowBenchmarkService = exports.WorkflowBenchmarkService = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const workflow_1 = require("./workflow");
+const logger_1 = require("../lib/logger");
+/**
+ * WorkflowBenchmarkService - Executes complete workflows for benchmarking
+ * Creates isolated environments for each model to ensure fair comparison
+ */
+class WorkflowBenchmarkService {
+    /**
+     * Execute a complete workflow for benchmarking purposes
+     */
+    async executeWorkflow(input, aiOptions, streamingOptions) {
+        const startTime = Date.now();
+        // Create temporary project directory for this benchmark run
+        const tempProjectDir = this.createTempProjectDir(input.tempDirBase || "/tmp", input.collectedResponses.projectName, aiOptions.aiProvider || "unknown", aiOptions.aiModel || "unknown");
+        const stats = {
+            initDuration: 0,
+            prdGenerationDuration: 0,
+            prdRefinementDuration: 0,
+            taskGenerationDuration: 0,
+            taskSplittingDuration: 0,
+            totalTasks: 0,
+            tasksWithSubtasks: 0,
+            avgTaskComplexity: 0,
+            prdSize: 0,
+            totalSteps: 0,
+            successfulSteps: 0,
+        };
+        let projectDir = tempProjectDir;
+        let prdFile = "";
+        let prdContent = "";
+        let tasks = [];
+        try {
+            // Step 1: Initialize Project
+            const stepStart = Date.now();
+            stats.totalSteps++;
+            const initResult = await workflow_1.workflowService.initializeProject({
+                projectName: input.collectedResponses.projectName,
+                projectDir: tempProjectDir,
+                initMethod: input.collectedResponses.initMethod,
+                projectDescription: input.collectedResponses.projectDescription,
+                aiOptions,
+                stackConfig: input.collectedResponses.stackConfig,
+                bootstrap: true, // Always bootstrap for benchmark unless explicitly disabled
+                streamingOptions,
+                callbacks: {
+                    onProgress: () => { }, // Silent for benchmarking
+                    onError: () => { },
+                },
+            });
+            stats.initDuration = Date.now() - stepStart;
+            stats.successfulSteps++;
+            projectDir = initResult.projectDir;
+            // Step 2: Define PRD
+            if (input.collectedResponses.prdMethod !== "skip") {
+                const prdStart = Date.now();
+                stats.totalSteps++;
+                const prdResult = await workflow_1.workflowService.definePRD({
+                    method: input.collectedResponses.prdMethod,
+                    prdFile: input.collectedResponses.prdFile,
+                    prdDescription: input.collectedResponses.prdDescription,
+                    prdContent: input.collectedResponses.prdContent,
+                    projectDir,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {
+                        onProgress: () => { },
+                        onError: () => { },
+                    },
+                });
+                stats.prdGenerationDuration = Date.now() - prdStart;
+                stats.successfulSteps++;
+                prdFile = prdResult.prdFile;
+                prdContent = prdResult.prdContent;
+                stats.prdSize = prdContent.length;
+                // Step 3: Refine PRD (if requested)
+                if (input.collectedResponses.refinePrd && input.collectedResponses.refineFeedback) {
+                    const refineStart = Date.now();
+                    stats.totalSteps++;
+                    const refineResult = await workflow_1.workflowService.refinePRD({
+                        method: "ai",
+                        prdFile,
+                        feedback: input.collectedResponses.refineFeedback,
+                        projectDir,
+                        aiOptions,
+                        streamingOptions,
+                        callbacks: {
+                            onProgress: () => { },
+                            onError: () => { },
+                        },
+                    });
+                    stats.prdRefinementDuration = Date.now() - refineStart;
+                    stats.successfulSteps++;
+                    prdContent = refineResult.prdContent;
+                    stats.prdSize = prdContent.length;
+                }
+                // Step 4: Generate Tasks
+                if (input.collectedResponses.generateTasks !== false && prdFile) {
+                    const tasksStart = Date.now();
+                    stats.totalSteps++;
+                    const tasksResult = await workflow_1.workflowService.generateTasks({
+                        prdFile,
+                        method: input.collectedResponses.customInstructions ? "ai" : "standard",
+                        customInstructions: input.collectedResponses.customInstructions,
+                        projectDir,
+                        aiOptions,
+                        streamingOptions,
+                        callbacks: {
+                            onProgress: () => { },
+                            onError: () => { },
+                        },
+                    });
+                    stats.taskGenerationDuration = Date.now() - tasksStart;
+                    stats.successfulSteps++;
+                    tasks = tasksResult.tasks;
+                    stats.totalTasks = tasks.length;
+                    // Step 5: Split Tasks (if requested)
+                    if (input.collectedResponses.splitTasks && tasks.length > 0) {
+                        const splitStart = Date.now();
+                        stats.totalSteps++;
+                        const tasksToSplit = input.collectedResponses.tasksToSplit?.length
+                            ? input.collectedResponses.tasksToSplit
+                            : tasks.slice(0, Math.min(3, tasks.length)).map(t => t.id); // Split first 3 tasks by default
+                        const splitResult = await workflow_1.workflowService.splitTasks({
+                            taskIds: tasksToSplit,
+                            splitMethod: input.collectedResponses.splitInstructions ? "custom" : "standard",
+                            customInstructions: input.collectedResponses.splitInstructions,
+                            aiOptions,
+                            streamingOptions,
+                            callbacks: {
+                                onProgress: () => { },
+                                onError: () => { },
+                            },
+                        });
+                        stats.taskSplittingDuration = Date.now() - splitStart;
+                        stats.successfulSteps++;
+                        stats.tasksWithSubtasks = splitResult.results.filter(r => !r.error && r.subtasks.length > 0).length;
+                    }
+                }
+            }
+            // Calculate complexity metrics
+            if (tasks.length > 0) {
+                const totalComplexity = tasks.reduce((sum, task) => {
+                    const contentLength = (task.description || "").length;
+                    return sum + (contentLength > 200 ? 3 : contentLength > 100 ? 2 : 1);
+                }, 0);
+                stats.avgTaskComplexity = totalComplexity / tasks.length;
+            }
+            return {
+                projectDir,
+                prdFile,
+                prdContent,
+                tasks,
+                stats,
+            };
+        }
+        finally {
+            // Clean up temporary directory
+            this.cleanupTempProjectDir(tempProjectDir);
+        }
+    }
+    /**
+     * Create a temporary project directory for benchmarking
+     */
+    createTempProjectDir(tempBase, projectName, provider, model) {
+        const sanitizedModel = model.replace(/[^a-zA-Z0-9-]/g, "-");
+        const dirName = `benchmark-${projectName}-${provider}-${sanitizedModel}-${Date.now()}`;
+        const tempDir = (0, path_1.join)(tempBase, "task-o-matic-benchmark", dirName);
+        if (!(0, fs_1.existsSync)(tempDir)) {
+            (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+        }
+        return tempDir;
+    }
+    /**
+     * Clean up temporary project directory
+     */
+    cleanupTempProjectDir(projectDir) {
+        try {
+            if ((0, fs_1.existsSync)(projectDir) && projectDir.includes("task-o-matic-benchmark")) {
+                (0, fs_1.rmSync)(projectDir, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            // Ignore cleanup errors
+            logger_1.logger.warn(`Warning: Could not clean up temp directory ${projectDir}`);
+        }
+    }
+    /**
+     * Apply the results from a selected benchmark to the actual project
+     */
+    async applyBenchmarkResult(selectedResult, targetProjectDir, originalResponses) {
+        try {
+            const { workflowService } = await Promise.resolve().then(() => __importStar(require("./workflow")));
+            const { writeFileSync, existsSync, mkdirSync } = await Promise.resolve().then(() => __importStar(require("fs")));
+            const { join } = await Promise.resolve().then(() => __importStar(require("path")));
+            // Ensure target directory exists
+            if (!existsSync(targetProjectDir)) {
+                mkdirSync(targetProjectDir, { recursive: true });
+            }
+            // Extract model configuration from modelId (e.g., "openai:gpt-4o")
+            const [provider, model] = selectedResult.modelId.split(":").slice(0, 2);
+            // Step 1: Initialize actual project with selected model
+            const actualResult = await workflowService.initializeProject({
+                projectName: originalResponses.projectName,
+                projectDir: targetProjectDir,
+                initMethod: originalResponses.initMethod,
+                projectDescription: originalResponses.projectDescription,
+                aiOptions: {
+                    aiProvider: provider,
+                    aiModel: model,
+                },
+                stackConfig: originalResponses.stackConfig,
+                bootstrap: true,
+                streamingOptions: {},
+                callbacks: {
+                    onProgress: (msg) => {
+                        const message = typeof msg === 'string' ? msg :
+                            'message' in msg ? msg.message :
+                                'text' in msg ? msg.text : 'Progress update';
+                        logger_1.logger.progress(`  ${message}`);
+                    },
+                    onError: (err) => logger_1.logger.error(`  Error: ${err.message || err}`),
+                },
+            });
+            // Step 2: Copy PRD content if available
+            if (selectedResult.output.prdContent && selectedResult.output.prdFile) {
+                const taskOMaticDir = join(targetProjectDir, ".task-o-matic", "prd");
+                if (!existsSync(taskOMaticDir)) {
+                    mkdirSync(taskOMaticDir, { recursive: true });
+                }
+                const targetPrdFile = join(taskOMaticDir, "prd.md");
+                writeFileSync(targetPrdFile, selectedResult.output.prdContent);
+                logger_1.logger.success(`  ✓ PRD copied to ${targetPrdFile}`);
+            }
+            // Step 3: Import tasks if available
+            if (selectedResult.output.tasks && selectedResult.output.tasks.length > 0) {
+                const { getStorage } = await Promise.resolve().then(() => __importStar(require("../utils/ai-service-factory")));
+                // Switch to target directory context
+                process.chdir(targetProjectDir);
+                for (const task of selectedResult.output.tasks) {
+                    try {
+                        await getStorage().createTask({
+                            title: task.title,
+                            description: task.description || "",
+                            content: task.description || "",
+                            parentId: task.parentId,
+                            estimatedEffort: task.estimatedEffort,
+                        });
+                    }
+                    catch (error) {
+                        logger_1.logger.warn(`  Warning: Could not import task "${task.title}"`);
+                    }
+                }
+                logger_1.logger.success(`  ✓ Imported ${selectedResult.output.tasks.length} tasks`);
+            }
+            return {
+                success: true,
+                message: `Successfully applied results from ${selectedResult.modelId} to ${targetProjectDir}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to apply benchmark results: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Validate workflow benchmark input
+     */
+    validateInput(input) {
+        return (input &&
+            input.collectedResponses &&
+            typeof input.collectedResponses.projectName === "string" &&
+            input.collectedResponses.projectName.length > 0 &&
+            typeof input.collectedResponses.initMethod === "string" &&
+            ["quick", "custom", "ai"].includes(input.collectedResponses.initMethod));
+    }
+}
+exports.WorkflowBenchmarkService = WorkflowBenchmarkService;
+exports.workflowBenchmarkService = new WorkflowBenchmarkService();