openmatrix 0.2.23 → 0.2.25

package/dist/test/generator.js

@@ -143,10 +143,25 @@ function generateTestContent(source, config) {
     // 导入语句
     const importPath = source.path.replace(/\.(ts|tsx)$/, '').replace(/\.(js|jsx)$/, '');
     const imports = generateImports(source.exports, importPath, usesTypeScript);
+    // 需要生命周期钩子的文件类型
+    const needsLifecycle = ['service', 'util', 'api', 'module'].includes(source.fileType);
+    // 需要 vi 导入的测试类型（使用 Mock 验证副作用）
+    const needsViImport = ['service', 'util', 'api', 'component', 'module'].includes(source.fileType);
     // 测试块
     const testBlocks = source.exports.map(exp => generateTestBlock(exp, framework, usesDescribeIt, source.fileType));
     // 组装内容
-    const content = `${imports}\n\n${testBlocks.join('\n\n')}\n`;
+    const content = `${needsViImport ? `import { vi } from 'vitest';\n` : ''}${imports}
+${needsLifecycle ? `
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+` : ''}
+${testBlocks.join('\n\n')}
+`;
     return content;
 }
 /**
@@ -163,31 +178,16 @@ function generateImports(exports, importPath, usesTypeScript) {
         : `const { ${exports.join(', ')} } = require('../../${importPath}');`;
 }
 /**
- * 生成测试块
+ * 生成测试块 - 根据文件类型生成有意义的业务测试
  */
 function generateTestBlock(exportName, framework, usesDescribeIt, fileType) {
     const useDescribe = usesDescribeIt ?? true;
-    const describeOrTest = usesDescribeIt ? 'describe' : 'test';
     if (useDescribe) {
+        // 根据文件类型生成不同的测试场景
+        const testCases = generateBusinessTestCases(exportName, fileType);
+        const testBlocks = testCases.map(tc => generateTestCaseBlock(tc, exportName));
         return `describe('${getDescribeTitle(exportName, fileType)}', () => {
-  it('should work correctly', () => {
-    // Arrange
-    const input = {};
-
-    // Act
-    const result = ${exportName}(input);
-
-    // Assert
-    expect(result).toBeDefined();
-  });
-
-  it('should handle edge cases', () => {
-    // Arrange
-    const input = null;
-
-    // Act & Assert
-    expect(() => ${exportName}(input)).not.toThrow();
-  });
+${testBlocks.join('\n\n')}
 });`;
     }
     else {
@@ -197,6 +197,258 @@ function generateTestBlock(exportName, framework, usesDescribeIt, fileType) {
 });`;
     }
 }
+/**
+ * 根据文件类型生成业务测试用例
+ */
+function generateBusinessTestCases(exportName, fileType) {
+    switch (fileType) {
+        case 'service':
+            return [
+                {
+                    name: 'should return valid result on successful execution',
+                    arrange: `// Arrange - 准备有效的输入参数
+    const params = { id: 'test-id', data: {} };
+    const spy = vi.spyOn({ ${exportName} }, '${exportName}');`,
+                    act: `// Act - 执行服务方法
+    const result = await ${exportName}(params);`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        'expect(result).toHaveProperty(\'data\');',
+                        'expect(result.error).toBeUndefined();',
+                        `expect(spy).toHaveBeenCalledWith(params);`,
+                        'expect(spy).toHaveBeenCalledTimes(1);'
+                    ]
+                },
+                {
+                    name: 'should handle invalid input gracefully',
+                    arrange: `// Arrange - 准备无效输入
+    const invalidParams = { id: null, data: undefined };`,
+                    act: `// Act - 使用无效参数调用
+    const result = await ${exportName}(invalidParams);`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        'expect(result).toHaveProperty(\'error\');'
+                    ]
+                },
+                {
+                    name: 'should handle empty parameters',
+                    arrange: `// Arrange - 空参数测试`,
+                    act: `// Act & Assert - 验证空参数处理
+    const result = await ${exportName}({});`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        '// 应该返回默认值或错误信息，而非崩溃'
+                    ]
+                },
+                {
+                    name: 'should handle missing required fields',
+                    arrange: `// Arrange - 缺少必填字段`,
+                    act: `// Act`,
+                    assert: [
+                        `expect(() => ${exportName}(null)).not.toThrow();`,
+                        'expect(() => ${exportName}(undefined)).not.toThrow();'
+                    ]
+                }
+            ];
+        case 'util':
+            return [
+                {
+                    name: 'should process valid input correctly',
+                    arrange: `// Arrange - 准备有效输入
+    const input = 'test-value';
+    const expected = 'expected-result';
+    const spy = vi.spyOn({ ${exportName} }, '${exportName}');`,
+                    act: `// Act
+    const result = ${exportName}(input);`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        'expect(typeof result).toBe(\'string\');',
+                        `expect(spy).toHaveBeenCalledWith(input);`,
+                        'expect(spy).toHaveBeenCalledTimes(1);'
+                    ]
+                },
+                {
+                    name: 'should handle null input',
+                    arrange: `// Arrange - null 输入`,
+                    act: `// Act & Assert`,
+                    assert: [
+                        `expect(() => ${exportName}(null)).not.toThrow();`,
+                        'const result = ${exportName}(null);',
+                        'expect(result).toBeDefined();'
+                    ]
+                },
+                {
+                    name: 'should handle empty string input',
+                    arrange: `// Arrange - 空字符串输入`,
+                    act: `// Act
+    const result = ${exportName}('');`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        '// 验证空字符串的预期行为'
+                    ]
+                },
+                {
+                    name: 'should handle various input types',
+                    arrange: `// Arrange - 多种输入类型测试`,
+                    act: `// Act - 测试不同类型`,
+                    assert: [
+                        'const numResult = ${exportName}(123);',
+                        'const boolResult = ${exportName}(true);',
+                        'const objResult = ${exportName}({ key: \'value\' });',
+                        'expect(numResult).toBeDefined();',
+                        'expect(boolResult).toBeDefined();',
+                        'expect(objResult).toBeDefined();'
+                    ]
+                }
+            ];
+        case 'component':
+            return [
+                {
+                    name: 'should render without crashing',
+                    arrange: `// Arrange - 准备组件 props
+    const props = { title: \'Test Title\', onClick: vi.fn() };`,
+                    act: `// Act - 渲染组件
+    const { container } = render(<${exportName} {...props} />);`,
+                    assert: [
+                        'expect(container).toBeDefined();',
+                        'expect(container.firstChild).toBeInTheDocument();'
+                    ]
+                },
+                {
+                    name: 'should handle user interaction',
+                    arrange: `// Arrange - 准备交互测试
+    const handleClick = vi.fn();
+    const props = { onClick: handleClick };`,
+                    act: `// Act - 模拟用户点击
+    const { getByRole } = render(<${exportName} {...props} />);
+    fireEvent.click(getByRole(\'button\'));`,
+                    assert: [
+                        'expect(handleClick).toHaveBeenCalledTimes(1);'
+                    ]
+                },
+                {
+                    name: 'should display correct content with props',
+                    arrange: `// Arrange - 准备显示内容测试
+    const testContent = \'Hello World\';
+    const props = { children: testContent };`,
+                    act: `// Act - 渲染并检查内容
+    const { getByText } = render(<${exportName} {...props} />);`,
+                    assert: [
+                        'expect(getByText(testContent)).toBeInTheDocument();'
+                    ]
+                },
+                {
+                    name: 'should handle missing optional props',
+                    arrange: `// Arrange - 无可选 props`,
+                    act: `// Act - 仅传递必需 props
+    const { container } = render(<${exportName} />);`,
+                    assert: [
+                        'expect(container).toBeDefined();',
+                        '// 组件应使用默认值正常渲染'
+                    ]
+                }
+            ];
+        case 'api':
+            return [
+                {
+                    name: 'should return success response for valid request',
+                    arrange: `// Arrange - 准备有效的 API 请求参数
+    const request = { method: \'GET\', path: \'/api/test\' };
+    const mockResponse = { status: 200, data: { id: 1 } };
+    const spy = vi.spyOn({ ${exportName} }, '${exportName}').mockResolvedValue(mockResponse);`,
+                    act: `// Act - 执行 API 调用
+    const response = await ${exportName}(request);`,
+                    assert: [
+                        'expect(response).toBeDefined();',
+                        'expect(response.status).toBe(200);',
+                        'expect(response.data).toBeDefined();',
+                        `expect(spy).toHaveBeenCalledWith(request);`,
+                        'expect(spy).toHaveBeenCalledTimes(1);'
+                    ]
+                },
+                {
+                    name: 'should handle 404 not found',
+                    arrange: `// Arrange - 准备不存在的资源请求
+    const request = { method: \'GET\', path: \'/api/nonexistent\' };
+    const mockResponse = { status: 404, error: \'Not Found\' };
+    vi.spyOn({ ${exportName} }, '${exportName}').mockResolvedValue(mockResponse);`,
+                    act: `// Act - 请求不存在的资源
+    const response = await ${exportName}(request);`,
+                    assert: [
+                        'expect(response.status).toBe(404);',
+                        'expect(response.error).toBeDefined();'
+                    ]
+                },
+                {
+                    name: 'should handle invalid request body',
+                    arrange: `// Arrange - 准备无效的请求体
+    const request = { method: \'POST\', path: \'/api/test\', body: null };
+    const mockResponse = { status: 400, error: \'invalid request\' };
+    vi.spyOn({ ${exportName} }, '${exportName}').mockResolvedValue(mockResponse);`,
+                    act: `// Act - 发送无效请求
+    const response = await ${exportName}(request);`,
+                    assert: [
+                        'expect(response.status).toBe(400);',
+                        'expect(response.error).toContain(\'invalid\');'
+                    ]
+                },
+                {
+                    name: 'should handle network errors gracefully',
+                    arrange: `// Arrange - 模拟网络错误
+    const request = { method: \'GET\', path: \'/api/error\' };
+    vi.spyOn({ ${exportName} }, '${exportName}').mockRejectedValue(new Error('Network Error'));`,
+                    act: `// Act - 处理错误响应`,
+                    assert: [
+                        `await expect(${exportName}(request)).rejects.toThrow('Network Error');`,
+                        '// 应该返回错误对象而非抛出异常'
+                    ]
+                }
+            ];
+        default:
+            // 通用模块测试
+            return [
+                {
+                    name: 'should return defined result for valid input',
+                    arrange: `// Arrange - 准备有效输入
+    const input = {};`,
+                    act: `// Act - 执行函数
+    const result = ${exportName}(input);`,
+                    assert: [
+                        'expect(result).toBeDefined();'
+                    ]
+                },
+                {
+                    name: 'should handle null input',
+                    arrange: `// Arrange - null 输入`,
+                    act: `// Act`,
+                    assert: [
+                        `expect(() => ${exportName}(null)).not.toThrow();`
+                    ]
+                },
+                {
+                    name: 'should handle undefined input',
+                    arrange: `// Arrange - undefined 输入`,
+                    act: `// Act`,
+                    assert: [
+                        `expect(() => ${exportName}(undefined)).not.toThrow();`
+                    ]
+                }
+            ];
+    }
+}
+/**
+ * 生成单个测试用例块
+ */
+function generateTestCaseBlock(tc, exportName) {
+    const indent = '  ';
+    const actIndent = tc.act.includes('\n') ? indent : indent + '  ';
+    const assertLines = tc.assert.map(a => `${indent}  ${a}`).join('\n');
+    return `${indent}it('${tc.name}', () => {
+${indent}  ${tc.arrange}
+${actIndent}${tc.act}
+${assertLines}
+${indent}});`;
+}
 /**
  * 获取 describe 标题
  */

package/dist/types/index.d.ts

@@ -228,8 +228,10 @@ export interface ParsedTask {
     title: string;
     description: string;
     goals: string[];
-    /** 每个 goal 的类型标注 (由 AI 在提取时标注)，与 goals 数组一一对应 */
+    /** 每个 goal 的类型标注 (AI 必填)，与 goals 数组一一对应 */
     goalTypes?: GoalType[];
+    /** 每个 goal 的复杂度标注 (AI 必填)，与 goals 数组一一对应 */
+    goalComplexity?: ('low' | 'medium' | 'high')[];
     constraints: string[];
     deliverables: string[];
     rawContent: string;

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "openmatrix",
-  "version": "0.2.23",
-  "description": "AI Agent task orchestration system with Claude Code Skills integration",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "openmatrix": "dist/cli/index.js"
-  },
-  "files": [
-    "dist",
-    "skills",
-    "scripts",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/cli/index.ts",
-    "test": "vitest",
-    "lint": "eslint src --ext .ts",
-    "typecheck": "tsc --noEmit",
-    "postinstall": "node scripts/install-skills.js"
-  },
-  "keywords": [
-    "claude",
-    "claude-code",
-    "ai-agent",
-    "task-orchestration",
-    "automation",
-    "multi-agent"
-  ],
-  "author": "",
-  "license": "MIT",
-  "type": "commonjs",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bigfish1913/openmatrix.git"
-  },
-  "homepage": "https://github.com/bigfish1913/openmatrix#readme",
-  "bugs": {
-    "url": "https://github.com/bigfish1913/openmatrix/issues"
-  },
-  "dependencies": {
-    "chalk": "^5.6.2",
-    "chokidar": "^5.0.0",
-    "commander": "^14.0.3",
-    "winston": "^3.19.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.58.1",
-    "@typescript-eslint/parser": "^8.58.1",
-    "@vitest/coverage-v8": "^1.6.1",
-    "eslint": "^10.2.0",
-    "typescript": "^5.3.3",
-    "vitest": "^1.6.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "openmatrix",
+  "version": "0.2.25",
+  "description": "AI Agent task orchestration system with Claude Code Skills integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "openmatrix": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "scripts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/index.ts",
+    "test": "vitest",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "postinstall": "node scripts/install-skills.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai-agent",
+    "task-orchestration",
+    "automation",
+    "multi-agent"
+  ],
+  "author": "",
+  "license": "MIT",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bigfish1913/openmatrix.git"
+  },
+  "homepage": "https://github.com/bigfish1913/openmatrix#readme",
+  "bugs": {
+    "url": "https://github.com/bigfish1913/openmatrix/issues"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "winston": "^3.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.58.1",
+    "@typescript-eslint/parser": "^8.58.1",
+    "@vitest/coverage-v8": "^1.6.1",
+    "eslint": "^10.2.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}