intention-coding 0.3.7 → 0.4.0

package/dist/services/integrated-generator/index.js

@@ -0,0 +1,1297 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integratedGenerator = exports.IntegratedGeneratorParams = void 0;
+const zod_1 = require("zod");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../../utils/logger");
+const config_1 = require("../../utils/config");
+const common_1 = require("../../utils/common");
+const crypto_1 = require("crypto");
+exports.IntegratedGeneratorParams = zod_1.z.object({
+    // 项目基本信息
+    project_name: zod_1.z.string().describe("项目名称"),
+    project_description: zod_1.z.string().describe("项目描述"),
+    // 需求信息
+    user_story: zod_1.z.string().describe("用户故事 - 遵循As a...I want...So that...格式"),
+    acceptance_criteria: zod_1.z.array(zod_1.z.string()).describe("验收标准列表"),
+    // 技术信息
+    programming_language: zod_1.z.string().describe("编程语言"),
+    framework: zod_1.z.string().optional().describe("使用的框架"),
+    architecture_pattern: zod_1.z.enum(['microservices', 'monolithic', 'layered', 'event-driven']).optional().describe("架构模式"),
+    // 生成选项
+    generation_type: zod_1.z.enum(['full_project', 'module_only', 'feature_only']).default('full_project').describe("生成类型"),
+    include_examples: zod_1.z.boolean().optional().default(true).describe("是否包含代码示例"),
+    include_tests: zod_1.z.boolean().optional().default(true).describe("是否包含测试代码"),
+    // 自定义内容
+    custom_context: zod_1.z.string().optional().describe("自定义上下文信息"),
+    business_rules: zod_1.z.array(zod_1.z.string()).optional().describe("业务规则"),
+    technical_requirements: zod_1.z.string().optional().describe("技术要求")
+});
+exports.integratedGenerator = {
+    name: 'integrated_generator',
+    description: '集成化项目生成器 - 按照需求驱动的开发流程生成完整的项目结构和代码',
+    parameters: exports.IntegratedGeneratorParams,
+    execute: (args) => __awaiter(void 0, void 0, void 0, function* () {
+        const { project_name, project_description, user_story, acceptance_criteria, programming_language, framework, architecture_pattern = 'layered', generation_type = 'full_project', include_examples = true, include_tests = true, custom_context, business_rules = [], technical_requirements } = args;
+        const sessionUuid = (0, crypto_1.randomUUID)();
+        const sanitizedProjectName = (0, common_1.sanitizeFileName)(project_name);
+        const sessionId = `${sanitizedProjectName}_${Date.now()}`;
+        try {
+            logger_1.logger.info('开始集成化项目生成流程', {
+                sessionUuid,
+                sessionId,
+                project_name,
+                programming_language,
+                framework,
+                generation_type
+            });
+            // 1. 准备输出目录
+            const outputDir = path_1.default.join((0, config_1.getStorageDir)(), 'integrated-projects');
+            yield promises_1.default.mkdir(outputDir, { recursive: true });
+            const projectDir = path_1.default.join(outputDir, sessionId);
+            yield promises_1.default.mkdir(projectDir, { recursive: true });
+            // 2. 创建项目结构
+            const projectStructure = yield createProjectStructure({
+                projectDir,
+                project_name,
+                programming_language,
+                framework,
+                architecture_pattern,
+                generation_type
+            });
+            // 3. 按规则流程生成文档和代码
+            const generationResult = yield executeRuleBasedGeneration({
+                sessionUuid,
+                projectDir,
+                project_name,
+                project_description,
+                user_story,
+                acceptance_criteria,
+                programming_language,
+                framework,
+                architecture_pattern,
+                generation_type,
+                include_examples,
+                include_tests,
+                custom_context,
+                business_rules,
+                technical_requirements
+            });
+            // 4. 生成项目规范文档
+            yield generateProjectStandards({
+                projectDir,
+                project_name,
+                programming_language,
+                framework,
+                architecture_pattern
+            });
+            // 5. 创建开发工作流文档
+            yield createDevelopmentWorkflow({
+                projectDir,
+                project_name,
+                user_story,
+                acceptance_criteria
+            });
+            logger_1.logger.info('集成化项目生成完成', {
+                sessionUuid,
+                projectDir: path_1.default.resolve(projectDir),
+                generatedFiles: generationResult.files.length,
+                structure: projectStructure
+            });
+            return formatIntegrationResult({
+                sessionUuid,
+                projectDir,
+                project_name,
+                generationResult,
+                projectStructure
+            });
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error('集成化项目生成失败', {
+                sessionUuid,
+                project_name,
+                error: errorMsg
+            });
+            throw new Error(`集成化项目生成失败: ${errorMsg}`);
+        }
+    })
+};
+// 创建项目结构
+function createProjectStructure(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { projectDir, programming_language, architecture_pattern, generation_type } = params;
+        const structure = {
+            docs: ['requirements', 'architecture', 'api', 'deployment'],
+            tests: ['unit', 'integration', 'e2e'],
+            config: [],
+            scripts: []
+        };
+        // 根据编程语言和架构模式创建结构
+        if (programming_language === 'typescript') {
+            if (architecture_pattern === 'layered') {
+                structure.src = ['controllers', 'services', 'repositories', 'models', 'middleware', 'utils'];
+                structure.config = ['database', 'environment', 'logging'];
+            }
+            else if (architecture_pattern === 'microservices') {
+                structure.services = [];
+                structure.shared = ['common', 'utils', 'config'];
+            }
+        }
+        else if (programming_language === 'python') {
+            structure.src = ['api', 'core', 'models', 'services', 'utils'];
+            structure.config = ['settings', 'database'];
+        }
+        // 创建目录结构
+        for (const [dir, subdirs] of Object.entries(structure)) {
+            const dirPath = path_1.default.join(projectDir, dir);
+            yield promises_1.default.mkdir(dirPath, { recursive: true });
+            if (Array.isArray(subdirs)) {
+                for (const subdir of subdirs) {
+                    yield promises_1.default.mkdir(path_1.default.join(dirPath, subdir), { recursive: true });
+                }
+            }
+        }
+        // 创建基础配置文件
+        yield createBaseConfigFiles(projectDir, params);
+        return structure;
+    });
+}
+// 创建基础配置文件
+function createBaseConfigFiles(projectDir, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { programming_language, framework } = params;
+        // 根据语言创建对应的配置文件
+        if (programming_language === 'typescript') {
+            yield promises_1.default.writeFile(path_1.default.join(projectDir, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: {
+                    target: 'ES2020',
+                    module: 'commonjs',
+                    outDir: './dist',
+                    rootDir: './src',
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    forceConsistentCasingInFileNames: true
+                }
+            }, null, 2));
+            yield promises_1.default.writeFile(path_1.default.join(projectDir, 'package.json'), JSON.stringify({
+                name: params.project_name,
+                version: '1.0.0',
+                description: params.project_description,
+                main: 'dist/index.js',
+                scripts: {
+                    dev: 'ts-node-dev --respawn --transpile-only src/index.ts',
+                    build: 'tsc',
+                    test: 'jest',
+                    lint: 'eslint src/**/*.ts'
+                },
+                dependencies: Object.assign(Object.assign(Object.assign({}, (framework === 'express' && { express: '^4.18.0' })), (framework === 'koa' && { koa: '^2.14.0' })), { 'dotenv': '^16.0.0' }),
+                devDependencies: {
+                    '@types/node': '^18.0.0',
+                    'typescript': '^4.9.0',
+                    'jest': '^29.0.0',
+                    'ts-jest': '^29.0.0'
+                }
+            }, null, 2));
+        }
+    });
+}
+// 执行基于规则的生成流程
+function executeRuleBasedGeneration(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { projectDir, sessionUuid } = params;
+        const generatedFiles = [];
+        // 1. 生成用户故事文档（严格按照规则）
+        const storyContent = yield generateUserStoryDocument(params);
+        const storyPath = path_1.default.join(projectDir, 'docs', 'requirements', 'user-story.md');
+        yield promises_1.default.writeFile(storyPath, storyContent, 'utf-8');
+        const storyStats = yield promises_1.default.stat(storyPath);
+        generatedFiles.push({ type: 'user-story', path: storyPath, size: storyStats.size });
+        // 2. 生成Feature文件（等待用户确认后才生成）
+        const featureContent = yield generateFeatureFile(params);
+        const featurePath = path_1.default.join(projectDir, 'docs', 'requirements', `${(0, common_1.sanitizeFileName)(params.project_name)}.feature.md`);
+        yield promises_1.default.writeFile(featurePath, featureContent, 'utf-8');
+        const featureStats = yield promises_1.default.stat(featurePath);
+        generatedFiles.push({ type: 'feature', path: featurePath, size: featureStats.size });
+        // 3. 生成技术架构文档
+        const architectureContent = yield generateArchitectureDocument(params);
+        const architecturePath = path_1.default.join(projectDir, 'docs', 'architecture', 'technical-architecture.md');
+        yield promises_1.default.writeFile(architecturePath, architectureContent, 'utf-8');
+        const archStats = yield promises_1.default.stat(architecturePath);
+        generatedFiles.push({ type: 'architecture', path: architecturePath, size: archStats.size });
+        // 4. 生成API文档
+        const apiContent = yield generateApiDocumentation(params);
+        const apiPath = path_1.default.join(projectDir, 'docs', 'api', 'api-specification.md');
+        yield promises_1.default.writeFile(apiPath, apiContent, 'utf-8');
+        const apiStats = yield promises_1.default.stat(apiPath);
+        generatedFiles.push({ type: 'api', path: apiPath, size: apiStats.size });
+        // 5. 生成测试计划
+        const testPlanContent = yield generateTestPlan(params);
+        const testPlanPath = path_1.default.join(projectDir, 'docs', 'testing-strategy.md');
+        yield promises_1.default.writeFile(testPlanPath, testPlanContent, 'utf-8');
+        const testStats = yield promises_1.default.stat(testPlanPath);
+        generatedFiles.push({ type: 'test-plan', path: testPlanPath, size: testStats.size });
+        // 6. 生成代码模板（如果指定了语言）
+        if (params.programming_language) {
+            const codeTemplates = yield generateCodeTemplates(params);
+            const codeDir = path_1.default.join(projectDir, 'src');
+            for (const template of codeTemplates) {
+                const templatePath = path_1.default.join(codeDir, template.filename);
+                yield promises_1.default.mkdir(path_1.default.dirname(templatePath), { recursive: true });
+                yield promises_1.default.writeFile(templatePath, template.content, 'utf-8');
+                const stats = yield promises_1.default.stat(templatePath);
+                generatedFiles.push({ type: 'code-template', path: templatePath, size: stats.size });
+            }
+        }
+        return { files: generatedFiles };
+    });
+}
+// 生成用户故事文档
+function generateUserStoryDocument(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { project_name, project_description, user_story, acceptance_criteria, business_rules = [] } = params;
+        return `# ${project_name} - 用户故事
+
+## 作为 (As a)
+[从用户故事中提取角色]
+
+## 我想要 (I want)
+[从用户故事中提取需求]
+
+## 以便于 (So that)
+[从用户故事中提取价值]
+
+## 验收标准 (Acceptance Criteria)
+${acceptance_criteria.map((criteria, index) => `- [ ] ${criteria}`).join('\n')}
+
+## 业务规则
+${business_rules.map((rule) => `* ${rule}`).join('\n')}
+
+## 补充信息
+- 项目描述：${project_description}
+- 技术要求：${params.technical_requirements || '待补充'}
+- 编程语言：${params.programming_language}
+- 框架：${params.framework || '未指定'}
+
+## 关联文件
+- Feature文件：../requirements/${(0, common_1.sanitizeFileName)(project_name)}.feature.md
+- API文档：../api/api-specification.md
+- 技术架构：../architecture/technical-architecture.md
+
+## 版本管理
+- 版本：v1.0.0
+- 创建时间：${new Date().toISOString()}
+- 状态：待评审
+
+## 评审检查点
+- [ ] 故事描述清晰完整
+- [ ] 验收标准具体可测试
+- [ ] 技术可行性已评估
+- [ ] 业务价值已明确
+
+> **重要提示**：此用户故事必须经过业务人员和开发人员的评审确认后，才能开始编写Feature文件和进行开发工作。详见.cursor/rules/requirements.md中的开发流程规范。
+`;
+    });
+}
+// 生成Feature文件
+function generateFeatureFile(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { project_name, user_story, acceptance_criteria } = params;
+        // 从用户故事提取关键信息
+        const lines = user_story.split('\n');
+        const asLine = lines.find((l) => l.toLowerCase().includes('as a')) || 'As a user';
+        const wantLine = lines.find((l) => l.toLowerCase().includes('i want')) || 'I want to use the system';
+        const soThatLine = lines.find((l) => l.toLowerCase().includes('so that')) || 'So that I can achieve my goals';
+        return `# ${project_name} - Feature Specification
+
+> **关联需求文档**：user-story.md
+> **状态**：等待用户故事确认后开发
+
+## Feature: ${project_name}
+
+### Background
+${asLine}
+${wantLine}
+${soThatLine}
+
+### Scenarios
+
+${acceptance_criteria.map((criteria, index) => `
+#### Scenario ${index + 1}: ${criteria.split(',')[0] || criteria}
+Given ${asLine.replace('As a', 'I am a').toLowerCase()}
+And ${wantLine.replace('I want', 'I have').toLowerCase()}
+When ${criteria.toLowerCase()}
+Then ${soThatLine.replace('so that', 'I can').toLowerCase()}
+`).join('\n')}
+
+### Technical Notes
+- **编程语言**：${params.programming_language}
+- **框架**：${params.framework || '标准库'}
+- **架构模式**：${params.architecture_pattern}
+
+### Implementation Guidelines
+1. **前置条件**：用户故事已经通过评审
+2. **开发顺序**：按照验收标准的优先级顺序实现
+3. **测试要求**：每个场景必须有对应的测试用例
+4. **代码审查**：完成后需要进行代码审查
+
+### Dependencies
+- 用户故事评审完成
+- 技术方案确定
+- 开发环境准备就绪
+
+### Definition of Done
+- [ ] 所有验收标准场景实现完成
+- [ ] 单元测试覆盖率达标
+- [ ] 代码审查通过
+- [ ] 文档更新完成
+- [ ] 部署验证通过
+`;
+    });
+}
+// 生成架构文档
+function generateArchitectureDocument(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { project_name, programming_language, framework, architecture_pattern } = params;
+        return `# ${project_name} - Technical Architecture
+
+## 1. 系统概述
+
+### 1.1 项目背景
+${params.project_description}
+
+### 1.2 技术栈
+- **编程语言**：${programming_language}
+- **框架**：${framework || '原生实现'}
+- **架构模式**：${architecture_pattern}
+
+## 2. 架构设计
+
+### 2.1 总体架构
+\`\`\`mermaid
+graph TD
+    A[Presentation Layer] --> B[Application Layer]
+    B --> C[Domain Layer]
+    C --> D[Infrastructure Layer]
+    
+    style A fill:#f9f,stroke:#333
+    style B fill:#bbf,stroke:#333
+    style C fill:#9f9,stroke:#333
+    style D fill:#ff9,stroke:#333
+\`\`\`
+
+### 2.2 模块划分
+
+#### 2.2.1 控制器层 (Controllers)
+- 处理HTTP请求
+- 参数验证
+- 响应格式化
+
+#### 2.2.2 服务层 (Services)
+- 业务逻辑处理
+- 事务管理
+- 领域服务协调
+
+#### 2.2.3 数据访问层 (Repositories)
+- 数据持久化
+- 查询优化
+- 缓存管理
+
+#### 2.2.4 领域模型 (Domain Models)
+- 核心业务实体
+- 业务规则
+- 状态管理
+
+## 3. 技术决策
+
+### 3.1 设计模式应用
+- **Repository Pattern**：数据访问抽象
+- **Service Layer Pattern**：业务逻辑封装
+- **Factory Pattern**：对象创建管理
+- **Strategy Pattern**：算法选择
+
+### 3.2 数据一致性
+- 事务边界定义
+- 并发控制策略
+- 错误处理机制
+
+### 3.3 可测试性设计
+- 依赖注入
+- 接口抽象
+- 测试数据管理
+
+## 4. 开发规范
+
+### 4.1 目录结构
+\`\`\`
+${project_name}/
+├── src/
+│   ├── controllers/     # 控制器层
+│   ├── services/        # 服务层
+│   ├── repositories/    # 数据访问层
+│   ├── models/          # 领域模型
+│   ├── middleware/      # 中间件
+│   └── utils/           # 工具类
+├── tests/
+│   ├── unit/            # 单元测试
+│   ├── integration/     # 集成测试
+│   └── e2e/            # 端到端测试
+├── docs/
+│   ├── api/             # API文档
+│   ├── architecture/    # 架构文档
+│   └── requirements/    # 需求文档
+└── config/              # 配置文件
+\`\`\`
+
+### 4.2 命名规范
+- **文件命名**：kebab-case
+- **类命名**：PascalCase
+- **函数命名**：camelCase
+- **常量命名**：UPPER_SNAKE_CASE
+
+## 5. 部署架构
+
+### 5.1 环境划分
+- **开发环境**：本地开发
+- **测试环境**：功能测试
+- **预生产环境**：集成测试
+- **生产环境**：正式部署
+
+### 5.2 部署策略
+- 容器化部署
+- 蓝绿部署
+- 滚动更新
+- 回滚机制
+
+## 6. 监控与运维
+
+### 6.1 监控指标
+- 系统性能监控
+- 业务指标监控
+- 错误日志监控
+- 用户行为分析
+
+### 6.2 告警机制
+- 阈值告警
+- 异常检测
+- 自动恢复
+- 人工介入
+`;
+    });
+}
+// 生成API文档
+function generateApiDocumentation(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { project_name, programming_language } = params;
+        return `# ${project_name} - API Specification
+
+## 1. API设计原则
+
+### 1.1 RESTful设计规范
+- 使用HTTP方法表达操作语义
+- 使用标准HTTP状态码
+- 使用清晰的URL结构
+- 支持内容协商
+
+### 1.2 版本管理
+- URL版本控制：/api/v1/
+- Header版本控制：Accept: application/vnd.api+json;version=1.0
+
+## 2. 认证与授权
+
+### 2.1 认证方式
+- JWT Token认证
+- OAuth 2.0支持
+- API Key认证
+
+### 2.2 权限控制
+- 基于角色的访问控制(RBAC)
+- 基于资源的访问控制
+- 细粒度权限管理
+
+## 3. 响应格式
+
+### 3.1 标准响应结构
+\`\`\`json
+{
+  "success": true,
+  "data": {},
+  "message": "操作成功",
+  "code": 200,
+  "timestamp": "2024-01-01T00:00:00Z"
+}
+\`\`\`
+
+### 3.2 错误响应结构
+\`\`\`json
+{
+  "success": false,
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "参数验证失败",
+    "details": []
+  },
+  "timestamp": "2024-01-01T00:00:00Z"
+}
+\`\`\`
+
+## 4. 核心API端点
+
+### 4.1 资源操作
+- **GET** /api/v1/{resource} - 获取资源列表
+- **GET** /api/v1/{resource}/{id} - 获取单个资源
+- **POST** /api/v1/{resource} - 创建资源
+- **PUT** /api/v1/{resource}/{id} - 更新资源
+- **DELETE** /api/v1/{resource}/{id} - 删除资源
+
+### 4.2 查询参数
+- **filter**: 过滤条件
+- **sort**: 排序字段
+- **page**: 页码
+- **limit**: 每页数量
+- **fields**: 返回字段
+
+## 5. 错误处理
+
+### 5.1 HTTP状态码
+- **200 OK**: 请求成功
+- **201 Created**: 资源创建成功
+- **400 Bad Request**: 请求参数错误
+- **401 Unauthorized**: 未授权
+- **403 Forbidden**: 权限不足
+- **404 Not Found**: 资源不存在
+- **422 Unprocessable Entity**: 业务逻辑错误
+- **500 Internal Server Error**: 服务器内部错误
+
+### 5.2 错误码规范
+- **格式**: MODULE_ERROR_TYPE
+- **示例**: USER_NOT_FOUND, VALIDATION_FAILED
+
+## 6. 测试API
+
+### 6.1 健康检查
+- **GET** /api/health - 系统健康检查
+
+### 6.2 版本信息
+- **GET** /api/version - 获取API版本信息
+
+## 7. 开发工具
+
+### 7.1 API文档
+- Swagger/OpenAPI 3.0
+- Postman集合
+- 自动化测试脚本
+
+### 7.2 Mock服务
+- 开发环境Mock数据
+- 测试环境隔离
+- 性能测试支持
+`;
+    });
+}
+// 生成测试计划
+function generateTestPlan(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { project_name, programming_language, framework, acceptance_criteria } = params;
+        return `# ${project_name} - 测试策略与计划
+
+## 1. 测试目标
+
+### 1.1 总体目标
+确保${project_name}的功能完整性、性能稳定性和用户体验质量。
+
+### 1.2 具体目标
+- 功能测试覆盖率：≥90%
+- 单元测试覆盖率：≥80%
+- 性能测试：响应时间<200ms
+- 安全测试：通过OWASP Top 10检查
+
+## 2. 测试类型
+
+### 2.1 单元测试
+- **测试框架**：${getTestFramework(programming_language, framework)}
+- **测试范围**：所有业务逻辑、工具函数、数据验证
+- **测试策略**：
+  - 边界值测试
+  - 异常场景测试
+  - 正常流程测试
+
+### 2.2 集成测试
+- **测试范围**：API接口、数据库操作、外部服务集成
+- **测试策略**：
+  - Happy Path测试
+  - 错误处理测试
+  - 数据一致性测试
+
+### 2.3 端到端测试
+- **测试范围**：完整用户流程
+- **测试工具**：${getE2ETestTool(programming_language, framework)}
+- **测试场景**：
+  ${acceptance_criteria.map((criteria) => `- ${criteria}`).join('\n  ')}
+
+### 2.4 性能测试
+- **测试工具**：${getPerformanceTestTool(programming_language, framework)}
+- **测试指标**：
+  - 响应时间
+  - 吞吐量
+  - 并发用户数
+  - 资源使用率
+
+## 3. 测试环境
+
+### 3.1 测试环境配置
+- **开发环境**：本地开发测试
+- **测试环境**：功能测试
+- **预生产环境**：集成测试
+- **性能测试环境**：压力测试
+
+### 3.2 测试数据管理
+- **测试数据生成**：自动化脚本
+- **数据清理**：测试后自动清理
+- **数据版本控制**：测试数据版本管理
+
+## 4. 测试执行计划
+
+### 4.1 测试阶段
+| 阶段 | 时间 | 负责人 | 目标 |
+|------|------|--------|------|
+| 单元测试 | Week 1 | 开发工程师 | 代码质量保证 |
+| 集成测试 | Week 2 | 测试工程师 | 接口功能验证 |
+| 端到端测试 | Week 3 | 测试工程师 | 用户流程验证 |
+| 性能测试 | Week 4 | 性能测试工程师 | 系统性能验证 |
+
+### 4.2 测试用例设计
+- **用例编号规则**：TC-{模块}-{功能}-{序号}
+- **用例模板**：
+  - 前置条件
+  - 测试步骤
+  - 预期结果
+  - 实际结果
+  - 测试数据
+
+## 5. 自动化测试
+
+### 5.1 CI/CD集成
+- **触发条件**：代码提交、合并请求
+- **执行流程**：
+  1. 代码质量检查
+  2. 单元测试执行
+  3. 集成测试执行
+  4. 测试报告生成
+
+### 5.2 测试报告
+- **报告内容**：
+  - 测试执行结果
+  - 覆盖率统计
+  - 性能指标
+  - 缺陷统计
+- **报告格式**：HTML、JSON、XML
+
+## 6. 缺陷管理
+
+### 6.1 缺陷分类
+- **严重程度**：致命、严重、一般、轻微
+- **优先级**：高、中、低
+- **类型**：功能、性能、安全、兼容性
+
+### 6.2 缺陷生命周期
+- **新建** → **确认** → **修复** → **验证** → **关闭**
+
+## 7. 质量门禁
+
+### 7.1 代码质量要求
+- 单元测试覆盖率 ≥ 80%
+- 代码复杂度 ≤ 10
+- 技术债务 ≤ 5%
+
+### 7.2 功能质量要求
+- 所有验收标准测试通过
+- 无致命和严重缺陷
+- 性能指标达标
+
+## 8. 测试工具配置
+
+### 8.1 配置文件示例
+- Jest配置
+- Postman集合
+- 性能测试脚本
+- 自动化测试脚本
+
+## 9. 与AI集成的测试流程
+
+### 9.1 AI辅助测试用例生成
+1. 基于用户故事生成测试用例
+2. AI审查测试用例完整性
+3. 生成边界条件测试
+
+### 9.2 AI辅助测试执行
+1. 智能测试数据生成
+2. 异常场景自动发现
+3. 测试结果智能分析
+`;
+    });
+}
+// 生成项目规范文档
+function generateProjectStandards(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { projectDir, project_name, programming_language, framework, architecture_pattern } = params;
+        const standardsContent = `# ${project_name} - 开发规范
+
+## 1. 技术栈规范
+
+### 1.1 编程语言
+- **语言**：${programming_language}
+- **版本**：${getLanguageVersion(programming_language)}
+- **代码风格**：${getCodeStyleGuide(programming_language)}
+
+### 1.2 框架与库
+- **主框架**：${framework || '标准库'}
+- **依赖管理**：${getPackageManager(programming_language)}
+- **构建工具**：${getBuildTool(programming_language)}
+
+### 1.3 开发工具
+- **IDE**：VS Code (推荐)
+- **代码格式化**：${getFormatterConfig(programming_language)}
+- **代码检查**：${getLinterConfig(programming_language)}
+
+## 2. 项目结构规范
+
+### 2.1 目录结构
+${getDirectoryStructure(programming_language, architecture_pattern)}
+
+### 2.2 文件命名规范
+- **文件命名**：kebab-case
+- **类命名**：PascalCase
+- **函数命名**：camelCase
+- **常量命名**：UPPER_SNAKE_CASE
+
+## 3. 编码规范
+
+### 3.1 代码风格
+${getCodingStandards(programming_language)}
+
+### 3.2 注释规范
+- **函数注释**：包含参数说明、返回值说明、异常说明
+- **类注释**：包含类的作用、使用示例
+- **模块注释**：包含模块功能、依赖关系
+
+### 3.3 错误处理
+- 使用try-catch处理异常
+- 提供有意义的错误信息
+- 记录错误日志
+
+## 4. 测试规范
+
+### 4.1 测试框架
+- **单元测试**：${getTestFramework(programming_language, framework)}
+- **集成测试**：${getIntegrationTestFramework(programming_language)}
+- **端到端测试**：${getE2ETestTool(programming_language, framework)}
+
+### 4.2 测试要求
+- 单元测试覆盖率 ≥ 80%
+- 所有公共API必须有测试
+- 边界条件测试
+- 异常场景测试
+
+## 5. 提交规范
+
+### 5.1 提交消息格式
+\`\`\`
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+\`\`\`
+
+### 5.2 提交类型
+- **feat**: 新功能
+- **fix**: 修复bug
+- **docs**: 文档更新
+- **style**: 代码格式调整
+- **refactor**: 代码重构
+- **test**: 测试相关
+- **chore**: 构建过程或辅助工具的变动
+
+## 6. 文档规范
+
+### 6.1 API文档
+- 使用OpenAPI 3.0规范
+- 包含完整的请求/响应示例
+- 提供错误码说明
+
+### 6.2 README文档
+- 项目简介
+- 安装说明
+- 使用示例
+- 贡献指南
+
+## 7. 部署规范
+
+### 7.1 环境配置
+- 开发环境
+- 测试环境
+- 预生产环境
+- 生产环境
+
+### 7.2 部署流程
+1. 代码审查通过
+2. 自动化测试通过
+3. 构建镜像
+4. 部署到测试环境
+5. 验证测试
+6. 部署到生产环境
+
+## 8. 监控规范
+
+### 8.1 日志规范
+- 使用结构化日志
+- 包含请求ID用于追踪
+- 敏感信息脱敏
+
+### 8.2 指标监控
+- 响应时间
+- 错误率
+- 系统资源使用
+- 业务指标
+`;
+        yield promises_1.default.writeFile(path_1.default.join(projectDir, 'docs', 'development-standards.md'), standardsContent, 'utf-8');
+    });
+}
+// 创建开发工作流文档
+function createDevelopmentWorkflow(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { projectDir, project_name, user_story, acceptance_criteria } = params;
+        const workflowContent = `# ${project_name} - 开发工作流
+
+## 1. 开发流程图
+
+\`\`\`mermaid
+flowchart TD
+    Start([开始]) --> Story[创建用户故事]
+    Story --> ReviewStory{用户故事评审}
+    ReviewStory -->|通过| WriteFeature[编写Feature文件]
+    ReviewStory -->|不通过| ReviseStory[修改用户故事]
+    ReviseStory --> ReviewStory
+    
+    WriteFeature --> ConfirmFeature{Feature确认}
+    ConfirmFeature -->|通过| Design[技术方案设计]
+    ConfirmFeature -->|不通过| ReviseFeature[修改Feature]
+    ReviseFeature --> ConfirmFeature
+    
+    Design --> Implement[代码实现]
+    Implement --> Test[编写测试]
+    Test --> ReviewCode[代码审查]
+    ReviewCode --> DeployTest[部署测试]
+    DeployTest --> Acceptance{验收测试}
+    Acceptance -->|通过| Done([完成])
+    Acceptance -->|不通过| Fix[修复问题]
+    Fix --> Test
+    
+    style Story fill:#e1f5fe
+    style WriteFeature fill:#f3e5f5
+    style Design fill:#e8f5e8
+    style Implement fill:#fff3e0
+    style Done fill:#e8f5e8
+\`\`\`
+
+## 2. 详细步骤说明
+
+### 2.1 第一阶段：需求确认
+1. **用户故事创建**
+   - 使用模板：docs/requirements/user-story.md
+   - 包含完整的As a/I want/So that结构
+   - 列出具体可测试的验收标准
+
+2. **用户故事评审**
+   - 参与人员：产品经理、开发工程师、测试工程师
+   - 检查点：
+     - 故事描述清晰完整
+     - 验收标准具体可测试
+     - 技术可行性评估
+     - 业务价值明确
+
+### 2.2 第二阶段：Feature文件编写
+1. **Feature文档创建**
+   - 基于确认的用户故事
+   - 使用标准Gherkin语法
+   - 每个验收标准对应一个Scenario
+
+2. **Feature评审**
+   - 技术方案验证
+   - 测试用例完整性检查
+   - 开发工作量评估
+
+### 2.3 第三阶段：技术实现
+1. **技术方案设计**
+   - 架构设计文档
+   - 数据库设计
+   - API接口设计
+
+2. **代码实现**
+   - 遵循开发规范
+   - 单元测试编写
+   - 代码审查
+
+3. **测试验证**
+   - 单元测试执行
+   - 集成测试执行
+   - 验收测试执行
+
+## 3. 质量门禁
+
+### 3.1 代码质量要求
+- 单元测试覆盖率 ≥ 80%
+- 代码复杂度 ≤ 10
+- 无致命和严重缺陷
+- 代码审查通过
+
+### 3.2 文档要求
+- 用户故事已评审确认
+- Feature文件已更新
+- API文档已同步
+- 部署文档已准备
+
+## 4. 工具使用指南
+
+### 4.1 开发工具
+- **IDE**: VS Code
+- **版本控制**: Git
+- **构建工具**: ${getBuildTool('typescript')}
+
+### 4.2 测试工具
+- **单元测试**: ${getTestFramework('typescript', 'express')}
+- **API测试**: Postman / REST Client
+- **性能测试**: ${getPerformanceTestTool('typescript', 'express')}
+
+### 4.3 部署工具
+- **容器化**: Docker
+- **CI/CD**: GitHub Actions
+- **监控**: ${getMonitoringTool('typescript')}
+
+## 5. 当前任务状态
+
+### 5.1 当前用户故事
+\`\`\`
+${user_story}
+\`\`\`
+
+### 5.2 验收标准
+${acceptance_criteria.map((criteria, index) => `${index + 1}. ${criteria}`).join('\n')}
+
+### 5.3 下一步行动
+1. [ ] 评审用户故事
+2. [ ] 确认验收标准
+3. [ ] 编写Feature文件
+4. [ ] 技术方案设计
+5. [ ] 代码实现
+6. [ ] 测试验证
+7. [ ] 部署上线
+
+## 6. 注意事项
+
+### 6.1 禁止行为
+- ❌ 未评审用户故事直接开发
+- ❌ 未确认验收标准开始编码
+- ❌ 跳过测试直接部署
+- ❌ 无代码审查合并代码
+
+### 6.2 推荐实践
+- ✅ 小步快跑，频繁提交
+- ✅ 测试驱动开发(TDD)
+- ✅ 持续集成，持续部署
+- ✅ 文档与代码同步更新
+`;
+        yield promises_1.default.writeFile(path_1.default.join(projectDir, 'docs', 'development-workflow.md'), workflowContent, 'utf-8');
+    });
+}
+// 格式化集成结果
+function formatIntegrationResult(params) {
+    const { sessionUuid, projectDir, project_name, generationResult, projectStructure } = params;
+    return `
+# 🎉 集成化项目生成完成
+
+## 📋 项目概览
+- **项目名称**: ${project_name}
+- **会话ID**: ${sessionUuid}
+- **项目目录**: \`${projectDir}\`
+- **生成时间**: ${new Date().toISOString()}
+
+## 📁 项目结构
+\`\`\`
+${project_name}/
+${Object.entries(projectStructure).map(([dir, subdirs]) => `├── ${dir}/\n${subdirs.map(sd => `│   ├── ${sd}/`).join('\n')}`).join('\n')}
+└── ...
+\`\`\`
+
+## 📄 生成的文档
+${generationResult.files.map((f) => `- **${f.type}**: \`${path_1.default.relative(projectDir, f.path)}\``).join('\n')}
+
+## 🎯 开发工作流
+
+### 阶段1: 需求确认 ✅
+- [x] 用户故事文档已生成
+- [x] 验收标准已定义
+- [ ] **待完成**: 用户故事评审会议
+
+### 阶段2: Feature设计 ✅
+- [x] Feature文件模板已创建
+- [ ] **待完成**: Feature文件评审确认
+
+### 阶段3: 技术实现 📋
+- [x] 技术架构文档已生成
+- [x] API规范已定义
+- [x] 测试策略已制定
+- [ ] **待开始**: 代码实现
+
+## 🚀 下一步操作
+
+1. **评审用户故事**
+   \`\`\`bash
+   # 查看用户故事
+   cat docs/requirements/user-story.md
+   \`\`\`
+
+2. **确认验收标准**
+   - 与业务团队确认验收标准
+   - 调整和完善用户故事
+
+3. **开始开发**
+   - 按照development-workflow.md中的流程执行
+   - 遵循development-standards.md中的规范
+
+4. **使用AI辅助开发**
+   - 使用Cursor AI进行代码生成
+   - 遵循.cursor/rules/中的规范
+
+## 📖 重要文件
+- **用户故事**: docs/requirements/user-story.md
+- **Feature文件**: docs/requirements/${(0, common_1.sanitizeFileName)(project_name)}.feature.md
+- **技术架构**: docs/architecture/technical-architecture.md
+- **API文档**: docs/api/api-specification.md
+- **开发工作流**: docs/development-workflow.md
+- **开发规范**: docs/development-standards.md
+
+## ⚠️ 重要提醒
+
+**严格按照以下流程执行开发：**
+1. 📋 **用户故事评审** (必须先完成)
+2. 📝 **Feature文件确认** (用户明确要求后)
+3. 🏗️ **技术方案设计**
+4. 💻 **代码实现**
+5. 🧪 **测试验证**
+6. 🚀 **部署上线`;
+}
+// 工具函数
+function getTestFramework(language, framework) {
+    var _a, _b;
+    const frameworks = {
+        typescript: { express: 'Jest', koa: 'Jest', default: 'Jest' },
+        javascript: { express: 'Jest', koa: 'Jest', default: 'Jest' },
+        python: { django: 'pytest', flask: 'pytest', default: 'unittest' },
+        java: { spring: 'JUnit 5', default: 'JUnit 5' },
+        go: { default: 'testing' }
+    };
+    return ((_a = frameworks[language]) === null || _a === void 0 ? void 0 : _a[framework || 'default']) || ((_b = frameworks[language]) === null || _b === void 0 ? void 0 : _b.default) || 'Unknown';
+}
+function getIntegrationTestFramework(language) {
+    const frameworks = {
+        typescript: 'Supertest',
+        javascript: 'Supertest',
+        python: 'pytest-django',
+        java: 'Spring Boot Test',
+        go: 'httpexpect'
+    };
+    return frameworks[language] || 'Unknown';
+}
+function getE2ETestTool(language, framework) {
+    var _a, _b;
+    const tools = {
+        typescript: { express: 'Cypress', koa: 'Cypress', default: 'Cypress' },
+        javascript: { express: 'Cypress', koa: 'Cypress', default: 'Cypress' },
+        python: { django: 'Selenium', flask: 'Selenium', default: 'Selenium' },
+        java: { spring: 'Selenium', default: 'Selenium' }
+    };
+    return ((_a = tools[language]) === null || _a === void 0 ? void 0 : _a[framework || 'default']) || ((_b = tools[language]) === null || _b === void 0 ? void 0 : _b.default) || 'Selenium';
+}
+function getPerformanceTestTool(language, framework) {
+    var _a, _b;
+    const tools = {
+        typescript: { express: 'Artillery', koa: 'Artillery', default: 'Artillery' },
+        javascript: { express: 'Artillery', koa: 'Artillery', default: 'Artillery' },
+        python: { django: 'Locust', flask: 'Locust', default: 'Locust' },
+        java: { spring: 'JMeter', default: 'JMeter' }
+    };
+    return ((_a = tools[language]) === null || _a === void 0 ? void 0 : _a[framework || 'default']) || ((_b = tools[language]) === null || _b === void 0 ? void 0 : _b.default) || 'JMeter';
+}
+function getLanguageVersion(language) {
+    const versions = {
+        typescript: '5.0+',
+        javascript: 'ES2020+',
+        python: '3.9+',
+        java: '17+',
+        go: '1.20+',
+        csharp: '.NET 6+'
+    };
+    return versions[language] || 'Latest';
+}
+function getCodeStyleGuide(language) {
+    const guides = {
+        typescript: 'ESLint + Prettier',
+        javascript: 'ESLint + Prettier',
+        python: 'PEP 8 + Black',
+        java: 'Google Java Style',
+        go: 'gofmt',
+        csharp: '.NET Code Style'
+    };
+    return guides[language] || 'Standard';
+}
+function getPackageManager(language) {
+    const managers = {
+        typescript: 'npm/yarn/pnpm',
+        javascript: 'npm/yarn/pnpm',
+        python: 'pip/poetry',
+        java: 'Maven/Gradle',
+        go: 'go mod',
+        csharp: 'NuGet'
+    };
+    return managers[language] || 'Standard';
+}
+function getBuildTool(language) {
+    const tools = {
+        typescript: 'tsc',
+        javascript: 'webpack',
+        python: 'poetry/pyproject',
+        java: 'Maven/Gradle',
+        go: 'go build',
+        csharp: 'MSBuild'
+    };
+    return tools[language] || 'Standard';
+}
+function getFormatterConfig(language) {
+    const configs = {
+        typescript: '.prettierrc',
+        javascript: '.prettierrc',
+        python: 'pyproject.toml',
+        java: 'checkstyle.xml',
+        go: 'gofmt'
+    };
+    return configs[language] || 'Standard';
+}
+function getLinterConfig(language) {
+    const configs = {
+        typescript: '.eslintrc.json',
+        javascript: '.eslintrc.json',
+        python: '.flake8',
+        java: 'checkstyle.xml',
+        go: 'golangci-lint'
+    };
+    return configs[language] || 'Standard';
+}
+function getDirectoryStructure(language, architecture) {
+    if (language === 'typescript' && architecture === 'layered') {
+        return `
+project-name/
+├── src/
+│   ├── controllers/     # 控制器层
+│   ├── services/        # 业务逻辑层
+│   ├── repositories/    # 数据访问层
+│   ├── models/          # 数据模型
+│   ├── middleware/      # 中间件
+│   ├── utils/           # 工具函数
+│   └── config/          # 配置
+├── tests/
+│   ├── unit/            # 单元测试
+│   ├── integration/     # 集成测试
+│   └── e2e/            # 端到端测试
+├── docs/                # 项目文档
+└── config/              # 配置文件
+`;
+    }
+    return '标准项目结构';
+}
+function getCodingStandards(language) {
+    const standards = {
+        typescript: '使用TypeScript严格模式，接口优先，类型安全',
+        javascript: '使用ES6+特性，避免var，使用const/let',
+        python: '遵循PEP 8规范，使用类型注解',
+        java: '遵循Google Java Style，使用Optional处理空值',
+        go: '使用gofmt格式化，遵循Effective Go'
+    };
+    return standards[language] || '遵循语言最佳实践';
+}
+function getMonitoringTool(language) {
+    const tools = {
+        typescript: 'Prometheus + Grafana',
+        javascript: 'Prometheus + Grafana',
+        python: 'Prometheus + Grafana',
+        java: 'Micrometer + Prometheus',
+        go: 'Prometheus + Grafana'
+    };
+    return tools[language] || 'Standard monitoring';
+}
+// 生成代码模板
+function generateCodeTemplates(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { programming_language, framework, project_name } = params;
+        const templates = [];
+        if (programming_language === 'typescript') {
+            templates.push({
+                filename: 'controllers/index.ts',
+                content: `import { Router } from 'express';
+import { healthCheck } from './health.controller';
+
+const router = Router();
+
+router.get('/health', healthCheck);
+
+export default router;`
+            }, {
+                filename: 'controllers/health.controller.ts',
+                content: `import { Request, Response } from 'express';
+
+export const healthCheck = async (req: Request, res: Response) => {
+  try {
+    res.json({
+      status: 'OK',
+      timestamp: new Date().toISOString(),
+      service: '${project_name}'
+    });
+  } catch (error) {
+    res.status(500).json({
+      status: 'ERROR',
+      message: 'Health check failed'
+    });
+  }
+};`
+            }, {
+                filename: 'services/index.ts',
+                content: `// Service layer exports
+export * from './base.service';`
+            }, {
+                filename: 'models/index.ts',
+                content: `// Model definitions
+export interface BaseModel {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}`
+            });
+        }
+        return templates;
+    });
+}