task-o-matic-core 0.1.0

package/dist/services/prd.js

@@ -0,0 +1,550 @@
+"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.prdService = exports.PRDService = void 0;
+exports.getPRDService = getPRDService;
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const ai_config_builder_1 = require("../utils/ai-config-builder");
+const config_1 = require("../lib/config");
+const validation_1 = require("../lib/validation");
+const streaming_utils_1 = require("../utils/streaming-utils");
+const file_utils_1 = require("../utils/file-utils");
+/**
+ * PRDService - Business logic for PRD operations
+ * Handles PRD parsing, task extraction, and PRD improvement
+ */
+class PRDService {
+    storage;
+    aiOperations;
+    /**
+     * Create a new PRDService
+     *
+     * @param dependencies - Optional dependencies to inject (for testing)
+     */
+    constructor(dependencies = {}) {
+        // Use injected dependencies or fall back to singletons
+        this.storage = dependencies.storage ?? (0, ai_service_factory_1.getStorage)();
+        this.aiOperations = dependencies.aiOperations ?? (0, ai_service_factory_1.getAIOperations)();
+    }
+    async parsePRD(input) {
+        const startTime = Date.now();
+        const steps = [];
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Starting PRD parsing...",
+        });
+        // Validate file exists (DRY fix 1.2)
+        (0, file_utils_1.validateFileExists)(input.file, `PRD file not found: ${input.file}`);
+        // Ensure we're in a task-o-matic project
+        const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+        if (!(0, fs_1.existsSync)(taskOMaticDir)) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, "Not a task-o-matic project. Run 'task-o-matic init init' first.", {
+                suggestions: ["Run `task-o-matic init init` in your project root."],
+            });
+        }
+        // Set working directory and reload config (DRY fix 1.4)
+        const workingDir = input.workingDirectory || process.cwd();
+        await (0, config_1.setupWorkingDirectory)(workingDir);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Reading PRD file...",
+        });
+        const prdContent = (0, fs_1.readFileSync)(input.file, "utf-8");
+        // Save PRD file to .task-o-matic/prd directory
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Saving PRD to project directory...",
+        });
+        const stepStart1 = Date.now();
+        const prdDir = (0, path_1.join)(taskOMaticDir, "prd");
+        const prdFileName = (0, path_1.basename)(input.file);
+        const savedPrdPath = (0, path_1.join)(prdDir, prdFileName);
+        // Ensure PRD directory exists
+        if (!(0, fs_1.existsSync)(prdDir)) {
+            (0, fs_1.mkdirSync)(prdDir, { recursive: true });
+        }
+        // Copy PRD file to project directory
+        (0, fs_1.copyFileSync)(input.file, savedPrdPath);
+        // Get relative path from .task-o-matic directory for storage
+        const relativePrdPath = (0, path_1.relative)(taskOMaticDir, savedPrdPath);
+        steps.push({
+            step: "Save PRD File",
+            status: "completed",
+            duration: Date.now() - stepStart1,
+        });
+        // Validate AI provider if specified
+        if (input.aiOptions?.aiProvider &&
+            !(0, validation_1.isValidAIProvider)(input.aiOptions.aiProvider)) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR, `Invalid AI provider: ${input.aiOptions.aiProvider}`, {
+                suggestions: ["Use a valid AI provider, e.g., 'openai', 'anthropic'"],
+            });
+        }
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Parsing PRD with AI...",
+        });
+        const stepStart2 = Date.now();
+        // Use utility to wrap streaming options and capture metrics (DRY fix 1.1)
+        const { options: metricsStreamingOptions, getMetrics } = (0, streaming_utils_1.createMetricsStreamingOptions)(input.streamingOptions, stepStart2);
+        const result = await this.aiOperations.parsePRD(prdContent, aiConfig, input.promptOverride, input.messageOverride, metricsStreamingOptions, undefined, // retryConfig
+        workingDir, // Pass working directory to AI operations
+        input.enableFilesystemTools);
+        // Extract metrics after AI call
+        const { tokenUsage, timeToFirstToken } = getMetrics();
+        steps.push({
+            step: "AI Parsing",
+            status: "completed",
+            duration: Date.now() - stepStart2,
+            details: { tasksFound: result.tasks.length },
+        });
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: `Creating ${result.tasks.length} tasks...`,
+        });
+        // Create tasks
+        const stepStart3 = Date.now();
+        const createdTasks = [];
+        for (let i = 0; i < result.tasks.length; i++) {
+            const task = result.tasks[i];
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: `Creating task ${i + 1}/${result.tasks.length}: ${task.title}`,
+                current: i + 1,
+                total: result.tasks.length,
+            });
+            const createdTask = await this.storage.createTask({
+                id: task.id, // Preserve AI-generated ID for dependencies
+                title: task.title,
+                description: task.description,
+                content: task.content,
+                estimatedEffort: task.estimatedEffort,
+                status: "todo",
+                dependencies: task.dependencies,
+                tags: task.tags,
+                prdFile: relativePrdPath, // Reference to the PRD file
+            });
+            createdTasks.push(createdTask);
+            // Update AI metadata with the actual task ID
+            const aiMetadata = {
+                taskId: createdTask.id,
+                aiGenerated: true,
+                aiPrompt: input.promptOverride || "Parse PRD and extract tasks",
+                confidence: result.confidence,
+                aiProvider: input.aiOptions?.aiProvider,
+                aiModel: input.aiOptions?.aiModel,
+                generatedAt: Date.now(),
+            };
+            await this.storage.saveTaskAIMetadata(aiMetadata);
+        }
+        steps.push({
+            step: "Create Tasks",
+            status: "completed",
+            duration: Date.now() - stepStart3,
+            details: { count: createdTasks.length },
+        });
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `Successfully created ${createdTasks.length} tasks from PRD`,
+        });
+        const duration = Date.now() - startTime;
+        // Calculate cost if token usage is available
+        let cost;
+        if (tokenUsage) {
+            // Cost calculation would depend on the model
+            // For now, we'll leave it undefined and can add pricing later
+            // This matches the benchmark pattern where cost calculation is done elsewhere
+        }
+        return {
+            success: true,
+            prd: {
+                overview: result.summary || "",
+                objectives: [],
+                features: [],
+            },
+            tasks: createdTasks,
+            stats: {
+                tasksCreated: createdTasks.length,
+                duration,
+                aiProvider: input.aiOptions?.aiProvider || "default",
+                aiModel: input.aiOptions?.aiModel || "default",
+                tokenUsage,
+                timeToFirstToken,
+                cost,
+            },
+            steps,
+        };
+    }
+    async generateQuestions(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Generating clarifying questions...",
+        });
+        // Validate file exists (DRY fix 1.2)
+        (0, file_utils_1.validateFileExists)(input.file, `PRD file not found: ${input.file}`);
+        // Set working directory and reload config (DRY fix 1.4)
+        const workingDir = input.workingDirectory || process.cwd();
+        await (0, config_1.setupWorkingDirectory)(workingDir);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Reading PRD file...",
+        });
+        const prdContent = (0, fs_1.readFileSync)(input.file, "utf-8");
+        if (input.aiOptions?.aiProvider &&
+            !(0, validation_1.isValidAIProvider)(input.aiOptions.aiProvider)) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR, `Invalid AI provider: ${input.aiOptions.aiProvider}`, {
+                suggestions: ["Use a valid AI provider, e.g., 'openai', 'anthropic'"],
+            });
+        }
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Analyzing PRD with AI...",
+        });
+        const questions = await this.aiOperations.generatePRDQuestions(prdContent, aiConfig, input.promptOverride, input.messageOverride, input.streamingOptions, undefined, workingDir, input.enableFilesystemTools);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `Generated ${questions.length} questions`,
+        });
+        return questions;
+    }
+    async reworkPRD(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Starting PRD improvement...",
+        });
+        // Validate file exists (DRY fix 1.2)
+        (0, file_utils_1.validateFileExists)(input.file, `PRD file not found: ${input.file}`);
+        // Set working directory and reload config (DRY fix 1.4)
+        const workingDir = input.workingDirectory || process.cwd();
+        await (0, config_1.setupWorkingDirectory)(workingDir);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Reading PRD file...",
+        });
+        const prdContent = (0, fs_1.readFileSync)(input.file, "utf-8");
+        // Validate AI provider if specified
+        if (input.aiOptions?.aiProvider &&
+            !(0, validation_1.isValidAIProvider)(input.aiOptions.aiProvider)) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR, `Invalid AI provider: ${input.aiOptions.aiProvider}`, {
+                suggestions: ["Use a valid AI provider, e.g., 'openai', 'anthropic'"],
+            });
+        }
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Calling AI to improve PRD...",
+        });
+        const improvedPRD = await this.aiOperations.reworkPRD(prdContent, input.feedback, aiConfig, input.promptOverride, input.messageOverride, input.streamingOptions, undefined, // retryConfig
+        workingDir, // Pass working directory to AI operations
+        input.enableFilesystemTools);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Saving improved PRD...",
+        });
+        const outputPath = input.output || input.file;
+        (0, fs_1.writeFileSync)(outputPath, improvedPRD);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `PRD improved and saved to ${outputPath}`,
+        });
+        return outputPath;
+    }
+    async refinePRDWithQuestions(input) {
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Starting PRD question/refine process...",
+        });
+        // Step 1: Generate questions
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Generating clarifying questions...",
+        });
+        const questions = await this.generateQuestions({
+            file: input.file,
+            workingDirectory: input.workingDirectory,
+            enableFilesystemTools: input.enableFilesystemTools,
+            aiOptions: input.aiOptions,
+            streamingOptions: input.streamingOptions,
+            callbacks: input.callbacks,
+        });
+        if (questions.length === 0) {
+            input.callbacks?.onProgress?.({
+                type: "completed",
+                message: "No questions generated - PRD appears complete",
+            });
+            return {
+                questions: [],
+                answers: {},
+                refinedPRDPath: input.file,
+            };
+        }
+        // Step 2: Get stack info for context
+        const workingDir = input.workingDirectory || process.cwd();
+        const PromptBuilder = (await Promise.resolve().then(() => __importStar(require("../lib/prompt-builder")))).PromptBuilder;
+        let stackInfo = "";
+        try {
+            stackInfo = await PromptBuilder.detectStackInfo(workingDir);
+            if (stackInfo === "Not detected") {
+                stackInfo = "";
+            }
+        }
+        catch (error) {
+            // Stack info not available
+        }
+        // Step 3: Get answers
+        let answers;
+        if (input.questionMode === "user") {
+            // User mode: return questions for CLI to prompt user
+            // Answers should be provided in input.answers
+            if (!input.answers || Object.keys(input.answers).length === 0) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, "User mode selected but no answers provided. CLI layer should collect answers.");
+            }
+            answers = input.answers;
+        }
+        else {
+            // AI mode: use AI to answer questions with context
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: "AI is answering questions...",
+            });
+            const prdContent = (0, fs_1.readFileSync)(input.file, "utf-8");
+            // Use questionAIOptions if provided, otherwise use main aiOptions
+            const answeringAIConfig = (0, ai_config_builder_1.buildAIConfig)(input.questionAIOptions || input.aiOptions);
+            answers = await this.aiOperations.answerPRDQuestions(prdContent, questions, answeringAIConfig, {
+                stackInfo,
+            }, input.streamingOptions);
+        }
+        // Step 4: Format questions + answers as structured feedback
+        let feedback = "Please incorporate the following clarifications into the PRD:\n\n";
+        questions.forEach((q, i) => {
+            feedback += `Q${i + 1}: ${q}\nA: ${answers[q] || "No answer provided"}\n\n`;
+        });
+        // Step 5: Automatically call reworkPRD with formatted feedback
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Refining PRD with answers...",
+        });
+        const refinedPRDPath = await this.reworkPRD({
+            file: input.file,
+            feedback,
+            workingDirectory: input.workingDirectory,
+            enableFilesystemTools: input.enableFilesystemTools,
+            aiOptions: input.aiOptions,
+            streamingOptions: input.streamingOptions,
+            callbacks: input.callbacks,
+        });
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `PRD refined with ${questions.length} questions answered`,
+        });
+        return {
+            questions,
+            answers,
+            refinedPRDPath,
+        };
+    }
+    async generatePRD(input) {
+        const startTime = Date.now();
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Generating PRD...",
+        });
+        // Use utility to wrap streaming options and capture metrics
+        const { options: metricsStreamingOptions, getMetrics } = (0, streaming_utils_1.createMetricsStreamingOptions)(input.streamingOptions, startTime);
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const content = await this.aiOperations.generatePRD(input.description, aiConfig, undefined, undefined, metricsStreamingOptions);
+        // Get metrics after AI operation
+        const { tokenUsage, timeToFirstToken } = getMetrics();
+        // Calculate cost if needed
+        let cost;
+        if (tokenUsage && tokenUsage.total > 0) {
+            cost = tokenUsage.total * 0.000001; // Placeholder cost calculation
+        }
+        // Save file using utility
+        const path = (0, file_utils_1.savePRDFile)(content, input.filename, input.outputDir);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `PRD generated and saved to ${path}`,
+        });
+        return {
+            path,
+            content,
+            stats: {
+                duration: Date.now() - startTime,
+                tokenUsage,
+                timeToFirstToken,
+                cost,
+            },
+        };
+    }
+    async combinePRDs(input) {
+        const startTime = Date.now();
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Combining PRDs...",
+        });
+        // Use utility to wrap streaming options and capture metrics
+        const { options: metricsStreamingOptions, getMetrics } = (0, streaming_utils_1.createMetricsStreamingOptions)(input.streamingOptions, startTime);
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        const content = await this.aiOperations.combinePRDs(input.prds, input.originalDescription, aiConfig, undefined, undefined, metricsStreamingOptions);
+        // Get metrics after AI operation
+        const { tokenUsage, timeToFirstToken } = getMetrics();
+        // Calculate cost if needed
+        let cost;
+        if (tokenUsage && tokenUsage.total > 0) {
+            cost = tokenUsage.total * 0.000001;
+        }
+        // Save file using utility (defaults to "prd.md" if no filename, so we provide the default for combinePRDs)
+        const path = (0, file_utils_1.savePRDFile)(content, input.filename || "prd-master.md", input.outputDir);
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: `Master PRD saved to ${path}`,
+        });
+        return {
+            path,
+            content,
+            stats: {
+                duration: Date.now() - startTime,
+                tokenUsage,
+                timeToFirstToken,
+                cost,
+            },
+        };
+    }
+    /**
+     * Suggest a technology stack based on PRD analysis.
+     */
+    async suggestStack(input) {
+        const startTime = Date.now();
+        input.callbacks?.onProgress?.({
+            type: "started",
+            message: "Analyzing PRD for stack suggestion...",
+        });
+        // Validate mutual exclusivity
+        if (input.file && input.content) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, "Cannot specify both --file and --content", {
+                suggestions: ["Use either --file OR --content, not both."],
+            });
+        }
+        if (!input.file && !input.content) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, "Must specify either --file or --content", {
+                suggestions: [
+                    "Provide a PRD file with --file or content with --content.",
+                ],
+            });
+        }
+        // Get PRD content
+        let prdContent;
+        if (input.file) {
+            (0, file_utils_1.validateFileExists)(input.file, `PRD file not found: ${input.file}`);
+            prdContent = (0, fs_1.readFileSync)(input.file, "utf-8");
+        }
+        else {
+            prdContent = input.content;
+        }
+        // Set working directory
+        const workingDir = input.workingDirectory || process.cwd();
+        await (0, config_1.setupWorkingDirectory)(workingDir);
+        // Validate AI provider if specified
+        if (input.aiOptions?.aiProvider &&
+            !(0, validation_1.isValidAIProvider)(input.aiOptions.aiProvider)) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR, `Invalid AI provider: ${input.aiOptions.aiProvider}`, {
+                suggestions: ["Use a valid AI provider, e.g., 'openai', 'anthropic'"],
+            });
+        }
+        const aiConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+        input.callbacks?.onProgress?.({
+            type: "progress",
+            message: "Calling AI to analyze PRD...",
+        });
+        // Use utility to wrap streaming options and capture metrics
+        const { options: metricsStreamingOptions, getMetrics } = (0, streaming_utils_1.createMetricsStreamingOptions)(input.streamingOptions, startTime);
+        const result = await this.aiOperations.suggestStack(prdContent, input.projectName, aiConfig, input.promptOverride, input.messageOverride, metricsStreamingOptions, undefined, // retryConfig
+        workingDir, input.enableFilesystemTools);
+        // Get metrics after AI operation
+        const { tokenUsage, timeToFirstToken } = getMetrics();
+        // Calculate cost if needed
+        let cost;
+        if (tokenUsage && tokenUsage.total > 0) {
+            cost = tokenUsage.total * 0.000001; // Placeholder cost calculation
+        }
+        // Save if requested
+        let savedPath;
+        if (input.save || input.output) {
+            input.callbacks?.onProgress?.({
+                type: "progress",
+                message: "Saving stack configuration...",
+            });
+            savedPath = (0, file_utils_1.saveStackFile)(result.config, input.output);
+        }
+        input.callbacks?.onProgress?.({
+            type: "completed",
+            message: savedPath
+                ? `Stack suggestion saved to ${savedPath}`
+                : "Stack suggestion complete",
+        });
+        return {
+            success: true,
+            stack: result.config,
+            reasoning: result.reasoning,
+            savedPath,
+            stats: {
+                duration: Date.now() - startTime,
+                tokenUsage,
+                timeToFirstToken,
+                cost,
+            },
+        };
+    }
+}
+exports.PRDService = PRDService;
+// Lazy singleton instance - only created when first accessed
+let prdServiceInstance;
+function getPRDService() {
+    if (!prdServiceInstance) {
+        prdServiceInstance = new PRDService();
+    }
+    return prdServiceInstance;
+}
+// Backward compatibility: export as const but use getter
+exports.prdService = new Proxy({}, {
+    get(target, prop) {
+        return getPRDService()[prop];
+    },
+});