@dommaker/harness 1.5.0 → 1.7.0

package/src/core/session/__tests__/startup.test.ts

@@ -1,281 +0,0 @@
-/**
- * SessionStartup 测试
- */
-
-import { SessionStartup } from '../startup';
-import { exec } from 'child_process';
-import * as fs from 'fs/promises';
-
-// Mock dependencies
-jest.mock('child_process', () => ({
-  exec: jest.fn(),
-}));
-
-jest.mock('fs/promises', () => ({
-  readFile: jest.fn(),
-  access: jest.fn(),
-}));
-
-const mockExec = exec as unknown as jest.Mock;
-const mockFs = fs as jest.Mocked<typeof fs>;
-
-describe('SessionStartup', () => {
-  let startup: SessionStartup;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    startup = new SessionStartup('/test/project', {
-      required: ['pwd'],
-      optional: [],
-    });
-  });
-
-  describe('constructor', () => {
-    it('should accept workDir and checkpoints', () => {
-      expect(startup).toBeDefined();
-    });
-  });
-
-  describe('run()', () => {
-    it('should run required checkpoints', async () => {
-      const result = await startup.run();
-
-      expect(result.results.length).toBe(1);
-      expect(result.results[0].type).toBe('pwd');
-    });
-
-    it('should return success when all required pass', async () => {
-      const result = await startup.run();
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should run optional checkpoints', async () => {
-      const s = new SessionStartup('/test', {
-        required: ['pwd'],
-        optional: ['git_status'],
-      });
-
-      mockExec.mockImplementation((cmd, opts, callback) => {
-        callback(null, { stdout: '', stderr: '' });
-      });
-
-      const result = await s.run();
-
-      expect(result.results.length).toBe(2);
-    });
-  });
-
-  describe('checkpoints', () => {
-    describe('pwd', () => {
-      it('should return workDir', async () => {
-        const s = new SessionStartup('/my/project', {
-          required: ['pwd'],
-          optional: [],
-        });
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-        expect(result.results[0].data).toBe('/my/project');
-      });
-    });
-
-    describe('git_log', () => {
-      it('should check git log', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['git_log'],
-          optional: [],
-        });
-
-        mockExec.mockImplementation((cmd, opts, callback) => {
-          callback(null, { stdout: 'abc123 Initial commit', stderr: '' });
-        });
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-      });
-    });
-
-    describe('git_status', () => {
-      it('should check git status', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['git_status'],
-          optional: [],
-        });
-
-        mockExec.mockImplementation((cmd, opts, callback) => {
-          if (cmd.includes('git status')) {
-            callback(null, { stdout: 'On branch main\nnothing to commit', stderr: '' });
-          } else {
-            callback(null, { stdout: '', stderr: '' });
-          }
-        });
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-      });
-    });
-
-    describe('read_progress', () => {
-      it('should read progress file', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['read_progress'],
-          optional: [],
-        });
-
-        mockFs.readFile.mockResolvedValueOnce('# Progress\n- Task 1 done');
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-      });
-
-      it('should return null for missing file', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['read_progress'],
-          optional: [],
-        });
-
-        mockFs.readFile.mockRejectedValueOnce(new Error('Not found'));
-
-        const result = await s.run();
-
-        // read_progress returns null on error, but doesn't fail
-        expect(result.results[0].success).toBe(true);
-        expect(result.results[0].data).toBeNull();
-      });
-    });
-
-    describe('read_task_list', () => {
-      it('should read task list', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['read_task_list'],
-          optional: [],
-        });
-
-        mockFs.access.mockResolvedValueOnce(undefined);
-        mockFs.readFile.mockResolvedValueOnce(JSON.stringify({ tasks: [] }));
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-      });
-
-      it('should handle missing task list', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['read_task_list'],
-          optional: [],
-        });
-
-        mockFs.access.mockRejectedValueOnce(new Error('Not found'));
-
-        const result = await s.run();
-
-        // 文件不存在时返回失败
-        expect(result.results[0].type).toBe('read_task_list');
-      });
-
-      it('should parse task list steps', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['read_task_list'],
-          optional: [],
-        });
-
-        mockFs.access.mockResolvedValueOnce(undefined);
-        mockFs.readFile.mockResolvedValueOnce(JSON.stringify({
-          tasks: [
-            { id: 'task-1', steps: [{ status: 'done' }] },
-          ],
-        }));
-
-        const result = await s.run();
-
-        expect(result.results[0].success).toBe(true);
-      });
-    });
-
-    describe('init_sh', () => {
-      it('should run init.sh', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['init_sh'],
-          optional: [],
-        });
-
-        mockExec.mockImplementation((cmd, opts, callback) => {
-          callback(null, { stdout: 'Init complete', stderr: '' });
-        });
-
-        const result = await s.run();
-
-        // init_sh 成功或失败取决于 mock 设置
-        expect(result.results[0].type).toBe('init_sh');
-      });
-    });
-
-    describe('basic_verification', () => {
-      it('should run basic verification', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['basic_verification'],
-          optional: [],
-        });
-
-        mockExec.mockImplementation((cmd, opts, callback) => {
-          callback(null, { stdout: 'Tests passed', stderr: '' });
-        });
-
-        const result = await s.run();
-
-        expect(result.results[0].type).toBe('basic_verification');
-      });
-    });
-
-    describe('load_context', () => {
-      it('should load context', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['load_context'],
-          optional: [],
-        });
-
-        mockFs.readFile.mockResolvedValueOnce('# Context\nSome content');
-
-        const result = await s.run();
-
-        expect(result.results[0].type).toBe('load_context');
-      });
-    });
-
-    describe('unknown checkpoint', () => {
-      it('should handle unknown checkpoint type', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['unknown_checkpoint' as any],
-          optional: [],
-        });
-
-        const result = await s.run();
-
-        expect(result.results[0].type).toBe('unknown_checkpoint');
-      });
-    });
-
-    describe('multiple checkpoints', () => {
-      it('should run all required and optional checkpoints', async () => {
-        const s = new SessionStartup('/test', {
-          required: ['pwd', 'git_log', 'git_status'],
-          optional: ['read_progress'],
-        });
-
-        mockExec.mockImplementation((cmd, opts, callback) => {
-          callback(null, { stdout: 'output', stderr: '' });
-        });
-        mockFs.readFile.mockResolvedValue('# Progress');
-
-        const result = await s.run();
-
-        expect(result.results.length).toBe(4);
-      });
-    });
-  });
-});

package/src/core/session/clean-state.ts

@@ -1,178 +0,0 @@
-/**
- * CleanStateManager - Session 结束状态管理
- * 
- * 确保 Agent 结束时必须"打扫干净"，不留烂代码。
- */
-
-import { execAsync } from '../../utils/exec';
-import { promisify } from 'util';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import type {
-  CleanStateConfig,
-  CleanStateResult,
-  DetectedBug,
-  SessionInfo,
-} from '../../types/session';
-
-
-const DEFAULT_CONFIG: Required<CleanStateConfig> = {
-  enabled: true,
-  autoCommit: true,
-  detectBugs: true,
-  updateProgress: true,
-  commitMessageTemplate: '[{taskId}] {description} - {status}',
-};
-
-const BUG_PATTERNS = [
-  { pattern: /console\.(error|warn)\(/, severity: 'low' as const, type: 'logic' as const },
-  { pattern: /FIXME|HACK/i, severity: 'medium' as const, type: 'logic' as const },
-  { pattern: /eval\s*\(/, severity: 'high' as const, type: 'security' as const },
-  { pattern: /dangerouslySetInnerHTML/, severity: 'medium' as const, type: 'security' as const },
-];
-
-export class CleanStateManager {
-  private config: Required<CleanStateConfig>;
-
-  constructor(config: Partial<CleanStateConfig> = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  async onSessionEnd(workDir: string, sessionInfo: SessionInfo): Promise<CleanStateResult> {
-    const result: CleanStateResult = { 
-      isClean: true, 
-      hasUncommittedChanges: false, 
-      progressUpdated: false, 
-      errors: [] 
-    };
-    
-    if (!this.config.enabled) return result;
-
-    try {
-      // 1. 检查未提交变更
-      result.hasUncommittedChanges = await this.hasUncommittedChanges(workDir);
-      
-      // 2. 自动提交（如果配置开启）
-      if (result.hasUncommittedChanges && this.config.autoCommit) {
-        result.committedFiles = await this.autoCommit(workDir, sessionInfo);
-      }
-      
-      // 3. 检测 bug（如果配置开启）
-      if (this.config.detectBugs) {
-        result.bugs = await this.detectBugs(workDir);
-        if (result.bugs.length > 0) result.isClean = false;
-      }
-      
-      // 4. 更新 progress（如果配置开启）
-      if (this.config.updateProgress) {
-        result.progressUpdated = await this.updateProgress(workDir, sessionInfo, result);
-      }
-    } catch (e: any) { 
-      result.errors?.push(e.message); 
-      result.isClean = false; 
-    }
-    
-    return result;
-  }
-
-  private async hasUncommittedChanges(workDir: string): Promise<boolean> {
-    try { 
-      const { stdout } = await execAsync('git status --porcelain', { cwd: workDir }); 
-      return stdout.trim().length > 0; 
-    } catch { 
-      return false; 
-    }
-  }
-
-  private async autoCommit(workDir: string, sessionInfo: SessionInfo): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync('git status --porcelain', { cwd: workDir });
-      const files = stdout.split('\n').filter(Boolean).map(l => l.substring(3).trim());
-      
-      await execAsync('git add -A', { cwd: workDir });
-      
-      // 生成提交消息
-      const msg = sessionInfo.task 
-        ? `[${sessionInfo.task.id}] ${sessionInfo.task.name || sessionInfo.task.id}`
-        : `[session] ${sessionInfo.workflowId}`;
-      
-      // 使用 execFile 避免 shell 注入
-      const { execFile: execFileCb } = await import('child_process');
-      const execFileAsync = promisify(execFileCb);
-      await execFileAsync('git', ['commit', '-m', msg], { cwd: workDir });
-      return files;
-    } catch { 
-      return []; 
-    }
-  }
-
-  private async detectBugs(workDir: string): Promise<DetectedBug[]> {
-    const bugs: DetectedBug[] = [];
-    try {
-      // 获取最近变更的文件
-      const { stdout } = await execAsync('git diff --name-only HEAD~1', { cwd: workDir });
-      
-      for (const file of stdout.split('\n').filter(Boolean)) {
-        // 只检查代码文件
-        if (!['.ts', '.tsx', '.js', '.jsx', '.py', '.go'].some(e => file.endsWith(e))) continue;
-        
-        try {
-          const content = await fs.readFile(path.join(workDir, file), 'utf-8');
-          const lines = content.split('\n');
-          
-          lines.forEach((line, i) => {
-            for (const { pattern, severity, type } of BUG_PATTERNS) {
-              if (pattern.test(line)) {
-                bugs.push({ 
-                  file, 
-                  line: i + 1, 
-                  message: `Detected pattern: ${pattern.source}`, 
-                  severity, 
-                  type 
-                });
-              }
-            }
-          });
-        } catch {
-          // 文件读取失败，跳过
-        }
-      }
-    } catch {}
-    return bugs;
-  }
-
-  private async updateProgress(workDir: string, sessionInfo: SessionInfo, cleanResult: CleanStateResult): Promise<boolean> {
-    const progressPath = path.join(workDir, '.harness', 'progress.yml');
-    try {
-      await fs.mkdir(path.dirname(progressPath), { recursive: true });
-      
-      // 读取现有 progress 或创建新的
-      let data: any = { sessions: [], last_updated: new Date().toISOString() };
-      try { 
-        data = yaml.load(await fs.readFile(progressPath, 'utf-8')) as any || data; 
-      } catch {}
-      
-      // 添加本次 session 记录
-      data.sessions.push({
-        id: sessionInfo.sessionId,
-        workflow: sessionInfo.workflowId,
-        task: sessionInfo.task?.id,
-        timestamp: new Date().toISOString(),
-        clean: cleanResult.isClean,
-        bugs: cleanResult.bugs?.length || 0,
-        committed: cleanResult.committedFiles?.length || 0,
-      });
-      
-      data.last_updated = new Date().toISOString();
-      
-      await fs.writeFile(progressPath, yaml.dump(data));
-      return true;
-    } catch { 
-      return false; 
-    }
-  }
-}
-
-export const createCleanStateManager = (config?: Partial<CleanStateConfig>) => 
-  new CleanStateManager(config);

package/src/core/session/index.ts

@@ -1,15 +0,0 @@
-/**
- * Session 模块导出
- */
-
-export { 
-  SessionStartup, 
-  createSessionStartup,
-  DEFAULT_CODE_CHECKPOINTS,
-  MINIMAL_CHECKPOINTS,
-} from './startup';
-
-export { 
-  CleanStateManager, 
-  createCleanStateManager,
-} from './clean-state';