@dommaker/harness 0.13.0 → 0.13.2

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

@@ -0,0 +1,334 @@
+/**
+ * SessionStartup 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import { SessionStartup, createSessionStartup, DEFAULT_CODE_CHECKPOINTS, MINIMAL_CHECKPOINTS } from '../core/session/startup';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+describe('SessionStartup', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-session');
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  describe('run', () => {
+    it('应该运行 pwd 检查点', async () => {
+      const startup = new SessionStartup(tempDir, {
+        required: ['pwd'],
+        optional: [],
+      });
+
+      const result = await startup.run();
+
+      expect(result.success).toBe(true);
+      expect(result.results.length).toBe(1);
+      expect(result.results[0].type).toBe('pwd');
+    });
+
+    it('应该运行 git_status 检查点', async () => {
+      const startup = new SessionStartup(tempDir, {
+        required: ['git_status'],
+        optional: [],
+      });
+
+      const result = await startup.run();
+
+      expect(result.results.length).toBe(1);
+      expect(result.results[0].type).toBe('git_status');
+    });
+
+    it('可选检查点失败不应该影响 success', async () => {
+      const startup = new SessionStartup(tempDir, {
+        required: ['pwd'],
+        optional: ['git_log'],
+      });
+
+      const result = await startup.run();
+
+      expect(result.success).toBe(true);
+      expect(result.results.length).toBe(2);
+    });
+
+    it('必要检查点失败应该影响 success', async () => {
+      const startup = new SessionStartup('/nonexistent/path', {
+        required: ['pwd'],
+        optional: [],
+      });
+
+      const result = await startup.run();
+
+      expect(result.results.length).toBe(1);
+    });
+  });
+
+  describe('检查点数据', () => {
+    it('pwd 应该返回当前目录', async () => {
+      const startup = new SessionStartup(tempDir, {
+        required: ['pwd'],
+        optional: [],
+      });
+
+      const result = await startup.run();
+      const pwdResult = result.results.find(r => r.type === 'pwd');
+
+      expect(pwdResult?.data).toBeDefined();
+    });
+  });
+
+  describe('git_log 检查点', () => {
+    it('应该返回 git log 数据', async () => {
+      const startup = new SessionStartup(tempDir, { required: ['git_log'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].type).toBe('git_log');
+      expect(result.results[0].success).toBe(true);
+    });
+  });
+
+  describe('read_task_list 检查点', () => {
+    it('tasks.yml 存在应该解析 YAML', async () => {
+      const tasksPath = path.join(tempDir, 'tasks.yml');
+      const taskData = {
+        tasks: [
+          { id: 't1', name: 'task 1', passes: true },
+          { id: 't2', name: 'task 2', passes: false },
+        ],
+      };
+      fs.writeFileSync(tasksPath, yaml.dump(taskData));
+
+      const startup = new SessionStartup(tempDir, { required: ['read_task_list'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toBeDefined();
+      expect(result.results[0].data.tasks.length).toBe(2);
+
+      fs.unlinkSync(tasksPath);
+    });
+
+    it('tasks.json 存在应该回退到 JSON', async () => {
+      const tasksPath = path.join(tempDir, 'tasks.json');
+      const taskData = {
+        tasks: [
+          { id: 't1', name: 'task 1', passes: true },
+        ],
+      };
+      fs.writeFileSync(tasksPath, JSON.stringify(taskData));
+
+      const startup = new SessionStartup(tempDir, { required: ['read_task_list'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data.tasks.length).toBe(1);
+
+      fs.unlinkSync(tasksPath);
+    });
+
+    it('无任务文件应该返回 null', async () => {
+      const noTasksDir = path.join(tempDir, 'no-tasks');
+      fs.mkdirSync(noTasksDir, { recursive: true });
+
+      const startup = new SessionStartup(noTasksDir, { required: ['read_task_list'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toBeNull();
+
+      fs.rmSync(noTasksDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('read_progress 检查点', () => {
+    it('progress.yml 存在应该解析', async () => {
+      const harnessDir = path.join(tempDir, '.harness');
+      fs.mkdirSync(harnessDir, { recursive: true });
+      const progressPath = path.join(harnessDir, 'progress.yml');
+      fs.writeFileSync(progressPath, yaml.dump({ step: 3, total: 10 }));
+
+      const startup = new SessionStartup(tempDir, { required: ['read_progress'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toEqual({ step: 3, total: 10 });
+
+      fs.unlinkSync(progressPath);
+      fs.rmdirSync(harnessDir);
+    });
+
+    it('无 progress.yml 应该返回 null', async () => {
+      const noProgressDir = path.join(tempDir, 'no-progress');
+      fs.mkdirSync(noProgressDir, { recursive: true });
+
+      const startup = new SessionStartup(noProgressDir, { required: ['read_progress'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toBeNull();
+
+      fs.rmSync(noProgressDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('init_sh 检查点', () => {
+    it('init.sh 存在应该返回 true', async () => {
+      const initPath = path.join(tempDir, 'init.sh');
+      fs.writeFileSync(initPath, '#!/bin/bash\necho "init"');
+
+      const startup = new SessionStartup(tempDir, { required: ['init_sh'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toBe(true);
+
+      fs.unlinkSync(initPath);
+    });
+
+    it('init.sh 不存在应该返回 false', async () => {
+      const noInitDir = path.join(tempDir, 'no-init');
+      fs.mkdirSync(noInitDir, { recursive: true });
+
+      const startup = new SessionStartup(noInitDir, { required: ['init_sh'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data).toBe(false);
+
+      fs.rmSync(noInitDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('basic_verification 检查点', () => {
+    it('应该检测 package.json 和 README.md', async () => {
+      const verDir = path.join(tempDir, 'verification');
+      fs.mkdirSync(verDir, { recursive: true });
+      fs.writeFileSync(path.join(verDir, 'package.json'), '{}');
+      fs.writeFileSync(path.join(verDir, 'README.md'), '# Test');
+
+      const startup = new SessionStartup(verDir, { required: ['basic_verification'], optional: [] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data.hasPackageJson).toBe(true);
+      expect(result.results[0].data.hasReadme).toBe(true);
+
+      fs.rmSync(verDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('load_context 检查点', () => {
+    it('应该加载存在的上下文文件', async () => {
+      const ctxDir = path.join(tempDir, 'context-test');
+      fs.mkdirSync(ctxDir, { recursive: true });
+      fs.writeFileSync(path.join(ctxDir, 'AGENTS.md'), '# Agents');
+      fs.writeFileSync(path.join(ctxDir, 'USER.md'), '# User');
+
+      const startup = new SessionStartup(ctxDir, { required: ['load_context'], optional: [], contextFiles: ['AGENTS.md', 'USER.md'] });
+      const result = await startup.run();
+      expect(result.results[0].success).toBe(true);
+      expect(result.results[0].data['AGENTS.md']).toBe('# Agents');
+      expect(result.results[0].data['USER.md']).toBe('# User');
+
+      fs.rmSync(ctxDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('未知检查点类型', () => {
+    it('应该返回失败结果', async () => {
+      const startup = new SessionStartup(tempDir, { required: ['unknown_type' as any], optional: [] });
+      const result = await startup.run();
+      expect(result.success).toBe(false);
+      expect(result.results[0].success).toBe(false);
+      expect(result.results[0].error).toContain('Unknown checkpoint type');
+    });
+  });
+
+  describe('getCurrentTask', () => {
+    it('应该返回第一个未通过的任务', async () => {
+      const tasksPath = path.join(tempDir, 'tasks.yml');
+      const taskData = {
+        tasks: [
+          { id: 't1', name: 'done', passes: true },
+          { id: 't2', name: 'current', passes: false },
+          { id: 't3', name: 'future', passes: false },
+        ],
+      };
+      fs.writeFileSync(tasksPath, yaml.dump(taskData));
+
+      const startup = new SessionStartup(tempDir, { required: [], optional: [] });
+      const current = await startup.getCurrentTask();
+      expect(current).not.toBeNull();
+      expect(current!.task.id).toBe('t2');
+      expect(current!.index).toBe(1);
+
+      fs.unlinkSync(tasksPath);
+    });
+
+    it('所有任务通过应该返回 null', async () => {
+      const tasksPath = path.join(tempDir, 'tasks.yml');
+      const taskData = {
+        tasks: [
+          { id: 't1', name: 'done', passes: true },
+        ],
+      };
+      fs.writeFileSync(tasksPath, yaml.dump(taskData));
+
+      const startup = new SessionStartup(tempDir, { required: [], optional: [] });
+      const current = await startup.getCurrentTask();
+      expect(current).toBeNull();
+
+      fs.unlinkSync(tasksPath);
+    });
+
+    it('无任务文件应该返回 null', async () => {
+      const noTasksDir = path.join(tempDir, 'no-tasks-get');
+      fs.mkdirSync(noTasksDir, { recursive: true });
+
+      const startup = new SessionStartup(noTasksDir, { required: [], optional: [] });
+      const current = await startup.getCurrentTask();
+      expect(current).toBeNull();
+
+      fs.rmSync(noTasksDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('generateReport', () => {
+    it('应该生成报告', () => {
+      const startup = new SessionStartup(tempDir, { required: [], optional: [] });
+      const report = startup.generateReport([
+        { type: 'pwd', success: true, data: '/tmp', duration: 5 },
+        { type: 'git_log', success: false, error: 'not a git repo', duration: 10 },
+      ]);
+
+      expect(report).toContain('Session Startup Report');
+      expect(report).toContain('pwd');
+      expect(report).toContain('git_log');
+      expect(report).toContain('not a git repo');
+    });
+  });
+
+  describe('createSessionStartup 工厂函数', () => {
+    it('应该创建 SessionStartup 实例', () => {
+      const startup = createSessionStartup(tempDir, { required: ['pwd'], optional: [] });
+      expect(startup).toBeInstanceOf(SessionStartup);
+    });
+  });
+
+  describe('常量', () => {
+    it('DEFAULT_CODE_CHECKPOINTS 应该有正确的结构', () => {
+      expect(DEFAULT_CODE_CHECKPOINTS.required).toContain('pwd');
+      expect(DEFAULT_CODE_CHECKPOINTS.required).toContain('git_log');
+      expect(DEFAULT_CODE_CHECKPOINTS.required).toContain('read_task_list');
+      expect(DEFAULT_CODE_CHECKPOINTS.optional).toContain('read_progress');
+      expect(DEFAULT_CODE_CHECKPOINTS.timeout).toBe(30000);
+    });
+
+    it('MINIMAL_CHECKPOINTS 应该有正确的结构', () => {
+      expect(MINIMAL_CHECKPOINTS.required).toContain('pwd');
+      expect(MINIMAL_CHECKPOINTS.required).toContain('read_task_list');
+      expect(MINIMAL_CHECKPOINTS.optional).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+/**
+ * SpecValidator 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import { SpecValidator } from '../core/spec/validator';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('SpecValidator', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-spec');
+  let validator: SpecValidator;
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+    validator = SpecValidator.getInstance();
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  describe('getInstance', () => {
+    it('应该返回单例实例', () => {
+      const instance1 = SpecValidator.getInstance();
+      const instance2 = SpecValidator.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('setConfig', () => {
+    it('应该更新配置', () => {
+      validator.setConfig({
+        enabled: true,
+        files: ['*.md'],
+      });
+
+      expect(validator).toBeDefined();
+    });
+  });
+
+  describe('detectSpecType', () => {
+    it('应该检测 Spec 类型', () => {
+      const type = validator.detectSpecType('ARCHITECTURE.md');
+      expect(type).toBeDefined();
+    });
+
+    it('YAML 文件应该返回正确类型', () => {
+      const type = validator.detectSpecType('specs/test.yml');
+      expect(type).toBeDefined();
+    });
+  });
+});

package/src/__tests__/token-budget.test.ts

@@ -0,0 +1,252 @@
+/**
+ * TokenEstimator 和 TokenBudget 测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { TokenEstimator, TokenBudget } from '../context/token-budget';
+
+describe('TokenEstimator', () => {
+  describe('estimateText', () => {
+    it('空字符串应该返回 0', () => {
+      expect(TokenEstimator.estimateText('')).toBe(0);
+    });
+
+    it('应该估算英文文本', () => {
+      const text = 'hello world';  // 11 字符 ≈ 3 tokens
+      const tokens = TokenEstimator.estimateText(text);
+
+      expect(tokens).toBeGreaterThan(0);
+      expect(tokens).toBeLessThan(10);
+    });
+
+    it('应该估算中文文本', () => {
+      const text = '你好世界';  // 4 字符 ≈ 3 tokens
+      const tokens = TokenEstimator.estimateText(text);
+
+      expect(tokens).toBeGreaterThan(0);
+      expect(tokens).toBeLessThan(10);
+    });
+
+    it('中英文混合应该按中文计算', () => {
+      const text = 'hello世界';  // 含中文，按中文比例
+      const tokens = TokenEstimator.estimateText(text);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('长文本应该返回更大的值', () => {
+      const shortText = 'hello';
+      const longText = 'hello world this is a longer text for testing';
+
+      const shortTokens = TokenEstimator.estimateText(shortText);
+      const longTokens = TokenEstimator.estimateText(longText);
+
+      expect(longTokens).toBeGreaterThan(shortTokens);
+    });
+  });
+
+  describe('estimateObject', () => {
+    it('应该估算对象的 Token 数', () => {
+      const obj = { name: 'test', value: 123 };
+      const tokens = TokenEstimator.estimateObject(obj);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('嵌套对象应该正确估算', () => {
+      const obj = {
+        user: {
+          name: 'test',
+          email: 'test@example.com',
+        },
+        items: [1, 2, 3],
+      };
+      const tokens = TokenEstimator.estimateObject(obj);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('无法 JSON 序列化应该返回 0', () => {
+      const obj: any = {};
+      obj.self = obj;  // 循环引用
+
+      const tokens = TokenEstimator.estimateObject(obj);
+
+      expect(tokens).toBe(0);
+    });
+  });
+
+  describe('estimateArray', () => {
+    it('应该估算数组的 Token 数', () => {
+      const arr = [1, 2, 3, 4, 5];
+      const tokens = TokenEstimator.estimateArray(arr);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('应该支持自定义估算器', () => {
+      const items = [
+        { name: 'item1', description: 'desc1' },
+        { name: 'item2', description: 'desc2' },
+      ];
+      const customEstimator = (item: any) => TokenEstimator.estimateText(item.name);
+
+      const tokens = TokenEstimator.estimateArray(items, customEstimator);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+
+    it('空数组应该返回较小值', () => {
+      expect(TokenEstimator.estimateArray([])).toBeLessThan(5);
+    });
+  });
+
+  describe('createFieldEstimator', () => {
+    it('应该创建字段估算器', () => {
+      interface TestItem {
+        title: string;
+        content: string;
+      }
+
+      const estimator = TokenEstimator.createFieldEstimator<TestItem>({
+        title: (v) => TokenEstimator.estimateText(v),
+        content: (v) => TokenEstimator.estimateText(v),
+      });
+
+      const item: TestItem = {
+        title: 'Test Title',
+        content: 'Test Content',
+      };
+
+      const tokens = estimator(item);
+
+      expect(tokens).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('TokenBudget', () => {
+  describe('constructor', () => {
+    it('应该初始化预算', () => {
+      const budget = new TokenBudget(10000);
+
+      expect(budget.total).toBe(10000);
+      expect(budget.used).toBe(0);
+      expect(budget.remaining).toBe(10000);
+    });
+  });
+
+  describe('reserve', () => {
+    it('应该预留预算', () => {
+      const budget = new TokenBudget(10000);
+
+      const result = budget.reserve(1000);
+
+      expect(result).toBe(true);
+      expect(budget.remaining).toBe(9000);
+    });
+
+    it('超出限制应该失败', () => {
+      const budget = new TokenBudget(1000);
+
+      const result = budget.reserve(2000);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('consume', () => {
+    it('应该使用预算', () => {
+      const budget = new TokenBudget(10000);
+
+      const result = budget.consume(1000);
+
+      expect(result).toBe(true);
+      expect(budget.used).toBe(1000);
+      expect(budget.remaining).toBe(9000);
+    });
+
+    it('超出限制应该失败', () => {
+      const budget = new TokenBudget(1000);
+
+      const result = budget.consume(2000);
+
+      expect(result).toBe(false);
+      expect(budget.used).toBe(0);
+    });
+  });
+
+  describe('forceConsume', () => {
+    it('应该强制使用预算（可能超预算）', () => {
+      const budget = new TokenBudget(1000);
+
+      budget.forceConsume(2000);
+
+      expect(budget.used).toBe(2000);
+    });
+  });
+
+  describe('release', () => {
+    it('应该释放预留的预算', () => {
+      const budget = new TokenBudget(10000);
+
+      budget.reserve(1000);
+      budget.release(500);
+
+      expect(budget.remaining).toBe(9500);
+    });
+
+    it('释放超过预留的量应该不会变成负数', () => {
+      const budget = new TokenBudget(10000);
+
+      budget.reserve(100);
+      budget.release(200);
+
+      expect(budget.remaining).toBe(10000);
+    });
+  });
+
+  describe('addBudget', () => {
+    it('应该增加预算', () => {
+      const budget = new TokenBudget(10000);
+
+      budget.addBudget(5000);
+
+      expect(budget.total).toBe(15000);
+    });
+  });
+
+  describe('canAfford', () => {
+    it('应该检查是否有足够预算', () => {
+      const budget = new TokenBudget(10000);
+
+      expect(budget.canAfford(5000)).toBe(true);
+      expect(budget.canAfford(15000)).toBe(false);
+    });
+
+    it('使用后应该正确计算', () => {
+      const budget = new TokenBudget(10000);
+
+      budget.consume(5000);
+
+      expect(budget.canAfford(5000)).toBe(true);
+      expect(budget.canAfford(5001)).toBe(false);
+    });
+  });
+
+  describe('usageRatio', () => {
+    it('应该计算使用比例', () => {
+      const budget = new TokenBudget(10000);
+
+      budget.consume(5000);
+
+      expect(budget.usageRatio).toBe(0.5);
+    });
+
+    it('未使用应该返回 0', () => {
+      const budget = new TokenBudget(10000);
+
+      expect(budget.usageRatio).toBe(0);
+    });
+  });
+});