openmatrix 0.2.22 → 0.2.24

package/dist/test/generator.js

@@ -163,31 +163,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 +182,245 @@ 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 mockDependencies = {};`,
+                    act: `// Act - 执行服务方法
+    const result = await ${exportName}(params);`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        'expect(result).toHaveProperty(\'data\');',
+                        'expect(result.error).toBeUndefined();'
+                    ]
+                },
+                {
+                    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';`,
+                    act: `// Act
+    const result = ${exportName}(input);`,
+                    assert: [
+                        'expect(result).toBeDefined();',
+                        'expect(typeof result).toBe(\'string\');'
+                    ]
+                },
+                {
+                    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\' };`,
+                    act: `// Act - 执行 API 调用
+    const response = await ${exportName}(request);`,
+                    assert: [
+                        'expect(response).toBeDefined();',
+                        'expect(response.status).toBe(200);',
+                        'expect(response.data).toBeDefined();'
+                    ]
+                },
+                {
+                    name: 'should handle 404 not found',
+                    arrange: `// Arrange - 准备不存在的资源请求
+    const request = { method: \'GET\', path: \'/api/nonexistent\' };`,
+                    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 };`,
+                    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\' };
+    // Mock network failure`,
+                    act: `// Act - 处理错误响应`,
+                    assert: [
+                        `await expect(${exportName}(request)).resolves.toBeDefined();`,
+                        '// 应该返回错误对象而非抛出异常'
+                    ]
+                }
+            ];
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/deploy.md

@@ -91,6 +91,80 @@ cat requirements.txt pyproject.toml 2>/dev/null
 
 ---
 
+## Step 2.1: 检测并优化依赖源
+
+检测项目使用的包管理器和镜像源，如果是国外慢源则建议替换为国内镜像：
+
+```bash
+# npm/yarn/pnpm 源
+npm config get registry 2>/dev/null
+cat .npmrc 2>/dev/null
+cat .yarnrc 2>/dev/null
+cat .yarnrc.yml 2>/dev/null
+
+# pip 源
+cat pip.conf 2>/dev/null
+pip config get global.index-url 2>/dev/null
+
+# Docker 镜像源
+cat /etc/docker/daemon.json 2>/dev/null
+cat ~/.docker/daemon.json 2>/dev/null
+
+# Go 代理
+go env GOPROXY 2>/dev/null
+
+# Rust 源
+cat ~/.cargo/config.toml 2>/dev/null
+
+# Gradle/Maven 源
+cat build.gradle 2>/dev/null | grep -i "repositories" -A 5
+cat pom.xml 2>/dev/null | grep -i "mirror" -A 5
+```
+
+**AI 分析源速度，如果检测到国外源，建议替换：**
+
+| 包管理器 | 国外源 | 国内镜像 |
+|---------|--------|---------|
+| npm/yarn/pnpm | registry.npmjs.org | https://registry.npmmirror.com |
+| pip | pypi.org | https://pypi.tuna.tsinghua.edu.cn/simple |
+| Docker | docker.io | mirror.ccs.tencentyun.com |
+| Go | proxy.golang.org | https://goproxy.cn,direct |
+| Rust/Cargo | crates.io | https://rsproxy.cn/crates.io-index |
+| Gradle/Maven | repo.maven.apache.org | https://maven.aliyun.com/repository/public |
+
+**如果检测到慢源，输出建议并询问：**
+
+```
+AskUserQuestion:
+  header: "镜像源"
+  question: "检测到 npm 使用官方源（registry.npmjs.org），国内访问较慢。是否切换到国内镜像？"
+
+  options:
+  - label: "切换到淘宝镜像 (推荐)"
+    description: "npmmirror.com，国内速度快，同步延迟 < 10 分钟"
+  - label: "保持不变"
+    description: "当前源可用，不需要切换"
+  - label: "使用其他镜像"
+    description: "指定自定义镜像地址"
+```
+
+**用户确认后执行切换：**
+```bash
+# npm
+npm config set registry https://registry.npmmirror.com
+
+# pip
+pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
+
+# Go
+go env -w GOPROXY=https://goproxy.cn,direct
+
+# Dockerfile 中的 apt 源（如果有）
+# AI 读取 Dockerfile，将 archive.ubuntu.com 替换为 mirrors.aliyun.com
+```
+
+---
+
 ## Step 3: 检测系统环境
 
 ```bash
@@ -181,6 +255,40 @@ AskUserQuestion:
 
 ---
 
+## Step 6.1: 生成部署任务清单
+
+根据前面的分析和用户选择，将所有部署步骤写入 TodoWrite，逐条执行：
+
+**示例（Docker 本地部署 + 源优化 + 脚本生成）：**
+
+```typescript
+TodoWrite({
+  todos: [
+    { content: "切换 npm 源到淘宝镜像", activeForm: "正在切换 npm 镜像源", status: "pending" },
+    { content: "构建 Docker 镜像", activeForm: "正在构建 Docker 镜像", status: "pending" },
+    { content: "启动容器", activeForm: "正在启动容器", status: "pending" },
+    { content: "验证部署：容器状态", activeForm: "正在检查容器状态", status: "pending" },
+    { content: "验证部署：端口监听", activeForm: "正在检查端口", status: "pending" },
+    { content: "验证部署：HTTP 连通", activeForm: "正在验证 HTTP 连通性", status: "pending" },
+    { content: "生成 Taskfile.yml 一键脚本", activeForm: "正在生成一键脚本", status: "pending" },
+    { content: "保存部署配置", activeForm: "正在保存部署配置", status: "pending" }
+  ]
+})
+```
+
+**任务清单根据实际情况动态生成：**
+- 需要切换源 → 加入源切换任务
+- 需要生成 Dockerfile → 加入生成任务
+- 多服务 → 每个服务一条任务
+- 选择生成脚本 → 加入脚本生成任务
+
+**执行规则：**
+- 每次只执行一条，完成后立即标记 completed
+- 失败时停止，输出错误信息
+- 用户可以看到整体进度
+
+---
+
 ## Step 7: 执行部署
 
 根据用户选择，AI 执行对应命令：

package/skills/test.md

@@ -392,6 +392,35 @@ ${uiComponents.map(c => `
 
 ## Step 7: 自动验证测试（循环机制）
 
+<LOOP_ENFORCEMENT>
+**此步骤是验证循环，必须执行直到验证通过或达到最大重试次数。**
+
+❌ **禁止在验证失败时停止** — 即使 Agent 返回了大段输出，也必须继续循环
+❌ **禁止询问"是否继续验证"** — 自动执行验证，无需用户确认
+❌ **禁止输出"让我知道是否..."后停止** — 继续执行验证循环
+❌ **禁止因为上下文压缩而忘记重试次数** — 使用 TodoWrite 持久化 retryCount
+
+**retryCount 持久化机制（防止上下文压缩丢失状态）:**
+
+验证循环开始时，使用 TodoWrite 记录状态：
+```
+TodoWrite([
+  { content: "验证测试（第 N 次）", activeForm: "正在验证测试（第 N 次）", status: "in_progress" }
+])
+```
+
+每次验证失败后：
+1. 更新 TodoWrite 的 retryCount（N → N+1）
+2. 检查是否达到最大次数（>= 3）
+3. 未达到 → 自动回到 Step 6 重新生成
+4. 已达到 → 暂停并报告问题
+
+**循环铁律：**
+- retryCount 从 TodoWrite 读取，不依赖上下文记忆
+- 验证失败必须自动循环，不得跳过
+- 最大重试 3 次，超过必须暂停
+</LOOP_ENFORCEMENT>
+
 **⛔ 自动验证流程 - 无需用户手动确认**
 
 ### 7.1 执行验证命令（自动判断结果）
@@ -414,15 +443,15 @@ fi
 **验证失败时自动处理：**
 
 ```
-验证失败 → retryCount + 1 → 检查重试次数 →
+验证失败 → TodoWrite 更新 retryCount → 检查重试次数 →
   ├─ < 3 次 → 自动回到 Step 6 重新生成（带失败信息）
   └─ >= 3 次 → 暂停，报告问题，可能是测试框架配置问题
 ```
 
-**重试计数器更新：**
-- Skill 内部维护 `retryCount` 变量
-- 每次验证失败 +1
-- 验证通过后重置为 0
+**重试计数器持久化：**
+- 使用 TodoWrite 记录 retryCount
+- 每次验证失败后更新 TodoWrite（retryCount + 1）
+- 验证通过后更新 TodoWrite 为 completed
 
 ### 7.3 自动循环回生成步骤