@dommaker/harness 1.1.0 → 1.2.0

package/src/__tests__/performance-collector.test.ts

@@ -1,276 +0,0 @@
-/**
- * PerformanceCollector 测试
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
-import { PerformanceCollector } from '../monitoring/performance-collector';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('PerformanceCollector', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-perf');
-  const logFile = path.join(tempDir, 'performance.log');
-  let collector: PerformanceCollector;
-
-  beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterAll(() => {
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  beforeEach(() => {
-    fs.writeFileSync(logFile, '');
-    collector = new PerformanceCollector({ logFile, enabled: true });
-  });
-
-  describe('record', () => {
-    it('应该记录性能数据', () => {
-      collector.record({
-        operation: 'test_op',
-        timestamp: Date.now(),
-        duration: 100,
-        result: 'ok',
-      });
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('test_op');
-      expect(content).toContain('ok');
-    });
-
-    it('禁用时应该不记录', () => {
-      const disabledCollector = new PerformanceCollector({
-        logFile,
-        enabled: false,
-      });
-
-      disabledCollector.record({
-        operation: 'test',
-        timestamp: Date.now(),
-        duration: 100,
-        result: 'ok',
-      });
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toBe('');
-    });
-  });
-
-  describe('recordOk', () => {
-    it('应该记录正常执行', () => {
-      collector.recordOk('extract', 150);
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('extract');
-      expect(content).toContain('150');
-      expect(content).toContain('ok');
-    });
-
-    it('应该支持元数据', () => {
-      collector.recordOk('extract', 150, { files: 10 });
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('files');
-    });
-  });
-
-  describe('recordExceeded', () => {
-    it('应该记录超阈值执行', () => {
-      collector.recordExceeded('invokeAgent', 35000, 30000);
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('invokeAgent');
-      expect(content).toContain('exceeded');
-      expect(content).toContain('35000');
-    });
-  });
-
-  describe('read', () => {
-    it('应该读取性能数据', () => {
-      collector.recordOk('op1', 100);
-      collector.recordOk('op2', 200);
-
-      const traces = collector.read();
-      expect(traces.length).toBe(2);
-    });
-
-    it('空文件应该返回空数组', () => {
-      fs.writeFileSync(logFile, '');
-      const traces = collector.read();
-      expect(traces).toEqual([]);
-    });
-  });
-
-  describe('getStats', () => {
-    it('应该返回统计信息', () => {
-      collector.recordOk('op1', 100);
-      collector.recordOk('op2', 200);
-      collector.recordExceeded('op3', 500, 400);
-
-      const stats = collector.getStats();
-
-      expect(stats.totalRecords).toBe(3);
-    });
-
-    it('应该正确读取数据', () => {
-      collector.recordOk('op1', 100);
-      collector.recordOk('op2', 200);
-
-      const traces = collector.read();
-
-      expect(traces.length).toBe(2);
-    });
-
-    it('文件不存在时应该返回空统计', () => {
-      fs.unlinkSync(logFile);
-      const tmpFile = path.join(require('os').tmpdir(), 'harness-test-nonexistent', 'perf.log');
-      const newCollector = new PerformanceCollector({ logFile: tmpFile });
-
-      const stats = newCollector.getStats();
-
-      expect(stats.fileExists).toBe(false);
-      expect(stats.totalRecords).toBe(0);
-    });
-  });
-
-  describe('recordError', () => {
-    it('应该记录错误', () => {
-      collector.recordError('failing-op', 100, 'Something went wrong');
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('error');
-      expect(content).toContain('Something went wrong');
-    });
-
-    it('应该支持 Error 对象', () => {
-      collector.recordError('failing-op', 100, new Error('Test error'));
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('Test error');
-    });
-
-    it('应该支持元数据', () => {
-      collector.recordError('failing-op', 100, 'Error', { retryCount: 3 });
-
-      const content = fs.readFileSync(logFile, 'utf-8');
-      expect(content).toContain('retryCount');
-    });
-  });
-
-  describe('readRecent', () => {
-    it('应该读取最近 N 小时的数据', () => {
-      collector.recordOk('recent-op', 100);
-
-      const traces = collector.readRecent(1);
-      expect(traces.length).toBe(1);
-    });
-  });
-
-  describe('readByOperation', () => {
-    it('应该过滤特定操作', () => {
-      collector.recordOk('op1', 100);
-      collector.recordOk('op2', 200);
-      collector.recordOk('op1', 150);
-
-      const traces = collector.readByOperation('op1');
-      expect(traces.length).toBe(2);
-    });
-  });
-
-  describe('过滤条件', () => {
-    it('应该按时间范围过滤', () => {
-      const now = Date.now();
-      collector.record({ operation: 'old', timestamp: now - 100000, duration: 100, result: 'ok' });
-      collector.record({ operation: 'new', timestamp: now, duration: 100, result: 'ok' });
-
-      const traces = collector.read({
-        timeRange: { start: now - 50000, end: now + 1000 },
-      });
-
-      expect(traces.length).toBe(1);
-      expect(traces[0]?.operation).toBe('new');
-    });
-
-    it('应该按结果类型过滤', () => {
-      collector.recordOk('ok-op', 100);
-      collector.recordError('err-op', 200, 'error');
-
-      const traces = collector.read({ result: 'error' });
-      expect(traces.length).toBe(1);
-      expect(traces[0]?.operation).toBe('err-op');
-    });
-
-    it('应该按项目路径过滤', () => {
-      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', projectPath: '/project1' });
-      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', projectPath: '/project2' });
-
-      const traces = collector.read({ projectPath: '/project1' });
-      expect(traces.length).toBe(1);
-    });
-
-    it('应该按会话 ID 过滤', () => {
-      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', sessionId: 'session-1' });
-      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', sessionId: 'session-2' });
-
-      const traces = collector.read({ sessionId: 'session-1' });
-      expect(traces.length).toBe(1);
-    });
-
-    it('应该按任务 ID 过滤', () => {
-      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', taskId: 'task-1' });
-      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', taskId: 'task-2' });
-
-      const traces = collector.read({ taskId: 'task-1' });
-      expect(traces.length).toBe(1);
-    });
-
-    it('应该按角色 ID 过滤', () => {
-      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', roleId: 'role-1' });
-      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', roleId: 'role-2' });
-
-      const traces = collector.read({ roleId: 'role-1' });
-      expect(traces.length).toBe(1);
-    });
-  });
-
-  describe('cleanupOldFiles', () => {
-    it('应该清理旧备份文件', () => {
-      // 创建一些备份文件（模拟滚动）
-      const backupFile = logFile.replace('.log', '-2026-01-01.log');
-      fs.writeFileSync(backupFile, 'old data');
-
-      // 由于文件是新建的，需要修改 mtime
-      // 简单验证函数运行不崩溃
-      const deleted = collector.cleanupOldFiles(0);
-      expect(deleted).toBeGreaterThanOrEqual(0);
-      
-      // 清理备份文件
-      try { fs.unlinkSync(backupFile); } catch {}
-    });
-
-    it('不存在目录时应该返回 0', () => {
-      // 创建新的 collector，使用临时目录
-      const nonexistentDir = path.join(process.cwd(), 'temp-nonexistent-perf');
-      const nonexistentLogFile = path.join(nonexistentDir, 'perf.log');
-      const newCollector = new PerformanceCollector({ logFile: nonexistentLogFile });
-
-      const deleted = newCollector.cleanupOldFiles(30);
-      expect(deleted).toBe(0);
-    });
-  });
-
-  describe('文件滚动', () => {
-    it('应该检查文件大小', () => {
-      // 创建大文件触发滚动检查
-      collector.recordOk('test', 100);
-      
-      // 文件应该存在
-      expect(fs.existsSync(logFile)).toBe(true);
-    });
-  });
-});

package/src/__tests__/presets.test.ts

@@ -1,65 +0,0 @@
-/**
- * presets 测试
- */
-
-import { describe, it, expect } from '@jest/globals';
-import { STRICT_PRESET, STANDARD_PRESET, RELAXED_PRESET, getPreset } from '../presets/standard';
-
-describe('Presets', () => {
-  describe('STRICT_PRESET', () => {
-    it('应该启用所有约束', () => {
-      expect(STRICT_PRESET.name).toBe('strict');
-      expect(STRICT_PRESET.ironLaws).toBeNull();
-      expect(STRICT_PRESET.guidelines).toBeNull();
-      expect(STRICT_PRESET.prompts).toBeNull();
-    });
-  });
-
-  describe('STANDARD_PRESET', () => {
-    it('应该启用所有约束', () => {
-      expect(STANDARD_PRESET.name).toBe('standard');
-      expect(STANDARD_PRESET.ironLaws).toBeNull();
-      expect(STANDARD_PRESET.guidelines).toBeNull();
-      expect(STANDARD_PRESET.prompts).toBeNull();
-    });
-  });
-
-  describe('RELAXED_PRESET', () => {
-    it('应该只启用核心约束', () => {
-      expect(RELAXED_PRESET.name).toBe('relaxed');
-      expect(RELAXED_PRESET.ironLaws).not.toBeNull();
-      expect(RELAXED_PRESET.guidelines).not.toBeNull();
-      expect(RELAXED_PRESET.prompts).toEqual([]);
-    });
-
-    it('应该包含 no_completion_without_verification', () => {
-      expect(RELAXED_PRESET.ironLaws).toContain('no_completion_without_verification');
-    });
-
-    it('应该包含 no_bypass_checkpoint', () => {
-      expect(RELAXED_PRESET.guidelines).toContain('no_bypass_checkpoint');
-    });
-  });
-
-  describe('getPreset', () => {
-    it('应该返回 strict 预设', () => {
-      const preset = getPreset('strict');
-      expect(preset.name).toBe('strict');
-    });
-
-    it('应该返回 standard 预设', () => {
-      const preset = getPreset('standard');
-      expect(preset.name).toBe('standard');
-    });
-
-    it('应该返回 relaxed 预设', () => {
-      const preset = getPreset('relaxed');
-      expect(preset.name).toBe('relaxed');
-    });
-
-    it('未知预设应该返回 standard', () => {
-      const preset = getPreset('unknown');
-      expect(preset.name).toBe('standard');
-    });
-  });
-});

package/src/core/constraints/__tests__/interceptor.test.ts

@@ -1,253 +0,0 @@
-/**
- * ConstraintInterceptor 测试
- */
-
-import { ConstraintInterceptor } from '../interceptor';
-import { constraintChecker } from '../checker';
-import type { ConstraintContext } from '../../../types/constraint';
-import type { EnforcementExecutor } from '../../../types/enforcement';
-
-// Mock constraintChecker
-jest.mock('../checker', () => ({
-  constraintChecker: {
-    getConstraints: jest.fn(),
-    check: jest.fn().mockResolvedValue({ satisfied: true }),
-  },
-}));
-
-const mockChecker = constraintChecker as jest.Mocked<typeof constraintChecker>;
-
-describe('ConstraintInterceptor', () => {
-  let interceptor: ConstraintInterceptor;
-
-  const mockCheck = jest.fn().mockResolvedValue({ satisfied: true });
-
-  const mockIronLaw = {
-    id: 'test_iron_law',
-    kind: 'check' as const,
-    rule: 'Test Iron Law',
-    message: 'Test iron law message',
-    level: 'iron_law' as const,
-    trigger: 'code_implementation',
-    enforcement: 'test-enforcement',
-    check: mockCheck,
-  };
-
-  const mockGuideline = {
-    id: 'test_guideline',
-    kind: 'check' as const,
-    rule: 'Test Guideline',
-    message: 'Test guideline message',
-    level: 'guideline' as const,
-    trigger: 'code_implementation',
-    enforcement: 'guideline-enforcement',
-    check: mockCheck,
-  };
-
-  const mockContext: ConstraintContext = {
-    operation: 'code_implementation',
-    projectPath: '/test',
-  };
-
-  const mockExecutor: EnforcementExecutor = {
-    execute: jest.fn(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    // Use the singleton instance
-    interceptor = ConstraintInterceptor.getInstance();
-    // Clear any previous state
-    interceptor.clearSkips();
-    interceptor.setEnabled(true);
-
-    mockChecker.getConstraints.mockReturnValue({
-      ironLaws: { test_iron_law: mockIronLaw },
-      guidelines: { test_guideline: mockGuideline },
-      prompts: {},
-    });
-  });
-
-  describe('getInstance', () => {
-    it('should return singleton instance', () => {
-      const instance1 = ConstraintInterceptor.getInstance();
-      const instance2 = ConstraintInterceptor.getInstance();
-      expect(instance1).toBe(instance2);
-    });
-  });
-
-  describe('register', () => {
-    it('should register executor', () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      expect(interceptor.hasExecutor('test-enforcement')).toBe(true);
-    });
-  });
-
-  describe('registerBatch', () => {
-    it('should register multiple executors', () => {
-      interceptor.registerBatch([
-        { enforcementId: 'exec1', executor: mockExecutor },
-        { enforcementId: 'exec2', executor: mockExecutor },
-      ]);
-      expect(interceptor.hasExecutor('exec1')).toBe(true);
-      expect(interceptor.hasExecutor('exec2')).toBe(true);
-    });
-  });
-
-  describe('unregister', () => {
-    it('should unregister executor', () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      const result = interceptor.unregister('test-enforcement');
-      expect(result).toBe(true);
-      expect(interceptor.hasExecutor('test-enforcement')).toBe(false);
-    });
-
-    it('should return false if not exists', () => {
-      const result = interceptor.unregister('nonexistent');
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('getExecutor', () => {
-    it('should return registered executor', () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      const executor = interceptor.getExecutor('test-enforcement');
-      expect(executor).toBe(mockExecutor);
-    });
-
-    it('should return undefined if not registered', () => {
-      const executor = interceptor.getExecutor('nonexistent');
-      expect(executor).toBeUndefined();
-    });
-  });
-
-  describe('getRegistrations', () => {
-    it('should return all registrations', () => {
-      interceptor.unregister('test-enforcement'); // Clear any existing
-      interceptor.register('test-enforcement', mockExecutor);
-      const registrations = interceptor.getRegistrations();
-      const found = registrations.find(r => r.id === 'test-enforcement');
-      expect(found).toBeDefined();
-    });
-  });
-
-  describe('setEnabled', () => {
-    it('should disable interceptor', () => {
-      interceptor.setEnabled(false);
-      interceptor.register('test-enforcement', mockExecutor);
-
-      const result = interceptor.intercept('code_implementation', mockContext);
-      // When disabled, should pass without checking
-      expect(result).resolves.toHaveProperty('passed', true);
-    });
-  });
-
-  describe('skip', () => {
-    it('should skip specified enforcements', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      interceptor.skip(['test-enforcement']);
-
-      const result = await interceptor.intercept('code_implementation', mockContext);
-      expect(result.constraints.some(c => c.skipped)).toBe(true);
-    });
-  });
-
-  describe('clearSkips', () => {
-    it('should clear all skips', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      interceptor.skip(['test-enforcement']);
-      interceptor.clearSkips();
-
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
-      await interceptor.intercept('code_implementation', mockContext);
-      expect(mockExecutor.execute).toHaveBeenCalled();
-    });
-  });
-
-  describe('intercept', () => {
-    it('should pass when all constraints satisfied', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      interceptor.register('guideline-enforcement', mockExecutor);
-
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
-
-      const result = await interceptor.intercept('code_implementation', mockContext);
-      expect(result.passed).toBe(true);
-      expect(result.violations.length).toBe(0);
-    });
-
-    it('should fail on iron law violation', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: false });
-
-      await expect(interceptor.intercept('code_implementation', mockContext)).rejects.toThrow();
-    });
-
-    it('should record guideline violation without throwing', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      interceptor.register('guideline-enforcement', mockExecutor);
-
-      (mockExecutor.execute as jest.Mock)
-        .mockResolvedValueOnce({ passed: true })  // iron law passes
-        .mockResolvedValueOnce({ passed: false }); // guideline fails
-
-      const result = await interceptor.intercept('code_implementation', mockContext);
-      expect(result.passed).toBe(true); // guidelines don't block
-      expect(result.violations.length).toBe(1);
-    });
-
-    it('should handle missing executor', async () => {
-      // No constraints at all
-      mockChecker.getConstraints.mockReturnValue({
-        ironLaws: {},
-        guidelines: {},
-        prompts: {},
-      });
-
-      const result = await interceptor.intercept('code_implementation', mockContext);
-      expect(result.passed).toBe(true);
-      expect(result.constraints.length).toBe(0);
-    });
-
-    it('should handle executor error for iron law', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockRejectedValue(new Error('Executor error'));
-
-      await expect(interceptor.intercept('code_implementation', mockContext)).rejects.toThrow();
-    });
-  });
-
-  describe('claim', () => {
-    it('should pass when constraints satisfied', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
-
-      await expect(interceptor.claim('code_implementation', mockContext)).resolves.not.toThrow();
-    });
-
-    it('should throw on violation', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: false });
-
-      await expect(interceptor.claim('code_implementation', mockContext)).rejects.toThrow();
-    });
-  });
-
-  describe('canProceed', () => {
-    it('should return true when passed', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
-
-      const result = await interceptor.canProceed('code_implementation', mockContext);
-      expect(result).toBe(true);
-    });
-
-    it('should return false on error', async () => {
-      interceptor.register('test-enforcement', mockExecutor);
-      (mockExecutor.execute as jest.Mock).mockRejectedValue(new Error('Error'));
-
-      const result = await interceptor.canProceed('code_implementation', mockContext);
-      expect(result).toBe(false);
-    });
-  });
-});