@dommaker/harness 0.13.0 → 0.13.2

package/src/__tests__/cso-validator.test.ts

@@ -0,0 +1,205 @@
+/**
+ * CSOValidator 测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { CSOValidator } from '../core/validators/cso';
+import type { WorkflowMeta, StepMeta, ToolMeta } from '../types/cso';
+
+describe('CSOValidator', () => {
+  const validator = CSOValidator.getInstance();
+
+  describe('单例模式', () => {
+    it('应该返回单例实例', () => {
+      const instance1 = CSOValidator.getInstance();
+      const instance2 = CSOValidator.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('validateWorkflow', () => {
+    it('有效的描述应该通过', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '用于处理用户登录场景，验证身份并创建会话',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.valid).toBe(true);
+      expect(result.message).toContain('符合');
+    });
+
+    it('包含工作流关键词应该失败', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '首先验证用户身份，然后创建会话，最后返回令牌',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues).toBeDefined();
+      expect(result.issues?.some(i => i.type === 'workflow_summary')).toBe(true);
+    });
+
+    it('缺少触发关键词应该失败', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '验证用户身份并创建会话',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues?.some(i => i.type === 'missing_trigger')).toBe(true);
+    });
+
+    it('描述过长应该失败', () => {
+      const longDesc = '用于处理用户登录场景，验证身份并创建会话'.repeat(12); // 228字符
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: longDesc,
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.issues?.some(i => i.type === 'too_long')).toBe(true);
+    });
+
+    it('多个问题应该全部返回', () => {
+      const longDesc = '首先验证用户身份然后创建会话'.repeat(10);
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: longDesc,
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues?.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('validateStep', () => {
+    it('有效的步骤描述应该通过', () => {
+      const step: StepMeta = {
+        name: 'validate-user',
+        description: '用于验证用户身份时，检查令牌有效性',
+      };
+
+      const result = validator.validateStep(step);
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('无效的步骤描述应该失败', () => {
+      const step: StepMeta = {
+        name: 'validate-user',
+        description: 'Step 1: 验证令牌',
+      };
+
+      const result = validator.validateStep(step);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues?.some(i => i.type === 'workflow_summary')).toBe(true);
+    });
+  });
+
+  describe('validateTool', () => {
+    it('有效的工具描述应该通过', () => {
+      const tool: ToolMeta = {
+        name: 'auth-tool',
+        description: '用于认证场景，提供登录和令牌验证功能',
+      };
+
+      const result = validator.validateTool(tool);
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('无效的工具描述应该失败', () => {
+      const tool: ToolMeta = {
+        name: 'auth-tool',
+        description: '首先调用登录API',
+      };
+
+      const result = validator.validateTool(tool);
+
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('建议生成', () => {
+    it('无效描述应该包含建议', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '验证用户身份',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.suggestion).toBeDefined();
+      expect(result.suggestion).toContain('建议');
+    });
+
+    it('有效描述不应该包含建议', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '用于验证用户身份',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.suggestion).toBeUndefined();
+    });
+  });
+
+  describe('中文支持', () => {
+    it('中文触发关键词应该被识别', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '当用户登录时，验证身份',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.issues?.some(i => i.type === 'missing_trigger')).toBe(false);
+    });
+
+    it('中文工作流关键词应该被识别', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: '首先检查权限，然后执行操作',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.issues?.some(i => i.type === 'workflow_summary')).toBe(true);
+    });
+  });
+
+  describe('英文支持', () => {
+    it('英文触发关键词应该被识别', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: 'Use for user authentication scenarios',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.issues?.some(i => i.type === 'missing_trigger')).toBe(false);
+    });
+
+    it('英文工作流关键词应该被识别', () => {
+      const workflow: WorkflowMeta = {
+        name: 'test-workflow',
+        description: 'First validate the token, then create session',
+      };
+
+      const result = validator.validateWorkflow(workflow);
+
+      expect(result.issues?.some(i => i.type === 'workflow_summary')).toBe(true);
+    });
+  });
+});

package/src/__tests__/detect-source-roots.test.ts

@@ -0,0 +1,98 @@
+/**
+ * detectSourceRoots 测试
+ */
+
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { detectSourceRoots } from '../utils/detect-source-roots';
+
+const tempDir = join(__dirname, '__temp_detect_source_roots__');
+
+beforeEach(() => {
+  if (existsSync(tempDir)) rmSync(tempDir, { recursive: true, force: true });
+  mkdirSync(tempDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(tempDir)) rmSync(tempDir, { recursive: true, force: true });
+});
+
+function touchFile(dir: string, name: string) {
+  const filePath = join(dir, name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, '// test');
+}
+
+describe('detectSourceRoots', () => {
+  it('单 repo: src/ 目录', () => {
+    touchFile(join(tempDir, 'src'), 'index.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('src');
+  });
+
+  it('单 repo: lib/ 目录', () => {
+    touchFile(join(tempDir, 'lib'), 'index.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('lib');
+  });
+
+  it('空项目返回空数组', () => {
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toEqual([]);
+  });
+
+  it('monorepo: packages/*/src', () => {
+    touchFile(join(tempDir, 'packages', 'core', 'src'), 'index.ts');
+    touchFile(join(tempDir, 'packages', 'utils', 'src'), 'util.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('packages/core/src');
+    expect(roots).toContain('packages/utils/src');
+  });
+
+  it('monorepo: packages/*/lib', () => {
+    touchFile(join(tempDir, 'packages', 'mylib', 'lib'), 'index.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('packages/mylib/lib');
+  });
+
+  it('monorepo: apps/*/src/modules/*', () => {
+    touchFile(join(tempDir, 'apps', 'api', 'src', 'modules', 'auth'), 'index.ts');
+    touchFile(join(tempDir, 'apps', 'api', 'src', 'modules', 'users'), 'handler.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('apps/api/src/modules/auth');
+    expect(roots).toContain('apps/api/src/modules/users');
+  });
+
+  it('排除 .d.ts 文件（只有类型声明不视为源码目录）', () => {
+    const dtsDir = join(tempDir, 'types');
+    mkdirSync(dtsDir, { recursive: true });
+    writeFileSync(join(dtsDir, 'index.d.ts'), 'export type Foo = string;');
+    const roots = detectSourceRoots(tempDir);
+    // types/ 只有 .d.ts → 不应被返回
+    expect(roots.filter(r => r.includes('types'))).toEqual([]);
+  });
+
+  it('跳过 __tests__, node_modules, dist, 隐藏目录', () => {
+    touchFile(join(tempDir, 'src'), 'index.ts');
+    touchFile(join(tempDir, 'src', '__tests__'), 'test.ts');
+    touchFile(join(tempDir, 'src', 'node_modules', 'pkg'), 'index.ts');
+    touchFile(join(tempDir, 'packages', '.internal', 'src'), 'index.ts');
+    const roots = detectSourceRoots(tempDir);
+    // src/ 本身被包含，但 __tests__ 等子目录不影响
+    expect(roots).toContain('src');
+    // packages/.internal 的 src/ 也应该被发现
+    expect(roots.some(r => r.includes('.internal'))).toBe(false);
+    // 只要 src/ 下有 .ts 就算
+    expect(roots.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('混合结构: packages + apps + src', () => {
+    touchFile(join(tempDir, 'src'), 'main.ts');
+    touchFile(join(tempDir, 'packages', 'core', 'src'), 'index.ts');
+    touchFile(join(tempDir, 'apps', 'api', 'src', 'modules', 'auth'), 'index.ts');
+    const roots = detectSourceRoots(tempDir);
+    expect(roots).toContain('src');
+    expect(roots).toContain('packages/core/src');
+    expect(roots).toContain('apps/api/src/modules/auth');
+  });
+});

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

@@ -0,0 +1,381 @@
+/**
+ * ConstraintDoctor 和 ConstraintEvolver 测试
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { TraceCollector } from '../monitoring/traces';
+import { TraceAnalyzer } from '../monitoring/trace-analyzer';
+import { ConstraintDoctor, createDoctor } from '../monitoring/constraint-doctor';
+import { ConstraintEvolver, createEvolver } from '../monitoring/constraint-evolver';
+import type { ExecutionTrace, TraceAnomaly } from '../types/trace';
+import type { Diagnosis } from '../monitoring/constraint-doctor';
+import type { ConstraintProposal } from '../monitoring/constraint-evolver';
+
+describe('ConstraintDoctor', () => {
+  let tempDir: string;
+  let collector: TraceCollector;
+  let analyzer: TraceAnalyzer;
+  let doctor: ConstraintDoctor;
+
+  beforeEach(() => {
+    tempDir = path.join(os.tmpdir(), `harness-traces-${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+    collector = new TraceCollector({
+      traceFile: path.join(tempDir, 'execution.log'),
+      enabled: true,
+    });
+    analyzer = new TraceAnalyzer(collector);
+    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);
+  });
+});
+
+describe('ConstraintEvolver', () => {
+  let tempDir: string;
+  let evolver: ConstraintEvolver;
+  let doctor: ConstraintDoctor;
+
+  beforeEach(() => {
+    tempDir = path.join(os.tmpdir(), `harness-proposals-${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+    evolver = createEvolver(tempDir);
+    doctor = createDoctor();
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  test('should propose from diagnosis', async () => {
+    const diagnosis: Diagnosis = {
+      anomalyId: 'test-anomaly-1',
+      constraintId: 'no_fix_without_root_cause',
+      diagnosedAt: Date.now(),
+      rootCause: {
+        primary: '约束过于严格',
+        secondary: ['缺少例外条件'],
+        evidence: [],
+      },
+      impact: {
+        severity: 'medium',
+        scope: 'single_project',
+        userImpact: '用户频繁绕过',
+      },
+      recommendations: [
+        {
+          type: 'add_exception',
+          content: '添加 typo 例外',
+          expectedOutcome: '绕过率降低',
+          implementationCost: 'low',
+        },
+      ],
+      needsChange: true,
+      urgency: 'medium',
+    };
+
+    const proposal = await evolver.propose(diagnosis);
+
+    expect(proposal).not.toBeNull();
+    expect(proposal!.constraintId).toBe('no_fix_without_root_cause');
+    expect(proposal!.type).toBe('add_exception');
+    expect(proposal!.status).toBe('proposed');
+  });
+
+  test('should not propose for diagnosis without change', async () => {
+    const diagnosis: Diagnosis = {
+      anomalyId: 'no-change',
+      constraintId: 'some_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();
+  });
+
+  test('should review low risk proposal', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'test-proposal-1',
+      proposedAt: Date.now(),
+      diagnosisId: 'test-anomaly',
+      constraintId: 'some_guideline',
+      type: 'add_exception',
+      content: {
+        proposed: 'new_exception',
+        description: 'Add exception',
+      },
+      reasoning: 'Test',
+      expectedOutcome: 'Better',
+      risk: { level: 'low', description: 'Low risk' },
+      implementation: { files: [], linesChanged: 5, testsRequired: true },
+      status: 'proposed',
+    };
+
+    const review = evolver.review(proposal);
+    expect(review.accepted).toBe(true);
+  });
+
+  test('should review iron_law modification carefully', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'iron-law-proposal',
+      proposedAt: Date.now(),
+      diagnosisId: 'iron-anomaly',
+      constraintId: 'no_self_approval', // Iron law that exists
+      type: 'modify_message', // Not add_exception
+      content: {
+        proposed: 'Change message',
+        description: 'Modify iron law',
+      },
+      reasoning: 'Test',
+      expectedOutcome: 'Test',
+      risk: { level: 'medium', description: 'Medium risk' },
+      implementation: { files: [], linesChanged: 10, testsRequired: true },
+      status: 'proposed',
+    };
+
+    const review = evolver.review(proposal);
+    expect(review.accepted).toBe(false);
+    expect(review.comment).toContain('Iron Law');
+  });
+
+  test('should generate implementation instructions', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'impl-test',
+      proposedAt: Date.now(),
+      diagnosisId: 'test',
+      constraintId: 'some_constraint',
+      type: 'add_exception',
+      content: {
+        proposed: 'new_exception',
+        description: 'Add exception',
+      },
+      reasoning: 'Test',
+      expectedOutcome: 'Test',
+      risk: { level: 'low', description: 'Low risk' },
+      implementation: { files: ['definitions.ts'], linesChanged: 5, testsRequired: true },
+      status: 'accepted',
+    };
+
+    const impl = evolver.implement(proposal);
+
+    expect(impl.instructions.length).toBeGreaterThan(0);
+    expect(impl.filesToModify).toContain('src/core/constraints/definitions.ts');
+    expect(impl.testsToRun.length).toBeGreaterThan(0);
+  });
+
+  test('should save and load proposal', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'save-test',
+      proposedAt: Date.now(),
+      diagnosisId: 'test',
+      constraintId: 'test_constraint',
+      type: 'add_exception',
+      content: { proposed: 'test', description: 'Test' },
+      reasoning: 'Test',
+      expectedOutcome: 'Test',
+      risk: { level: 'low', description: 'Low' },
+      implementation: { files: [], linesChanged: 1, testsRequired: false },
+      status: 'proposed',
+    };
+
+    evolver.saveProposal(proposal);
+
+    const loaded = evolver.loadProposal('save-test');
+    expect(loaded.constraintId).toBe('test_constraint');
+    expect(loaded.status).toBe('proposed');
+  });
+
+  test('should list proposals', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'list-test',
+      proposedAt: Date.now(),
+      diagnosisId: 'test',
+      constraintId: 'test',
+      type: 'add_exception',
+      content: { proposed: 'test', description: 'Test' },
+      reasoning: 'Test',
+      expectedOutcome: 'Test',
+      risk: { level: 'low', description: 'Low' },
+      implementation: { files: [], linesChanged: 1, testsRequired: false },
+      status: 'proposed',
+    };
+
+    evolver.saveProposal(proposal);
+
+    const proposals = evolver.listProposals('proposed');
+    expect(proposals.length).toBe(1);
+    expect(proposals[0].id).toBe('list-test');
+  });
+
+  test('should update proposal status', async () => {
+    const proposal: ConstraintProposal = {
+      id: 'status-test',
+      proposedAt: Date.now(),
+      diagnosisId: 'test',
+      constraintId: 'test',
+      type: 'add_exception',
+      content: { proposed: 'test', description: 'Test' },
+      reasoning: 'Test',
+      expectedOutcome: 'Test',
+      risk: { level: 'low', description: 'Low' },
+      implementation: { files: [], linesChanged: 1, testsRequired: false },
+      status: 'proposed',
+    };
+
+    evolver.saveProposal(proposal);
+    evolver.updateProposalStatus('status-test', 'accepted', 'Looks good');
+
+    const loaded = evolver.loadProposal('status-test');
+    expect(loaded.status).toBe('accepted');
+    expect(loaded.reviewComment).toBe('Looks good');
+  });
+});