task-o-matic 0.0.7 → 0.0.9

package/dist/services/workflow-benchmark.js

@@ -0,0 +1,317 @@
+"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");
+/**
+ * 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
+            console.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';
+                        console.log(`  ${message}`);
+                    },
+                    onError: (err) => console.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);
+                console.log(`  ✓ 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) {
+                        console.warn(`  Warning: Could not import task "${task.title}"`);
+                    }
+                }
+                console.log(`  ✓ 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();

package/dist/services/workflow.d.ts

@@ -0,0 +1,85 @@
+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";
+/**
+ * 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;
+        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;
+    }): 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>;
+}
+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":"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"}