@dommaker/harness 1.4.0 → 1.6.0

package/src/__tests__/clean-state-extra.test.ts

@@ -1,301 +0,0 @@
-/**
- * clean-state.ts 补充测试
- * 
- * 目标：覆盖 autoCommit、detectBugs 完整流程、异常分支
- */
-
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { CleanStateManager } from '../core/session/clean-state';
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-
-describe('CleanStateManager - 补充覆盖', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-clean-extra');
-
-  beforeAll(() => {
-    // 创建临时 git 仓库
-    fs.mkdirSync(tempDir, { recursive: true });
-    execSync('git init', { cwd: tempDir });
-    execSync('git config user.email "test@test.com"', { cwd: tempDir });
-    execSync('git config user.name "Test"', { cwd: tempDir });
-    
-    // 初始提交
-    const initialFile = path.join(tempDir, 'initial.txt');
-    fs.writeFileSync(initialFile, 'initial');
-    execSync('git add .', { cwd: tempDir });
-    execSync('git commit -m "init"', { cwd: tempDir });
-  });
-
-  afterAll(() => {
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  describe('autoCommit 流程', () => {
-    it('应该自动提交变更的文件', async () => {
-      // 创建新文件
-      const newFile = path.join(tempDir, 'new-file.ts');
-      fs.writeFileSync(newFile, 'export const x = 1;');
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: true,
-        detectBugs: false,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-ac-001',
-        workflowId: 'workflow-001',
-        task: { id: 'task-ac', name: 'AutoCommit Test' },
-      });
-
-      expect(result.hasUncommittedChanges).toBe(true);
-      expect(result.committedFiles).toBeDefined();
-      expect(result.committedFiles!.length).toBeGreaterThan(0);
-      
-      // 验证 git 状态干净
-      const status = execSync('git status --porcelain', { cwd: tempDir }).toString();
-      expect(status.trim()).toBe('');
-    });
-
-    it('无变更时不应提交', async () => {
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: true,
-        detectBugs: false,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-ac-002',
-        workflowId: 'workflow-002',
-      });
-
-      expect(result.hasUncommittedChanges).toBe(false);
-      expect(result.committedFiles).toBeUndefined();
-    });
-
-    it('无 task 信息时使用 workflowId 作为消息', async () => {
-      // 创建变更
-      const file = path.join(tempDir, 'no-task.ts');
-      fs.writeFileSync(file, 'export const y = 2;');
-      
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: true,
-        detectBugs: false,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-ac-003',
-        workflowId: 'workflow-no-task',
-      });
-
-      expect(result.committedFiles).toBeDefined();
-      
-      // 验证提交消息
-      const log = execSync('git log -1 --pretty=format:"%s"', { cwd: tempDir }).toString();
-      expect(log).toContain('workflow-no-task');
-    });
-  });
-
-  describe('detectBugs 完整流程', () => {
-    it('应该检测到安全漏洞 eval', async () => {
-      // 创建包含 eval 的文件
-      const buggyFile = path.join(tempDir, 'eval-bug.ts');
-      fs.writeFileSync(buggyFile, `
-const code = 'malicious';
-eval(code);
-`);
-      execSync('git add .', { cwd: tempDir });
-      execSync('git commit -m "add eval bug"', { cwd: tempDir });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: true,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-bug-001',
-        workflowId: 'workflow-bug',
-      });
-
-      // 应该检测到 eval
-      expect(result.bugs).toBeDefined();
-      expect(result.bugs!.length).toBeGreaterThan(0);
-      expect(result.isClean).toBe(false);
-
-      const evalBug = result.bugs!.find(b => b.message.includes('eval'));
-      expect(evalBug).toBeDefined();
-      expect(evalBug!.severity).toBe('high');
-      expect(evalBug!.type).toBe('security');
-    });
-
-    it('应该检测 dangerouslySetInnerHTML', async () => {
-      const reactFile = path.join(tempDir, 'danger.tsx');
-      fs.writeFileSync(reactFile, `
-<div dangerouslySetInnerHTML={{ __html: userInput }} />
-`);
-      execSync('git add .', { cwd: tempDir });
-      execSync('git commit -m "add danger bug"', { cwd: tempDir });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: true,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-bug-002',
-        workflowId: 'workflow-bug',
-      });
-
-      expect(result.bugs).toBeDefined();
-      const dangerBug = result.bugs!.find(b => b.message.includes('dangerouslySetInnerHTML'));
-      expect(dangerBug).toBeDefined();
-      expect(dangerBug!.severity).toBe('medium');
-    });
-
-    it('应该检测 FIXME 和 HACK 注释', async () => {
-      const fixmeFile = path.join(tempDir, 'fixme.ts');
-      fs.writeFileSync(fixmeFile, `
-// FIXME: 需要重构
-function hack() {
-  // HACK: 临时方案
-}
-`);
-      execSync('git add .', { cwd: tempDir });
-      execSync('git commit -m "add fixme"', { cwd: tempDir });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: true,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-bug-003',
-        workflowId: 'workflow-bug',
-      });
-
-      expect(result.bugs).toBeDefined();
-      const fixmeBug = result.bugs!.find(b => b.message.includes('FIXME'));
-      expect(fixmeBug).toBeDefined();
-      expect(fixmeBug!.severity).toBe('medium');
-    });
-
-    it('非代码文件应该被跳过', async () => {
-      const textFile = path.join(tempDir, 'readme.txt');
-      fs.writeFileSync(textFile, 'console.error("test")');
-      execSync('git add .', { cwd: tempDir });
-      execSync('git commit -m "add text file"', { cwd: tempDir });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: true,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-bug-004',
-        workflowId: 'workflow-bug',
-      });
-
-      // .txt 文件应该被跳过
-      const txtBug = result.bugs?.find(b => b.file.includes('.txt'));
-      expect(txtBug).toBeUndefined();
-    });
-
-    it('git diff 失败应该返回空数组', async () => {
-      // 非 git 目录
-      const nonGitDir = path.join(process.cwd(), 'temp-non-git');
-      fs.mkdirSync(nonGitDir, { recursive: true });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: true,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(nonGitDir, {
-        sessionId: 'session-bug-005',
-        workflowId: 'workflow-bug',
-      });
-
-      expect(result.bugs).toEqual([]);
-
-      fs.rmSync(nonGitDir, { recursive: true, force: true });
-    });
-  });
-
-  describe('updateProgress 异常处理', () => {
-    it('progress 写入失败应该返回 false', async () => {
-      // 使用只读目录
-      const readOnlyDir = path.join(process.cwd(), 'temp-readonly');
-      fs.mkdirSync(readOnlyDir, { recursive: true });
-      
-      // 先初始化 git（否则 hasUncommittedChanges 会失败）
-      execSync('git init', { cwd: readOnlyDir });
-      execSync('git config user.email "test@test.com"', { cwd: readOnlyDir });
-      execSync('git config user.name "Test"', { cwd: readOnlyDir });
-      
-      const initialFile = path.join(readOnlyDir, 'init.txt');
-      fs.writeFileSync(initialFile, 'init');
-      execSync('git add .', { cwd: readOnlyDir });
-      execSync('git commit -m "init"', { cwd: readOnlyDir });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: false,
-        updateProgress: true,
-      });
-
-      const result = await manager.onSessionEnd(readOnlyDir, {
-        sessionId: 'session-prog-001',
-        workflowId: 'workflow-prog',
-        task: { id: 'task-prog', name: 'Progress Test' },
-      });
-
-      // progressUpdated 可能为 true（成功写入）或 false（失败）
-      // 不再强求 false，因为现在可以成功写入
-      expect(result).toBeDefined();
-
-      fs.rmSync(readOnlyDir, { recursive: true, force: true });
-    });
-  });
-
-  describe('hasUncommittedChanges', () => {
-    it('干净的工作目录应该返回 false', async () => {
-      // 使用已有的 git 仓库，确保干净状态
-      execSync('git checkout .', { cwd: tempDir, stdio: 'pipe' });
-      execSync('git clean -fd', { cwd: tempDir, stdio: 'pipe' });
-
-      const manager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: false,
-        updateProgress: false,
-      });
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-check-001',
-        workflowId: 'workflow-check',
-      });
-
-      expect(result.hasUncommittedChanges).toBe(false);
-    });
-  });
-});

package/src/__tests__/clean-state.test.ts

@@ -1,169 +0,0 @@
-/**
- * CleanStateManager 测试
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
-import { CleanStateManager } from '../core/session/clean-state';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('CleanStateManager', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-clean');
-  let manager: CleanStateManager;
-
-  beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterAll(() => {
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  beforeEach(() => {
-    manager = new CleanStateManager({
-      enabled: true,
-      autoCommit: false,  // 禁用自动提交
-      detectBugs: true,
-      updateProgress: false,
-    });
-  });
-
-  describe('onSessionEnd', () => {
-    it('禁用应该返回空结果', async () => {
-      const disabledManager = new CleanStateManager({ enabled: false });
-
-      const result = await disabledManager.onSessionEnd(tempDir, {
-        sessionId: 'session-001',
-        workflowId: 'workflow-001',
-      });
-
-      expect(result.isClean).toBe(true);
-      expect(result.hasUncommittedChanges).toBe(false);
-    });
-
-    it('应该运行 bug 检测', async () => {
-      // Bug 检测需要扫描目录中的文件
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-001',
-        workflowId: 'workflow-001',
-      });
-
-      // 只验证运行不崩溃
-      expect(result).toBeDefined();
-    });
-
-    it('安全文件应该通过', async () => {
-      // 创建安全的文件
-      const safeFile = path.join(tempDir, 'safe.ts');
-      fs.writeFileSync(safeFile, `
-export function hello() {
-  return 'world';
-}
-`);
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-002',
-        workflowId: 'workflow-002',
-      });
-
-      expect(result.isClean).toBe(true);
-    });
-  });
-
-  describe('配置', () => {
-    it('应该支持自定义配置', () => {
-      const customManager = new CleanStateManager({
-        detectBugs: false,
-        autoCommit: false,
-      });
-
-      expect(customManager).toBeDefined();
-    });
-  });
-
-  describe('错误处理', () => {
-    it('不存在目录应该返回结果', async () => {
-      const result = await manager.onSessionEnd('/nonexistent/path', {
-        sessionId: 'session-003',
-        workflowId: 'workflow-003',
-      });
-
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('自动提交', () => {
-    it('禁用自动提交应该跳过', async () => {
-      const noCommitManager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-      });
-
-      const result = await noCommitManager.onSessionEnd(tempDir, {
-        sessionId: 'session-004',
-        workflowId: 'workflow-004',
-      });
-
-      expect(result.committedFiles).toBeUndefined();
-    });
-  });
-
-  describe('Progress 更新', () => {
-    it('应该更新 progress 文件', async () => {
-      const progressManager = new CleanStateManager({
-        enabled: true,
-        autoCommit: false,
-        detectBugs: false,
-        updateProgress: true,
-      });
-
-      const result = await progressManager.onSessionEnd(tempDir, {
-        sessionId: 'session-005',
-        workflowId: 'workflow-005',
-        task: { id: 'task-001', name: 'Test Task' },
-      });
-
-      expect(result.progressUpdated).toBe(true);
-    });
-  });
-
-  describe('Bug 检测', () => {
-    it('应该检测 console.error', async () => {
-      const bugFile = path.join(tempDir, 'buggy.ts');
-      fs.writeFileSync(bugFile, `
-console.error('Something went wrong');
-`);
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-006',
-        workflowId: 'workflow-006',
-      });
-
-      // Bug 检测运行了，但可能找不到变更（没有 git 历史）
-      expect(result).toBeDefined();
-
-      fs.rmSync(bugFile, { force: true });
-    });
-
-    it('应该检测 FIXME 注释', async () => {
-      const fixmeFile = path.join(tempDir, 'fixme.ts');
-      fs.writeFileSync(fixmeFile, `
-// FIXME: This is a hack
-function hack() {}
-`);
-
-      const result = await manager.onSessionEnd(tempDir, {
-        sessionId: 'session-007',
-        workflowId: 'workflow-007',
-      });
-
-      expect(result).toBeDefined();
-
-      fs.rmSync(fixmeFile, { force: true });
-    });
-  });
-});

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

@@ -1,132 +0,0 @@
-/**
- * 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: [],
-    passed: true,
-    warningCount: 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() }],
-    passed: false,
-    warningCount: 1,
-  };
-}
-
-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__/passes-gate-extra.test.ts

@@ -1,93 +0,0 @@
-/**
- * PassesGate 补充测试 - 覆盖重试逻辑和 runTests
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
-import { PassesGate, createPassesGate } from '../core/validators/passes-gate';
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-describe('PassesGate - 补充覆盖', () => {
-  const tempDir = join(process.cwd(), 'temp-test-passes-extra');
-  let gate: PassesGate;
-
-  beforeAll(() => {
-    mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterAll(() => {
-    try {
-      rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  beforeEach(() => {
-    gate = createPassesGate({
-      enabled: true,
-      testCommand: 'npm test',
-      requireEvidence: false,
-      maxRetries: 1,
-      retryDelay: 100,
-    });
-  });
-
-  describe('runTests', () => {
-    // runTests 方法会实际执行测试命令，在测试环境中跳过
-    // 这些测试在 passes-gate.test.ts 中已经有类似覆盖
-    it.skip('应该返回测试结果统计', async () => {
-      // 这个测试会实际运行 npm test，在 CI 环境中可能超时
-    });
-  });
-
-  describe('setPasses 重试逻辑', () => {
-    it('测试失败应该返回不允许', async () => {
-      // 创建会失败的测试命令
-      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
-        name: 'fail-project',
-        scripts: { test: 'exit 1' },
-      }));
-
-      const failGate = createPassesGate({
-        enabled: true,
-        testCommand: 'npm test',
-        maxRetries: 0,
-        retryDelay: 10,
-      });
-
-      const result = await failGate.setPasses('fail-task', true, tempDir);
-      
-      expect(result.allowed).toBe(false);
-      expect(result.attempts).toBeGreaterThan(0);
-      expect(result.error).toBeDefined();
-    });
-
-    it('证据不存在应该返回不允许', async () => {
-      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
-        name: 'evidence-project',
-        scripts: { test: 'echo "1 passed"' },
-      }));
-
-      const evidenceGate = createPassesGate({
-        enabled: true,
-        testCommand: 'npm test',
-        requireEvidence: true,
-      });
-
-      const result = await evidenceGate.setPasses('evidence-task', true, tempDir);
-      
-      // 证据会自动生成在 .agent/evidence 目录
-      // requireEvidence=true 时需要验证证据存在
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('checkTestFileChanges', () => {
-    it('应该检测测试文件变更', async () => {
-      const changes = await gate.checkTestFileChanges(tempDir);
-      
-      expect(Array.isArray(changes)).toBe(true);
-    });
-  });
-});