intention-coding 0.4.0 → 0.4.3

package/dist/services/code-generator/workflow-manager.js

@@ -1,252 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowManager = void 0;
-const logger_1 = require("../../utils/logger");
-const types_1 = require("./types");
-const research_stage_1 = require("./stages/research-stage");
-const ideation_stage_1 = require("./stages/ideation-stage");
-const planning_stage_1 = require("./stages/planning-stage");
-const execution_stage_1 = require("./stages/execution-stage");
-const optimization_stage_1 = require("./stages/optimization-stage");
-const review_stage_1 = require("./stages/review-stage");
-/**
- * 工作流程管理器
- * 职责：管理六阶段开发工作流的执行和状态转换
- */
-class WorkflowManager {
-    constructor() {
-        this.tasks = new Map();
-        this.stages = new Map();
-        this.initializeStages();
-    }
-    /**
-     * 初始化各个阶段的处理器
-     */
-    initializeStages() {
-        this.stages.set(types_1.WorkflowStage.RESEARCH, new research_stage_1.ResearchStage());
-        this.stages.set(types_1.WorkflowStage.IDEATION, new ideation_stage_1.IdeationStage());
-        this.stages.set(types_1.WorkflowStage.PLANNING, new planning_stage_1.PlanningStage());
-        this.stages.set(types_1.WorkflowStage.EXECUTION, new execution_stage_1.ExecutionStage());
-        this.stages.set(types_1.WorkflowStage.OPTIMIZATION, new optimization_stage_1.OptimizationStage());
-        this.stages.set(types_1.WorkflowStage.REVIEW, new review_stage_1.ReviewStage());
-    }
-    /**
-     * 创建新的工作流任务
-     */
-    createTask(taskDescription) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                logger_1.logger.info('创建新的工作流任务', { taskDescription });
-                const taskId = this.generateTaskId();
-                const task = {
-                    id: taskId,
-                    description: taskDescription,
-                    currentStage: types_1.WorkflowStage.RESEARCH,
-                    context: {
-                        taskDescription,
-                        requirements: {
-                            completenessScore: 0,
-                            targetClarity: 0,
-                            expectedResults: 0,
-                            scopeBoundary: 0,
-                            constraints: 0,
-                            missingInfo: [],
-                            clarificationQuestions: []
-                        },
-                        constraints: [],
-                        successCriteria: []
-                    },
-                    stages: [],
-                    createdAt: new Date(),
-                    updatedAt: new Date()
-                };
-                this.tasks.set(taskId, task);
-                // 自动开始研究阶段
-                return yield this.executeStage(taskId, types_1.WorkflowStage.RESEARCH);
-            }
-            catch (error) {
-                logger_1.logger.error('创建工作流任务失败', { error, taskDescription });
-                throw new types_1.CodeGeneratorError('无法创建工作流任务，请检查任务描述', types_1.ErrorCodes.INVALID_TASK_DESCRIPTION, types_1.WorkflowStage.RESEARCH, { taskDescription });
-            }
-        });
-    }
-    /**
-     * 执行指定阶段
-     */
-    executeStage(taskId, stage, input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const task = this.getTask(taskId);
-            try {
-                logger_1.logger.info('执行工作流阶段', { taskId, stage, currentStage: task.currentStage });
-                // 验证阶段转换的合法性
-                this.validateStageTransition(task.currentStage, stage);
-                // 获取阶段处理器
-                const stageHandler = this.stages.get(stage);
-                if (!stageHandler) {
-                    throw new types_1.CodeGeneratorError(`不支持的工作流阶段: ${stage}`, types_1.ErrorCodes.STAGE_TRANSITION_FAILED, stage);
-                }
-                // 创建阶段结果记录
-                const stageResult = {
-                    stage,
-                    status: 'in_progress',
-                    input: input || {},
-                    output: null,
-                    timestamp: new Date()
-                };
-                task.stages.push(stageResult);
-                task.currentStage = stage;
-                task.updatedAt = new Date();
-                // 执行阶段逻辑
-                const startTime = Date.now();
-                const response = yield stageHandler.execute(task, input);
-                const duration = Date.now() - startTime;
-                // 更新阶段结果
-                stageResult.status = response.status === 'success' ? 'completed' : 'failed';
-                stageResult.output = response.data;
-                stageResult.duration = duration;
-                stageResult.feedback = response.message;
-                logger_1.logger.info('工作流阶段执行完成', {
-                    taskId,
-                    stage,
-                    status: response.status,
-                    duration
-                });
-                return response;
-            }
-            catch (error) {
-                logger_1.logger.error('工作流阶段执行失败', { error, taskId, stage });
-                // 更新阶段状态为失败
-                const failedStage = task.stages.find(s => s.stage === stage);
-                if (failedStage) {
-                    failedStage.status = 'failed';
-                    failedStage.output = { error: error instanceof Error ? error.message : String(error) };
-                }
-                if (error instanceof types_1.CodeGeneratorError) {
-                    throw error;
-                }
-                throw new types_1.CodeGeneratorError(`阶段 ${stage} 执行失败: ${error instanceof Error ? error.message : String(error)}`, types_1.ErrorCodes.STAGE_TRANSITION_FAILED, stage, { taskId, originalError: error });
-            }
-        });
-    }
-    /**
-     * 继续到下一个阶段
-     */
-    proceedToNextStage(taskId, feedback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const task = this.getTask(taskId);
-            const nextStage = this.getNextStage(task.currentStage);
-            if (!nextStage) {
-                return {
-                    stage: task.currentStage,
-                    status: 'success',
-                    message: '🎉 工作流程已完成！所有阶段都已成功执行。',
-                    nextActions: ['查看最终结果', '开始新任务'],
-                    requiresUserConfirmation: false
-                };
-            }
-            // 如果有反馈，记录到当前阶段
-            if (feedback) {
-                const currentStageResult = task.stages.find(s => s.stage === task.currentStage);
-                if (currentStageResult) {
-                    currentStageResult.feedback = feedback;
-                }
-            }
-            return yield this.executeStage(taskId, nextStage);
-        });
-    }
-    /**
-     * 跳转到指定阶段
-     */
-    jumpToStage(taskId, targetStage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const task = this.getTask(taskId);
-            logger_1.logger.info('用户请求跳转阶段', {
-                taskId,
-                from: task.currentStage,
-                to: targetStage
-            });
-            return yield this.executeStage(taskId, targetStage);
-        });
-    }
-    /**
-     * 获取任务状态
-     */
-    getTaskStatus(taskId) {
-        return this.getTask(taskId);
-    }
-    /**
-     * 获取所有任务
-     */
-    getAllTasks() {
-        return Array.from(this.tasks.values());
-    }
-    /**
-     * 删除任务
-     */
-    deleteTask(taskId) {
-        return this.tasks.delete(taskId);
-    }
-    // 私有辅助方法
-    getTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            throw new types_1.CodeGeneratorError(`任务不存在: ${taskId}`, types_1.ErrorCodes.INVALID_TASK_DESCRIPTION, types_1.WorkflowStage.RESEARCH, { taskId });
-        }
-        return task;
-    }
-    generateTaskId() {
-        return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-    validateStageTransition(currentStage, targetStage) {
-        // 允许用户跳转到任何阶段（按照工作流文档要求）
-        // 但记录非顺序跳转的警告
-        const stageOrder = [
-            types_1.WorkflowStage.RESEARCH,
-            types_1.WorkflowStage.IDEATION,
-            types_1.WorkflowStage.PLANNING,
-            types_1.WorkflowStage.EXECUTION,
-            types_1.WorkflowStage.OPTIMIZATION,
-            types_1.WorkflowStage.REVIEW
-        ];
-        const currentIndex = stageOrder.indexOf(currentStage);
-        const targetIndex = stageOrder.indexOf(targetStage);
-        if (targetIndex < currentIndex) {
-            logger_1.logger.warn('用户跳转到之前的阶段', {
-                from: currentStage,
-                to: targetStage
-            });
-        }
-        else if (targetIndex > currentIndex + 1) {
-            logger_1.logger.warn('用户跳过了中间阶段', {
-                from: currentStage,
-                to: targetStage,
-                skipped: stageOrder.slice(currentIndex + 1, targetIndex)
-            });
-        }
-    }
-    getNextStage(currentStage) {
-        const stageOrder = [
-            types_1.WorkflowStage.RESEARCH,
-            types_1.WorkflowStage.IDEATION,
-            types_1.WorkflowStage.PLANNING,
-            types_1.WorkflowStage.EXECUTION,
-            types_1.WorkflowStage.OPTIMIZATION,
-            types_1.WorkflowStage.REVIEW
-        ];
-        const currentIndex = stageOrder.indexOf(currentStage);
-        if (currentIndex === -1 || currentIndex === stageOrder.length - 1) {
-            return null;
-        }
-        return stageOrder[currentIndex + 1];
-    }
-}
-exports.WorkflowManager = WorkflowManager;