@dommaker/harness 0.13.0 → 0.13.2

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

@@ -0,0 +1,404 @@
+/**
+ * constraint-evolver 测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { ConstraintEvolver } from '../monitoring/constraint-evolver';
+import type { Diagnosis } from '../monitoring/constraint-doctor';
+
+describe('ConstraintEvolver', () => {
+  describe('constructor', () => {
+    it('应该创建实例', () => {
+      const evolver = new ConstraintEvolver();
+      expect(evolver).toBeDefined();
+    });
+
+    it('支持自定义 proposalsDir', () => {
+      const evolver = new ConstraintEvolver('/tmp/test-proposals');
+      expect(evolver).toBeDefined();
+    });
+  });
+
+  describe('propose', () => {
+    it('应该根据诊断生成提案', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'anomaly-001',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: {
+          primary: '例外使用过多',
+          evidence: [],
+        },
+        impact: {
+          severity: 'medium',
+          scope: 'single_project',
+          userImpact: '质量下降',
+        },
+        recommendations: [
+          {
+            type: 'add_exception',
+            content: '添加 simple_typo 例外',
+            expectedOutcome: '减少误报',
+            implementationCost: 'low',
+          },
+        ],
+        needsChange: true,
+        urgency: 'medium',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+
+      expect(proposal).toBeDefined();
+      expect(proposal?.constraintId).toBe('no_fix_without_root_cause');
+    });
+
+    it('needsChange=false 应该返回 null', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'anomaly-no-change',
+        constraintId: 'test_constraint',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '正常', evidence: [] },
+        impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+        recommendations: [],
+        needsChange: false,
+        urgency: 'low',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      expect(proposal).toBeNull();
+    });
+
+    it('recommendations 为空应该返回 null', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'anomaly-no-rec',
+        constraintId: 'test_constraint',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '测试', evidence: [] },
+        impact: { severity: 'medium', scope: 'single_project', userImpact: '测试' },
+        recommendations: [],
+        needsChange: true,
+        urgency: 'medium',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      expect(proposal).toBeNull();
+    });
+
+    it('应该处理 adjust_threshold 类型', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'anomaly-002',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '触发条件过宽', evidence: [] },
+        impact: { severity: 'low', scope: 'single_project', userImpact: '少量误报' },
+        recommendations: [
+          { type: 'adjust_threshold', content: '缩小触发范围', expectedOutcome: '减少误报', implementationCost: 'low' },
+        ],
+        needsChange: true,
+        urgency: 'low',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      expect(proposal).toBeDefined();
+      expect(proposal?.type).toBe('adjust_trigger');
+    });
+
+    it('应该处理 modify_constraint 类型', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'anomaly-003',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '消息不清晰', evidence: [] },
+        impact: { severity: 'low', scope: 'single_project', userImpact: '用户体验差' },
+        recommendations: [
+          { type: 'modify_constraint', content: '优化提示消息', expectedOutcome: '更清晰', implementationCost: 'low' },
+        ],
+        needsChange: true,
+        urgency: 'low',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      expect(proposal).toBeDefined();
+      expect(proposal?.type).toBe('modify_message');
+    });
+  });
+
+  describe('proposeBatch', () => {
+    it('应该批量生成提案', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnoses: Diagnosis[] = [
+        {
+          anomalyId: 'batch-001',
+          constraintId: 'no_fix_without_root_cause',
+          diagnosedAt: Date.now(),
+          rootCause: { primary: '测试1', evidence: [] },
+          impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+          recommendations: [{ type: 'add_exception', content: 'test', expectedOutcome: 'ok', implementationCost: 'low' }],
+          needsChange: true,
+          urgency: 'low',
+        },
+        {
+          anomalyId: 'batch-002',
+          constraintId: 'no_code_without_test',
+          diagnosedAt: Date.now(),
+          rootCause: { primary: '测试2', evidence: [] },
+          impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+          recommendations: [{ type: 'add_exception', content: 'test', expectedOutcome: 'ok', implementationCost: 'low' }],
+          needsChange: true,
+          urgency: 'low',
+        },
+        {
+          anomalyId: 'batch-003',
+          constraintId: 'unknown_constraint',
+          diagnosedAt: Date.now(),
+          rootCause: { primary: '测试3', evidence: [] },
+          impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+          recommendations: [],
+          needsChange: false,
+          urgency: 'low',
+        },
+      ];
+
+      const proposals = await evolver.proposeBatch(diagnoses);
+      expect(proposals.length).toBe(2);
+    });
+  });
+
+  describe('review', () => {
+    it('Iron Law 非添加例外应该被拒绝', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'review-001',
+        constraintId: 'no_bypass_checkpoint',  // iron_law
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '测试', evidence: [] },
+        impact: { severity: 'high', scope: 'single_project', userImpact: '严重' },
+        recommendations: [{ type: 'modify_constraint', content: '修改消息', expectedOutcome: '更清晰', implementationCost: 'low' }],
+        needsChange: true,
+        urgency: 'high',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      const review = evolver.review(proposal!);
+
+      expect(review.accepted).toBe(false);
+      expect(review.comment).toContain('Iron Law');
+    });
+
+    it('高风险提案应该被拒绝', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'review-002',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '高风险', evidence: [] },
+        impact: { severity: 'high', scope: 'multiple_projects', userImpact: '严重' },
+        recommendations: [{ type: 'add_exception', content: 'test', expectedOutcome: '高风险', implementationCost: 'high' }],
+        needsChange: true,
+        urgency: 'high',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      const review = evolver.review(proposal!);
+
+      expect(review.accepted).toBe(false);
+      expect(review.comment).toContain('高风险');
+    });
+
+    it('低风险 + 有测试应该通过', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'review-003',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '低风险变更', evidence: [] },
+        impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+        recommendations: [{ type: 'add_exception', content: 'test', expectedOutcome: '低风险', implementationCost: 'low' }],
+        needsChange: true,
+        urgency: 'low',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      const review = evolver.review(proposal!);
+
+      expect(review.accepted).toBe(true);
+    });
+
+    it('中风险需要人工审核', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'review-004',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '中风险', evidence: [] },
+        impact: { severity: 'medium', scope: 'single_project', userImpact: '中等' },
+        recommendations: [{ type: 'adjust_threshold', content: 'test', expectedOutcome: '中风险', implementationCost: 'high' }],
+        needsChange: true,
+        urgency: 'medium',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      const review = evolver.review(proposal!);
+
+      expect(review.accepted).toBe(false);
+      expect(review.comment).toContain('人工审核');
+    });
+  });
+
+  describe('implement', () => {
+    it('add_exception 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const diagnosis: Diagnosis = {
+        anomalyId: 'impl-001',
+        constraintId: 'no_fix_without_root_cause',
+        diagnosedAt: Date.now(),
+        rootCause: { primary: '测试', evidence: [] },
+        impact: { severity: 'low', scope: 'single_project', userImpact: '无' },
+        recommendations: [{ type: 'add_exception', content: 'test_exception', expectedOutcome: 'ok', implementationCost: 'low' }],
+        needsChange: true,
+        urgency: 'low',
+      };
+
+      const proposal = await evolver.propose(diagnosis);
+      const impl = evolver.implement(proposal!);
+
+      expect(impl.instructions.length).toBeGreaterThan(0);
+      expect(impl.filesToModify).toContain('src/core/constraints/definitions.ts');
+    });
+
+    it('remove_exception 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const proposal = {
+        id: 'test-remove',
+        proposedAt: Date.now(),
+        diagnosisId: 'diag-001',
+        constraintId: 'test',
+        type: 'remove_exception' as const,
+        content: { proposed: 'old_exception', description: 'test' },
+        reasoning: 'test',
+        expectedOutcome: 'ok',
+        risk: { level: 'low' as const, description: 'test' },
+        implementation: { files: ['test.ts'], linesChanged: 5, testsRequired: true },
+        status: 'proposed' as const,
+      };
+
+      const impl = evolver.implement(proposal);
+      expect(impl.instructions.some(i => i.includes('移除'))).toBe(true);
+    });
+
+    it('adjust_trigger 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const proposal = {
+        id: 'test-adjust',
+        proposedAt: Date.now(),
+        diagnosisId: 'diag-002',
+        constraintId: 'test',
+        type: 'adjust_trigger' as const,
+        content: { current: 'old_trigger', proposed: 'new_trigger', description: 'test' },
+        reasoning: 'test',
+        expectedOutcome: 'ok',
+        risk: { level: 'low' as const, description: 'test' },
+        implementation: { files: ['test.ts'], linesChanged: 5, testsRequired: true },
+        status: 'proposed' as const,
+      };
+
+      const impl = evolver.implement(proposal);
+      expect(impl.instructions.some(i => i.includes('调整'))).toBe(true);
+    });
+
+    it('change_level 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const proposal = {
+        id: 'test-level',
+        proposedAt: Date.now(),
+        diagnosisId: 'diag-003',
+        constraintId: 'test',
+        type: 'change_level' as const,
+        content: { current: 'iron_law', proposed: 'guideline', description: 'test' },
+        reasoning: 'test',
+        expectedOutcome: 'ok',
+        risk: { level: 'low' as const, description: 'test' },
+        implementation: { files: ['test.ts'], linesChanged: 5, testsRequired: true },
+        status: 'proposed' as const,
+      };
+
+      const impl = evolver.implement(proposal);
+      expect(impl.instructions.some(i => i.includes('层级'))).toBe(true);
+    });
+
+    it('modify_message 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const proposal = {
+        id: 'test-msg',
+        proposedAt: Date.now(),
+        diagnosisId: 'diag-004',
+        constraintId: 'test',
+        type: 'modify_message' as const,
+        content: { current: 'old msg', proposed: 'new msg', description: 'test' },
+        reasoning: 'test',
+        expectedOutcome: 'ok',
+        risk: { level: 'low' as const, description: 'test' },
+        implementation: { files: ['test.ts'], linesChanged: 5, testsRequired: true },
+        status: 'proposed' as const,
+      };
+
+      const impl = evolver.implement(proposal);
+      expect(impl.instructions.some(i => i.includes('修改'))).toBe(true);
+    });
+
+    it('new_constraint 应该生成正确指令', async () => {
+      const evolver = new ConstraintEvolver();
+
+      const proposal = {
+        id: 'test-new',
+        proposedAt: Date.now(),
+        diagnosisId: 'diag-005',
+        constraintId: 'test',
+        type: 'new_constraint' as const,
+        content: { proposed: { id: 'new_constraint', level: 'guideline', rule: 'test' }, description: 'test' },
+        reasoning: 'test',
+        expectedOutcome: 'ok',
+        risk: { level: 'low' as const, description: 'test' },
+        implementation: { files: ['test.ts'], linesChanged: 20, testsRequired: true },
+        status: 'proposed' as const,
+      };
+
+      const impl = evolver.implement(proposal);
+      expect(impl.filesToModify.length).toBeGreaterThan(1);
+    });
+  });
+
+  describe('listProposals', () => {
+    it('应该返回所有提案', () => {
+      const evolver = new ConstraintEvolver();
+      const proposals = evolver.listProposals();
+      expect(Array.isArray(proposals)).toBe(true);
+    });
+
+    it('应该返回待审核提案', () => {
+      const evolver = new ConstraintEvolver();
+      const pending = evolver.listProposals('proposed');
+      expect(Array.isArray(pending)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,136 @@
+/**
+ * ConstraintViolationHandler 测试（S4）
+ */
+import { describe, it, expect } from '@jest/globals';
+import {
+  ConstraintViolationHandler,
+  executeWithBlock,
+  executeWithCollect,
+  executeWithSafeBoolean,
+} from '../failure/constraint-handler';
+import { ConstraintViolationError } from '../types/constraint';
+import type { ConstraintCheckResult } from '../types/constraint';
+
+function makePassingResult(): ConstraintCheckResult {
+  return {
+    ironLaws: [{ id: 'test_law', level: 'iron_law', satisfied: true, checkedAt: new Date() }],
+    guidelines: [],
+    tips: [],
+    passed: true,
+    warningCount: 0,
+    tipCount: 0,
+  };
+}
+
+function makeFailingResult(): ConstraintCheckResult {
+  return {
+    ironLaws: [{ id: 'test_law', level: 'iron_law', satisfied: false, message: '违规', checkedAt: new Date() }],
+    guidelines: [{ id: 'guide', level: 'guideline', satisfied: false, checkedAt: new Date() }],
+    tips: [],
+    passed: false,
+    warningCount: 1,
+    tipCount: 0,
+  };
+}
+
+function makeThrowingFn() {
+  return async () => {
+    throw new ConstraintViolationError({
+      id: 'test_law',
+      level: 'iron_law',
+      satisfied: false,
+      message: '铁律违规',
+      checkedAt: new Date(),
+    });
+  };
+}
+
+describe('ConstraintViolationHandler', () => {
+  const handler = new ConstraintViolationHandler();
+
+  describe('BLOCK strategy', () => {
+    it('通过时返回结果', async () => {
+      const result = await handler.execute(() => Promise.resolve(makePassingResult()), 'BLOCK');
+      expect(result.strategy).toBe('BLOCK');
+      expect(result.hasViolation).toBe(false);
+      expect(result.checkResult?.passed).toBe(true);
+    });
+
+    it('违规时抛出异常', async () => {
+      await expect(
+        handler.execute(makeThrowingFn(), 'BLOCK')
+      ).rejects.toThrow(ConstraintViolationError);
+    });
+
+    it('checkResult 包含 failed 时 hasViolation=true', async () => {
+      const result = await handler.execute(() => Promise.resolve(makeFailingResult()), 'BLOCK');
+      expect(result.hasViolation).toBe(true);
+    });
+  });
+
+  describe('COLLECT strategy', () => {
+    it('通过时返回完整结果', async () => {
+      const result = await handler.execute(() => Promise.resolve(makePassingResult()), 'COLLECT');
+      expect(result.strategy).toBe('COLLECT');
+      expect(result.hasViolation).toBe(false);
+      expect(result.checkResult).toBeDefined();
+    });
+
+    it('checkResult 有违规时 hasViolation=true', async () => {
+      const result = await handler.execute(() => Promise.resolve(makeFailingResult()), 'COLLECT');
+      expect(result.hasViolation).toBe(true);
+      expect(result.violationCount).toBe(2); // 1 iron + 1 guideline
+    });
+
+    it('抛出异常时捕获并返回空结果', async () => {
+      const result = await handler.execute(makeThrowingFn(), 'COLLECT');
+      expect(result.strategy).toBe('COLLECT');
+      expect(result.hasViolation).toBe(true);
+      expect(result.checkResult).toBeDefined();
+      expect(result.checkResult!.passed).toBe(false);
+    });
+  });
+
+  describe('SAFE_BOOLEAN strategy', () => {
+    it('通过时返回 false', async () => {
+      const result = await handler.execute(() => Promise.resolve(makePassingResult()), 'SAFE_BOOLEAN');
+      expect(result.strategy).toBe('SAFE_BOOLEAN');
+      expect(result.hasViolation).toBe(false);
+    });
+
+    it('违规时返回 true', async () => {
+      const result = await handler.execute(() => Promise.resolve(makeFailingResult()), 'SAFE_BOOLEAN');
+      expect(result.hasViolation).toBe(true);
+    });
+
+    it('抛出异常时返回 true', async () => {
+      const result = await handler.execute(makeThrowingFn(), 'SAFE_BOOLEAN');
+      expect(result.hasViolation).toBe(true);
+    });
+  });
+});
+
+describe('快捷函数', () => {
+  it('executeWithBlock 通过', async () => {
+    const result = await executeWithBlock(() => Promise.resolve(makePassingResult()));
+    expect(result.strategy).toBe('BLOCK');
+    expect(result.hasViolation).toBe(false);
+  });
+
+  it('executeWithBlock 违规抛出', async () => {
+    await expect(
+      executeWithBlock(makeThrowingFn())
+    ).rejects.toThrow(ConstraintViolationError);
+  });
+
+  it('executeWithCollect 异常不抛出', async () => {
+    const result = await executeWithCollect(makeThrowingFn());
+    expect(result.hasViolation).toBe(true);
+    expect(result.checkResult).toBeDefined();
+  });
+
+  it('executeWithSafeBoolean 异常返回 true', async () => {
+    const result = await executeWithSafeBoolean(makeThrowingFn());
+    expect(result.hasViolation).toBe(true);
+  });
+});

package/src/__tests__/context/progressive-loader.test.ts

@@ -0,0 +1,131 @@
+/**
+ * @spec HZ-002
+ * @acceptance AC-001-1, AC-001-2, AC-001-3, AC-001-4
+ * 
+ * Progressive Loader 测试
+ */
+
+import { ProgressiveLoader } from '../../context/progressive-loader';
+import { TokenEstimator, TokenBudget, AdaptiveTokenBudget } from '../../context/token-budget';
+
+describe('TokenEstimator', () => {
+  it('should estimate English text', () => {
+    const tokens = TokenEstimator.estimateText('Hello World');
+    expect(tokens).toBeGreaterThan(0);
+  });
+
+  it('should estimate Chinese text', () => {
+    const tokens = TokenEstimator.estimateText('你好世界');
+    expect(tokens).toBeGreaterThan(0);
+  });
+
+  it('should estimate object', () => {
+    const tokens = TokenEstimator.estimateObject({ foo: 'bar', num: 123 });
+    expect(tokens).toBeGreaterThan(0);
+  });
+});
+
+describe('TokenBudget', () => {
+  it('should manage budget correctly', () => {
+    const budget = new TokenBudget(1000);
+    expect(budget.total).toBe(1000);
+    expect(budget.remaining).toBe(1000);
+    
+    budget.consume(300);
+    expect(budget.used).toBe(300);
+    expect(budget.remaining).toBe(700);
+    expect(budget.status).toBe('healthy');
+  });
+
+  it('should reserve and release budget', () => {
+    const budget = new TokenBudget(1000);
+    budget.reserve(200);
+    expect(budget.remaining).toBe(800);
+    
+    budget.release(100);
+    expect(budget.remaining).toBe(900);
+  });
+
+  it('should detect budget exceeded', () => {
+    const budget = new TokenBudget(100);
+    budget.consume(80);
+    expect(budget.status).toBe('critical');
+  });
+});
+
+describe('ProgressiveLoader', () => {
+  it('should load in chunks', async () => {
+    const loader = new ProgressiveLoader();
+    const items = Array.from({ length: 100 }, (_, i) => i);
+    const chunks: number[][] = [];
+    
+    await loader.loadInChunks(items, {
+      chunkSize: 10,
+      onChunk: (chunk: number[]) => { chunks.push(chunk); }
+    });
+    
+    expect(chunks.length).toBe(10);
+    expect(chunks[0].length).toBe(10);
+  });
+
+  it('should respect token budget with truncate', async () => {
+    const loader = new ProgressiveLoader();
+    const items = [
+      { content: 'a'.repeat(100) },
+      { content: 'b'.repeat(100) },
+      { content: 'c'.repeat(100) },
+      { content: 'd'.repeat(100) },
+    ];
+    
+    const result = await loader.loadWithBudget(items, {
+      budget: 60,
+      estimator: (item: { content: string }) => TokenEstimator.estimateText(item.content),
+      onBudgetExceeded: 'truncate',
+      minItems: 1
+    });
+    
+    expect(result.items.length).toBeLessThanOrEqual(3);
+    expect(result.truncated).toBe(true);
+  });
+
+  it('should respect token budget with skip', async () => {
+    const loader = new ProgressiveLoader();
+    const items = [
+      { content: 'a'.repeat(100) },
+      { content: 'b'.repeat(1000) },
+      { content: 'c'.repeat(100) },
+    ];
+    
+    const result = await loader.loadWithBudget(items, {
+      budget: 60,
+      estimator: (item: { content: string }) => TokenEstimator.estimateText(item.content),
+      onBudgetExceeded: 'skip',
+      minItems: 1
+    });
+    
+    expect(result.skipped).toBeGreaterThan(0);
+  });
+});
+
+describe('AdaptiveTokenBudget', () => {
+  it('should suggest budget adjustment', () => {
+    const budget = new AdaptiveTokenBudget(1000);
+    
+    for (let i = 0; i < 5; i++) {
+      budget.recordActualUsage(950);
+    }
+    
+    const suggestion = budget.suggestBudgetAdjustment();
+    expect(suggestion.action).toBe('increase');
+  });
+
+  it('should predict future needs', () => {
+    const budget = new AdaptiveTokenBudget(1000);
+    budget.recordActualUsage(500);
+    budget.recordActualUsage(600);
+    budget.recordActualUsage(550);
+    
+    const prediction = budget.predictNeed();
+    expect(prediction).toBeGreaterThan(0);
+  });
+});