@dommaker/harness 0.13.0 → 0.13.2

package/src/__tests__/error-classifier.test.ts

@@ -0,0 +1,304 @@
+/**
+ * ErrorClassifier 测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { ErrorClassifier } from '../failure/classifier';
+import { ErrorType, FailureLevel } from '../failure/types';
+
+describe('ErrorClassifier', () => {
+  const classifier = new ErrorClassifier();
+
+  describe('classify', () => {
+    it('应该分类测试失败错误', () => {
+      const error = new Error('test failure occurred');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.TEST_FAILED);
+      expect(result.level).toBe(FailureLevel.L1);
+      expect(result.matchedRule).toBeDefined();
+    });
+
+    it('应该分类断言错误', () => {
+      const error = new Error('Assertion failed: expected true');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.TEST_FAILED);
+    });
+
+    it('应该分类门禁错误', () => {
+      const error = new Error('Gate failed: constraint violation');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.GATE_FAILED);
+      expect(result.level).toBe(FailureLevel.L2);
+    });
+
+    it('应该分类超时错误', () => {
+      const error = new Error('Timeout: operation timed out after 5000ms');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.TIMEOUT);
+      expect(result.level).toBe(FailureLevel.L1);
+    });
+
+    it('应该分类网络错误', () => {
+      const error = new Error('Network error: ECONNREFUSED');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.NETWORK_ERROR);
+    });
+
+    it('应该分类依赖阻塞错误', () => {
+      const error = new Error('dependency blocked: upstream failed');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.DEPENDENCY_BLOCKED);
+      expect(result.level).toBe(FailureLevel.L3);
+    });
+
+    it('应该分类上下文溢出', () => {
+      const error = new Error('context overflow: token limit exceeded');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.CONTEXT_OVERFLOW);
+      expect(result.level).toBe(FailureLevel.L2);
+    });
+
+    it('应该分类验证错误', () => {
+      const error = new Error('validation error: invalid schema');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.VALIDATION_ERROR);
+    });
+
+    it('未知错误应该返回 UNKNOWN', () => {
+      const error = new Error('某某未知错误某');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.UNKNOWN);
+    });
+
+    it('应该保留原始错误', () => {
+      const error = new Error('test error');
+      const result = classifier.classify(error);
+
+      expect(result.originalError).toBe(error);
+    });
+  });
+
+  describe('自定义规则', () => {
+    it('应该支持自定义分类规则', () => {
+      const customClassifier = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.VALIDATION_ERROR,
+            keywords: ['custom-error'],
+            level: FailureLevel.L3,
+          },
+        ],
+      });
+
+      const error = new Error('custom-error: something went wrong');
+      const result = customClassifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.VALIDATION_ERROR);
+      expect(result.level).toBe(FailureLevel.L3);
+    });
+
+    it('自定义规则优先级高于默认规则', () => {
+      const customClassifier = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.GATE_FAILED,
+            keywords: ['test'],
+            level: FailureLevel.L4,
+          },
+        ],
+      });
+
+      const error = new Error('test failed');
+      const result = customClassifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.GATE_FAILED);
+    });
+  });
+
+  describe('自定义等级映射', () => {
+    it('应该支持自定义等级映射', () => {
+      const customClassifier = new ErrorClassifier({
+        levelMapping: {
+          [ErrorType.UNKNOWN]: FailureLevel.L4,
+        },
+      });
+
+      const error = new Error('某某未知错误某');
+      const result = customClassifier.classify(error);
+
+      expect(result.level).toBe(FailureLevel.L4);
+    });
+  });
+
+  describe('大小写不敏感', () => {
+    it('应该忽略大小写', () => {
+      const error1 = new Error('TEST FAILURE');
+      const error2 = new Error('test failure');
+      const error3 = new Error('Test Failure');
+
+      const result1 = classifier.classify(error1);
+      const result2 = classifier.classify(error2);
+      const result3 = classifier.classify(error3);
+
+      expect(result1.type).toBe(ErrorType.TEST_FAILED);
+      expect(result2.type).toBe(ErrorType.TEST_FAILED);
+      expect(result3.type).toBe(ErrorType.TEST_FAILED);
+    });
+  });
+
+  describe('Agent 错误', () => {
+    it('应该分类 Agent 错误', () => {
+      const error = new Error('agent error: rate limit exceeded');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.AGENT_ERROR);
+    });
+
+    it('应该分类 quota 错误', () => {
+      const error = new Error('model error: quota exceeded');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.AGENT_ERROR);
+    });
+  });
+
+  describe('工具错误', () => {
+    it('应该分类工具错误', () => {
+      const error = new Error('tool error: executor failed');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.TOOL_ERROR);
+    });
+
+    it('应该分类 skill 错误', () => {
+      const error = new Error('skill error: execution failed');
+      const result = classifier.classify(error);
+
+      expect(result.type).toBe(ErrorType.TOOL_ERROR);
+    });
+  });
+
+  describe('其他方法', () => {
+    it('getLevel 应该返回等级', () => {
+      const level = classifier.getLevel(ErrorType.TEST_FAILED);
+      expect(level).toBe(FailureLevel.L1);
+    });
+
+    it('getLevel 未知类型应该返回默认', () => {
+      const level = classifier.getLevel('unknown_type' as any);
+      expect(level).toBe(FailureLevel.L2);
+    });
+
+    it('addRule 应该添加规则', () => {
+      const c = new ErrorClassifier();
+      c.addRule({
+        type: ErrorType.VALIDATION_ERROR,
+        keywords: ['my-custom-error'],
+        level: FailureLevel.L4,
+      });
+
+      const error = new Error('my-custom-error occurred');
+      const result = c.classify(error);
+      expect(result.type).toBe(ErrorType.VALIDATION_ERROR);
+      expect(result.level).toBe(FailureLevel.L4);
+    });
+
+    it('getRules 应该返回所有规则', () => {
+      const c = new ErrorClassifier();
+      const rules = c.getRules();
+      expect(Array.isArray(rules)).toBe(true);
+      expect(rules.length).toBeGreaterThan(0);
+    });
+
+    it('应该支持 pattern 匹配', () => {
+      const c = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.VALIDATION_ERROR,
+            patterns: [/error-code-\d+/],
+            level: FailureLevel.L3,
+          },
+        ],
+      });
+
+      const error = new Error('error-code-500 occurred');
+      const result = c.classify(error);
+      expect(result.type).toBe(ErrorType.VALIDATION_ERROR);
+    });
+
+    it('应该处理没有 keywords 和 patterns 的规则', () => {
+      const c = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.VALIDATION_ERROR,
+            // no keywords or patterns
+          },
+        ],
+      });
+
+      const error = new Error('unknown error');
+      const result = c.classify(error);
+      // 规则没有匹配条件，不会匹配
+      expect(result.type).not.toBe(ErrorType.VALIDATION_ERROR);
+    });
+
+    it('应该支持空 keywords 数组', () => {
+      const c = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.VALIDATION_ERROR,
+            keywords: [],
+          },
+        ],
+      });
+
+      const error = new Error('unknown error');
+      const result = c.classify(error);
+      expect(result.type).not.toBe(ErrorType.VALIDATION_ERROR);
+    });
+
+    it('应该支持空 patterns 数组', () => {
+      const c = new ErrorClassifier({
+        rules: [
+          {
+            type: ErrorType.VALIDATION_ERROR,
+            patterns: [],
+          },
+        ],
+      });
+
+      const error = new Error('unknown error');
+      const result = c.classify(error);
+      expect(result.type).not.toBe(ErrorType.VALIDATION_ERROR);
+    });
+  });
+
+  describe('快速函数', () => {
+    it('classifyError 应该快速分类', () => {
+      const { classifyError } = require('../failure/classifier');
+      const type = classifyError(new Error('test failed'));
+      expect(type).toBe(ErrorType.TEST_FAILED);
+    });
+
+    it('getFailureLevel 应该快速获取等级', () => {
+      const { getFailureLevel } = require('../failure/classifier');
+      const level = getFailureLevel(ErrorType.TEST_FAILED);
+      expect(level).toBe(FailureLevel.L1);
+    });
+
+    it('createErrorClassifier 应该创建实例', () => {
+      const { createErrorClassifier } = require('../failure/classifier');
+      const c = createErrorClassifier();
+      expect(c).toBeInstanceOf(ErrorClassifier);
+    });
+  });
+});

package/src/__tests__/exec.test.ts

@@ -0,0 +1,83 @@
+/**
+ * exec 工具测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { runCommand, isCommandAvailable, normalizeTriggers, delay } from '../utils/exec';
+
+describe('exec utils', () => {
+  describe('runCommand', () => {
+    it('应该执行命令并返回 stdout', async () => {
+      const result = await runCommand('echo hello');
+      expect(result).toBe('hello');
+    });
+
+    it('不存在的命令应该返回空字符串', async () => {
+      const result = await runCommand('nonexistent_command_xyz');
+      expect(result).toBe('');
+    });
+
+    it('应该支持 cwd 参数', async () => {
+      const result = await runCommand('pwd', '/tmp');
+      expect(result).toContain('tmp');
+    });
+
+    it('多行输出应该保留换行', async () => {
+      const result = await runCommand('echo -e "line1\\nline2"');
+      expect(result).toContain('line1');
+      expect(result).toContain('line2');
+    });
+  });
+
+  describe('isCommandAvailable', () => {
+    it('存在的命令应该返回 true', async () => {
+      const result = await isCommandAvailable('ls');
+      expect(result).toBe(true);
+    });
+
+    it('不存在的命令应该返回 false', async () => {
+      const result = await isCommandAvailable('nonexistent_command_xyz');
+      expect(result).toBe(false);
+    });
+
+    it('常见命令应该可用', async () => {
+      expect(await isCommandAvailable('cat')).toBe(true);
+      expect(await isCommandAvailable('grep')).toBe(true);
+    });
+  });
+
+  describe('normalizeTriggers', () => {
+    it('应该返回 fallback 当值为 null', () => {
+      const result = normalizeTriggers(null, ['default']);
+      expect(result).toEqual(['default']);
+    });
+
+    it('应该返回 fallback 当值为 undefined', () => {
+      const result = normalizeTriggers(undefined, ['default']);
+      expect(result).toEqual(['default']);
+    });
+
+    it('应该将单值包装为数组', () => {
+      const result = normalizeTriggers('single');
+      expect(result).toEqual(['single']);
+    });
+
+    it('应该直接返回数组', () => {
+      const result = normalizeTriggers(['a', 'b']);
+      expect(result).toEqual(['a', 'b']);
+    });
+
+    it('应该使用空数组作为默认 fallback', () => {
+      const result = normalizeTriggers(undefined);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('delay', () => {
+    it('应该延迟指定时间', async () => {
+      const start = Date.now();
+      await delay(10);
+      expect(Date.now() - start).toBeGreaterThanOrEqual(8);
+    });
+  });
+});

package/src/__tests__/extend-exceptions.test.ts

@@ -0,0 +1,149 @@
+/**
+ * extend_exceptions 功能测试
+ */
+
+import { ProjectConfigLoader } from '../core/project-config-loader';
+import * as fs from 'fs';
+
+// Mock 文件系统
+jest.mock('fs');
+
+describe('extend_exceptions', () => {
+  let loader: ProjectConfigLoader;
+
+  beforeEach(() => {
+    loader = new ProjectConfigLoader('/test/project');
+    jest.clearAllMocks();
+  });
+
+  it('应该追加例外到内置约束', () => {
+    // 模拟配置文件存在
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockImplementation((filePath: string) => {
+      if (filePath.includes('config.yml')) {
+        return 'preset: standard\n';
+      }
+      if (filePath.includes('custom-constraints.yml')) {
+        return `
+custom_constraints:
+  no_fix_without_root_cause:
+    extend_exceptions:
+      - MY_CUSTOM_EXCEPTION_1
+      - MY_CUSTOM_EXCEPTION_2
+`;
+      }
+      return '';
+    });
+
+    loader.load();
+    const merged = loader.mergeConstraints();
+
+    // 注意：no_fix_without_root_cause 是 GUIDELINE
+    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    expect(constraint).toBeDefined();
+    // 应该包含内置例外
+    expect(constraint?.exceptions).toContain('simple_typo');
+    expect(constraint?.exceptions).toContain('config_value_error');
+    // 应该包含新增例外
+    expect(constraint?.exceptions).toContain('MY_CUSTOM_EXCEPTION_1');
+    expect(constraint?.exceptions).toContain('MY_CUSTOM_EXCEPTION_2');
+    // 总数应该是 5（3 内置 + 2 新增）
+    expect(constraint?.exceptions?.length).toBe(5);
+  });
+
+  it('应该支持 exceptions + extend_exceptions', () => {
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockImplementation((filePath: string) => {
+      if (filePath.includes('config.yml')) {
+        return 'preset: standard\n';
+      }
+      if (filePath.includes('custom-constraints.yml')) {
+        return `
+custom_constraints:
+  no_fix_without_root_cause:
+    exceptions:
+      - MY_EXCEPTION
+    extend_exceptions:
+      - MY_EXTENDED
+`;
+      }
+      return '';
+    });
+
+    loader.load();
+    const merged = loader.mergeConstraints();
+
+    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    // 应该包含内置例外（因为有 extend_exceptions）
+    expect(constraint?.exceptions).toContain('simple_typo');
+    // 应该包含自定义例外
+    expect(constraint?.exceptions).toContain('MY_EXCEPTION');
+    // 应该包含扩展例外
+    expect(constraint?.exceptions).toContain('MY_EXTENDED');
+    // 总数应该是 5（3 内置 + 1 exceptions + 1 extend_exceptions）
+    expect(constraint?.exceptions?.length).toBe(5);
+  });
+
+  it('没有 extend_exceptions 时应该完全覆盖', () => {
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockImplementation((filePath: string) => {
+      if (filePath.includes('config.yml')) {
+        return 'preset: standard\n';
+      }
+      if (filePath.includes('custom-constraints.yml')) {
+        return `
+custom_constraints:
+  no_fix_without_root_cause:
+    level: guideline
+    rule: Do not fix without root cause
+    message: 禁止没有根因分析就修复
+    trigger: bug_fix
+    exceptions:
+      - MY_EXCEPTION
+`;
+      }
+      return '';
+    });
+
+    loader.load();
+    const merged = loader.mergeConstraints();
+
+    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    // 应该只包含自定义例外
+    expect(constraint?.exceptions).toEqual(['MY_EXCEPTION']);
+    // 内置例外不应该保留
+    expect(constraint?.exceptions).not.toContain('simple_typo');
+  });
+
+  it('纯扩展模式应该保留内置约束的其他属性', () => {
+    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    (fs.readFileSync as jest.Mock).mockImplementation((filePath: string) => {
+      if (filePath.includes('config.yml')) {
+        return 'preset: standard\n';
+      }
+      if (filePath.includes('custom-constraints.yml')) {
+        return `
+custom_constraints:
+  no_fix_without_root_cause:
+    extend_exceptions:
+      - MY_PATTERN
+`;
+      }
+      return '';
+    });
+
+    loader.load();
+    const merged = loader.mergeConstraints();
+
+    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    expect(constraint).toBeDefined();
+    // 应该保留内置约束的 rule
+    expect(constraint?.rule).toBeTruthy();
+    // 应该保留内置约束的 message
+    expect(constraint?.message).toBeTruthy();
+    // 应该包含新增的例外
+    expect(constraint?.exceptions).toContain('MY_PATTERN');
+    // 应该保留内置例外
+    expect(constraint?.exceptions).toContain('simple_typo');
+  });
+});