@dommaker/harness 1.1.1 → 1.2.0

package/src/__tests__/constraint-doctor.test.ts

@@ -1,271 +0,0 @@
-/**
- * ConstraintDoctor 测试
- */
-
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { ConstraintDoctor } from '../monitoring/constraint-doctor';
-import type { TraceAnomaly } from '../types/trace';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('ConstraintDoctor', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-doctor');
-  let doctor: ConstraintDoctor;
-
-  beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
-    doctor = new ConstraintDoctor();
-  });
-
-  afterAll(() => {
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  describe('constructor', () => {
-    it('应该创建实例', () => {
-      expect(doctor).toBeDefined();
-    });
-  });
-
-  describe('setData', () => {
-    it('应该设置数据', () => {
-      doctor.setData([], undefined);
-
-      expect(doctor).toBeDefined();
-    });
-  });
-
-  describe('diagnose', () => {
-    it('应该诊断异常', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'high_bypass_rate',
-        constraintId: 'no_fix_without_root_cause',
-        level: 'guideline',
-        message: '绕过率过高',
-        data: {
-          currentRate: 0.5,
-          threshold: 0.3,
-        },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis).toBeDefined();
-      expect(diagnosis.constraintId).toBe('no_fix_without_root_cause');
-    });
-
-    it('应该返回诊断结果', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'rising_fail_rate',
-        constraintId: 'no_completion_without_verification',
-        level: 'iron_law',
-        message: '失败率上升',
-        data: {
-          currentRate: 0.6,
-          threshold: 0.5,
-          trend: 'rising',
-        },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis.rootCause).toBeDefined();
-      expect(diagnosis.impact).toBeDefined();
-      expect(diagnosis.needsChange).toBeDefined();
-    });
-  });
-
-  describe('generateReport', () => {
-    it('应该生成报告', () => {
-      const diagnosis = {
-        anomalyId: 'test',
-        constraintId: 'test',
-        diagnosedAt: Date.now(),
-        rootCause: { primary: 'Test', evidence: [] },
-        impact: { severity: 'medium' as const, scope: 'single_project' as const, userImpact: 'Test' },
-        recommendations: [],
-        needsChange: true,
-        urgency: 'medium' as const,
-      };
-
-      const report = doctor.generateReport(diagnosis);
-
-      expect(typeof report).toBe('string');
-      expect(report.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('saveDiagnosis', () => {
-    it('应该保存诊断', () => {
-      const diagnosis = {
-        anomalyId: 'test',
-        constraintId: 'test',
-        diagnosedAt: Date.now(),
-        rootCause: { primary: 'Test', evidence: [] },
-        impact: { severity: 'medium' as const, scope: 'single_project' as const, userImpact: 'Test' },
-        recommendations: [],
-        needsChange: false,
-        urgency: 'low' as const,
-      };
-
-      const outputPath = path.join(tempDir, 'diagnosis.json');
-
-      doctor.saveDiagnosis(diagnosis, outputPath);
-
-      expect(fs.existsSync(outputPath)).toBe(true);
-    });
-  });
-
-  describe('loadDiagnosis', () => {
-    it('应该加载诊断', () => {
-      const diagnosis = {
-        anomalyId: 'test-load',
-        constraintId: 'test-load',
-        diagnosedAt: Date.now(),
-        rootCause: { primary: 'Test', evidence: [] },
-        impact: { severity: 'low' as const, scope: 'single_project' as const, userImpact: 'Test' },
-        recommendations: [],
-        needsChange: false,
-        urgency: 'low' as const,
-      };
-
-      const outputPath = path.join(tempDir, 'diagnosis-load.json');
-      doctor.saveDiagnosis(diagnosis, outputPath);
-
-      const loaded = doctor.loadDiagnosis(outputPath);
-
-      expect(loaded).toBeDefined();
-      expect(loaded.anomalyId).toBe('test-load');
-    });
-  });
-
-  describe('diagnose - 更多异常类型', () => {
-    it('应该诊断 rising_bypass_rate', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'rising_bypass_rate',
-        constraintId: 'no_fix_without_root_cause',
-        level: 'guideline',
-        message: '绕过率上升',
-        data: { currentRate: 0.4, threshold: 0.2, trend: 'rising' },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis.rootCause.primary).toContain('绕过率');
-      expect(diagnosis.needsChange).toBe(true);
-      expect(diagnosis.urgency).toBe('high');
-    });
-
-    it('应该诊断 low_pass_rate', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'low_pass_rate',
-        constraintId: 'capability_sync',
-        level: 'guideline',
-        message: '通过率过低',
-        data: { currentRate: 0.1, threshold: 0.5 },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis.rootCause.primary).toContain('通过率');
-      expect(diagnosis.needsChange).toBe(true);
-      expect(diagnosis.urgency).toBe('high');
-    });
-
-    it('应该诊断 exception_overuse', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'exception_overuse',
-        constraintId: 'no_fix_without_root_cause',
-        level: 'guideline',
-        message: '例外过度使用',
-        data: { currentRate: 0.6, threshold: 0.2 },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis.rootCause.primary).toContain('例外');
-      expect(diagnosis.needsChange).toBe(true);
-    });
-
-    it('rising_fail_rate 应该设置 severity 为 high 当 iron_law', async () => {
-      const anomaly: TraceAnomaly = {
-        type: 'rising_fail_rate',
-        constraintId: 'no_completion_without_verification',
-        level: 'iron_law',
-        message: '失败率上升',
-        data: { currentRate: 0.7, threshold: 0.3, trend: 'rising' },
-        detectedAt: Date.now(),
-      };
-
-      const diagnosis = await doctor.diagnose(anomaly);
-
-      expect(diagnosis.impact.severity).toBe('high');
-    });
-  });
-
-  describe('diagnoseBatch', () => {
-    it('应该批量诊断多个异常', async () => {
-      const anomalies: TraceAnomaly[] = [
-        {
-          type: 'high_bypass_rate',
-          constraintId: 'no_fix_without_root_cause',
-          level: 'guideline',
-          message: '绕过率过高',
-          data: { currentRate: 0.5, threshold: 0.3 },
-          detectedAt: Date.now(),
-        },
-        {
-          type: 'low_pass_rate',
-          constraintId: 'capability_sync',
-          level: 'guideline',
-          message: '通过率过低',
-          data: { currentRate: 0.1, threshold: 0.5 },
-          detectedAt: Date.now(),
-        },
-      ];
-
-      const results = await doctor.diagnoseBatch(anomalies);
-
-      expect(results.length).toBe(2);
-      expect(results[0].constraintId).toBe('no_fix_without_root_cause');
-      expect(results[1].constraintId).toBe('capability_sync');
-    });
-  });
-
-  describe('saveDiagnosis - 目录不存在', () => {
-    it('应该自动创建目录', () => {
-      const nestedPath = path.join(tempDir, 'nested', 'deep', 'diagnosis.json');
-      const diagnosis = {
-        anomalyId: 'nested-test',
-        constraintId: 'test',
-        diagnosedAt: Date.now(),
-        rootCause: { primary: 'Test', evidence: [] },
-        impact: { severity: 'low' as const, scope: 'single_project' as const, userImpact: 'Test' },
-        recommendations: [],
-        needsChange: false,
-        urgency: 'low' as const,
-      };
-
-      doctor.saveDiagnosis(diagnosis, nestedPath);
-
-      expect(fs.existsSync(nestedPath)).toBe(true);
-    });
-  });
-
-  describe('createDoctor 工厂函数', () => {
-    it('应该创建实例', async () => {
-      const { createDoctor } = await import('../monitoring/constraint-doctor');
-      const d = createDoctor();
-      expect(d).toBeDefined();
-    });
-  });
-});

package/src/__tests__/doctor-extra.test.ts

@@ -1,155 +0,0 @@
-/**
- * ConstraintDoctor 测试
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { ConstraintDoctor, createDoctor } from '../monitoring/constraint-doctor';
-import type { ExecutionTrace, TraceAnomaly } from '../types/trace';
-
-describe('ConstraintDoctor', () => {
-  let tempDir: string;
-  let doctor: ConstraintDoctor;
-
-  beforeEach(() => {
-    tempDir = path.join(os.tmpdir(), `harness-traces-${Date.now()}`);
-    fs.mkdirSync(tempDir, { recursive: true });
-    doctor = createDoctor();
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true });
-    }
-  });
-
-  test('should diagnose high bypass rate anomaly', async () => {
-    // 创建异常
-    const anomaly: TraceAnomaly = {
-      type: 'high_bypass_rate',
-      constraintId: 'test_constraint',
-      level: 'guideline',
-      message: 'Bypass rate 40%',
-      data: {
-        currentRate: 0.4,
-        threshold: 0.3,
-      },
-      detectedAt: Date.now(),
-      suggestedAction: 'diagnose',
-    };
-
-    // 添加 traces
-    const traces: ExecutionTrace[] = [];
-    for (let i = 0; i < 10; i++) {
-      traces.push({
-        constraintId: 'test_constraint',
-        level: 'guideline',
-        timestamp: Date.now() - i * 60 * 1000,
-        result: i < 6 ? 'bypassed' : 'pass',
-      });
-    }
-    doctor.setData(traces);
-
-    // 诊断
-    const diagnosis = await doctor.diagnose(anomaly);
-
-    expect(diagnosis.constraintId).toBe('test_constraint');
-    expect(diagnosis.needsChange).toBe(true);
-    expect(diagnosis.rootCause.primary).toContain('过于严格');
-    expect(diagnosis.recommendations.length).toBeGreaterThan(0);
-    expect(diagnosis.recommendations[0].type).toBe('add_exception');
-  });
-
-  test('should diagnose rising fail rate anomaly', async () => {
-    const anomaly: TraceAnomaly = {
-      type: 'rising_fail_rate',
-      constraintId: 'another_constraint',
-      level: 'iron_law',
-      message: 'Fail rate rising',
-      data: {
-        currentRate: 0.6,
-        threshold: 0.5,
-        trend: 'rising',
-      },
-      detectedAt: Date.now(),
-      suggestedAction: 'diagnose',
-    };
-
-    doctor.setData([]);
-    const diagnosis = await doctor.diagnose(anomaly);
-
-    expect(diagnosis.needsChange).toBe(true);
-    expect(diagnosis.impact.severity).toBe('high'); // Iron law
-    expect(diagnosis.urgency).toBe('medium'); // Iron law 强制 medium+
-  });
-
-  test('should detect exception overuse', async () => {
-    const anomaly: TraceAnomaly = {
-      type: 'exception_overuse',
-      constraintId: 'constraint_with_exceptions',
-      level: 'guideline',
-      message: 'Exception rate 50%',
-      data: {
-        currentRate: 0.5,
-        threshold: 0.4,
-      },
-      detectedAt: Date.now(),
-      suggestedAction: 'add_exception',
-    };
-
-    doctor.setData([]);
-    const diagnosis = await doctor.diagnose(anomaly);
-
-    expect(diagnosis.rootCause.primary).toContain('过度使用');
-    expect(diagnosis.recommendations[0].type).toBe('modify_constraint');
-  });
-
-  test('should generate diagnosis report', async () => {
-    const anomaly: TraceAnomaly = {
-      type: 'high_bypass_rate',
-      constraintId: 'test',
-      level: 'guideline',
-      message: 'Test',
-      data: {
-        currentRate: 0.5,
-        threshold: 0.3,
-      },
-      detectedAt: Date.now(),
-      suggestedAction: 'diagnose',
-    };
-
-    doctor.setData([]);
-    const diagnosis = await doctor.diagnose(anomaly);
-    const report = doctor.generateReport(diagnosis);
-
-    expect(report).toContain('# Diagnosis Report');
-    expect(report).toContain('Root Cause');
-    expect(report).toContain('Recommendations');
-    expect(report).toContain('test');
-  });
-
-  test('should save and load diagnosis', async () => {
-    const anomaly: TraceAnomaly = {
-      type: 'high_bypass_rate',
-      constraintId: 'save_test',
-      level: 'guideline',
-      message: 'Test',
-      data: { currentRate: 0.5, threshold: 0.3 },
-      detectedAt: Date.now(),
-      suggestedAction: 'diagnose',
-    };
-
-    doctor.setData([]);
-    const diagnosis = await doctor.diagnose(anomaly);
-
-    const outputPath = path.join(tempDir, 'diagnosis.json');
-    doctor.saveDiagnosis(diagnosis, outputPath);
-
-    expect(fs.existsSync(outputPath)).toBe(true);
-
-    const loaded = doctor.loadDiagnosis(outputPath);
-    expect(loaded.constraintId).toBe('save_test');
-    expect(loaded.needsChange).toBe(true);
-  });
-});

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

@@ -1,149 +0,0 @@
-/**
- * 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 是 prompt 层约束（ADR-0001）
-    const constraint = merged.prompts!['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.prompts!['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');
-  });
-});

package/src/__tests__/interceptor.test.ts

@@ -1,89 +0,0 @@
-/**
- * ConstraintInterceptor 测试
- */
-
-import { describe, it, expect } from '@jest/globals';
-import { ConstraintInterceptor } from '../core/constraints/interceptor';
-import type { EnforcementExecutor } from '../types/enforcement';
-
-describe('ConstraintInterceptor', () => {
-  describe('单例模式', () => {
-    it('应该返回单例实例', () => {
-      const instance1 = ConstraintInterceptor.getInstance();
-      const instance2 = ConstraintInterceptor.getInstance();
-      expect(instance1).toBe(instance2);
-    });
-  });
-
-  describe('setEnabled', () => {
-    it('应该能启用/禁用拦截器', () => {
-      const interceptor = ConstraintInterceptor.getInstance();
-      
-      interceptor.setEnabled(false);
-      interceptor.setEnabled(true);
-      
-      expect(interceptor).toBeDefined();
-    });
-  });
-
-  describe('register', () => {
-    it('应该能注册执行器', () => {
-      const interceptor = ConstraintInterceptor.getInstance();
-      
-      const executor: EnforcementExecutor = {
-        execute: async () => ({
-          passed: true,
-          message: 'test',
-        }),
-      };
-      
-      interceptor.register('test_executor', executor);
-      
-      expect(interceptor).toBeDefined();
-    });
-  });
-
-  describe('unregister', () => {
-    it('应该能注销执行器', () => {
-      const interceptor = ConstraintInterceptor.getInstance();
-      
-      const executor: EnforcementExecutor = {
-        execute: async () => ({
-          passed: true,
-          message: 'temp',
-        }),
-      };
-      
-      interceptor.register('temp_executor', executor);
-      
-      const removed = interceptor.unregister('temp_executor');
-      expect(removed).toBe(true);
-    });
-
-    it('注销不存在的执行器应该返回 false', () => {
-      const interceptor = ConstraintInterceptor.getInstance();
-      
-      const removed = interceptor.unregister('nonexistent');
-      expect(removed).toBe(false);
-    });
-  });
-
-  describe('registerBatch', () => {
-    it('应该能批量注册', () => {
-      const interceptor = ConstraintInterceptor.getInstance();
-      
-      interceptor.registerBatch([
-        {
-          enforcementId: 'batch1',
-          executor: { execute: async () => ({ passed: true }) },
-        },
-        {
-          enforcementId: 'batch2',
-          executor: { execute: async () => ({ passed: true }) },
-        },
-      ]);
-      
-      expect(interceptor).toBeDefined();
-    });
-  });
-});