@dommaker/harness 0.19.0 → 1.1.0

package/src/context/__tests__/file-budget.test.ts

@@ -1,142 +0,0 @@
-/**
- * FileBudget 测试
- */
-
-import { FileBudget } from '../file-budget';
-import * as fs from 'fs';
-
-jest.mock('fs', () => ({
-  statSync: jest.fn(),
-  readFileSync: jest.fn(),
-}));
-
-const mockFs = fs as jest.Mocked<typeof fs>;
-
-describe('FileBudget', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('checkFile', () => {
-    it('应该允许小文件', () => {
-      (mockFs.statSync as jest.Mock).mockReturnValue({ size: 1000 });
-      const budget = new FileBudget();
-      const result = budget.checkFile('/test/file.ts');
-      expect(result.allowed).toBe(true);
-    });
-
-    it('应该拒绝超大文件', () => {
-      (mockFs.statSync as jest.Mock).mockReturnValue({ size: 100000 });
-      const budget = new FileBudget();
-      const result = budget.checkFile('/test/large-file.ts');
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain('超过限制');
-    });
-
-    it('应该处理文件不存在', () => {
-      (mockFs.statSync as jest.Mock).mockImplementation(() => {
-        throw new Error('ENOENT');
-      });
-      const budget = new FileBudget();
-      const result = budget.checkFile('/test/missing.ts');
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain('无法读取文件');
-    });
-  });
-
-  describe('readWithBudget', () => {
-    it('应该读取正常文件', () => {
-      (mockFs.readFileSync as jest.Mock).mockReturnValue('line1\nline2\nline3');
-      const budget = new FileBudget();
-      const result = budget.readWithBudget('/test/file.ts');
-      expect(result.content).toBe('line1\nline2\nline3');
-      expect(result.truncated).toBe(false);
-      expect(result.linesRead).toBe(3);
-    });
-
-    it('应该按行数截断', () => {
-      const lines = Array.from({ length: 3000 }, (_, i) => `line${i}`);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(lines.join('\n'));
-      const budget = new FileBudget({ maxLines: 2000 });
-      const result = budget.readWithBudget('/test/large.ts');
-      expect(result.truncated).toBe(true);
-      expect(result.linesRead).toBe(2000);
-      expect(result.continuationHint).toContain('offset=2000');
-    });
-
-    it('应该按 token 数截断', () => {
-      // 长内容超过 token 限制
-      const longContent = 'a'.repeat(50000);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(longContent);
-      const budget = new FileBudget({ maxTokenEstimate: 100, maxLines: 10000, maxBytes: 100000 });
-      const result = budget.readWithBudget('/test/long.ts');
-      expect(result.truncated).toBe(true);
-    });
-
-    it('应该处理读取失败', () => {
-      (mockFs.readFileSync as jest.Mock).mockImplementation(() => {
-        throw new Error('EACCES');
-      });
-      const budget = new FileBudget();
-      const result = budget.readWithBudget('/test/locked.ts');
-      expect(result.content).toBe('');
-      expect(result.continuationHint).toContain('无法读取文件');
-    });
-
-    it('应该支持自定义配置', () => {
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(lines.join('\n'));
-      const budget = new FileBudget();
-      const result = budget.readWithBudget('/test/file.ts', { maxLines: 50 });
-      expect(result.truncated).toBe(true);
-      expect(result.linesRead).toBe(50);
-    });
-
-    it('应该不生成 continuationHint 当配置关闭', () => {
-      const lines = Array.from({ length: 3000 }, (_, i) => `line${i}`);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(lines.join('\n'));
-      const budget = new FileBudget({ continuationHint: false, maxLines: 2000 });
-      const result = budget.readWithBudget('/test/large.ts');
-      expect(result.truncated).toBe(true);
-      expect(result.continuationHint).toBeUndefined();
-    });
-
-    it('should truncate by byte count', () => {
-      const content = 'x'.repeat(20000);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(content);
-      const budget = new FileBudget({ maxBytes: 500, maxLines: 50000, maxTokenEstimate: 100000 });
-      const result = budget.readWithBudget('/test/big-bytes.ts');
-      expect(result.truncated).toBe(true);
-      expect(result.content.length).toBeLessThan(20000);
-    });
-
-    it('should include continuation hint when byte truncated', () => {
-      const content = 'y'.repeat(20000);
-      (mockFs.readFileSync as jest.Mock).mockReturnValue(content);
-      const budget = new FileBudget({
-        maxBytes: 500,
-        maxLines: 50000,
-        maxTokenEstimate: 100000,
-        continuationHint: true,
-      });
-      const result = budget.readWithBudget('/test/big-bytes-hint.ts');
-      expect(result.truncated).toBe(true);
-      expect(result.continuationHint).toContain('字节');
-    });
-  });
-
-  describe('getConfig', () => {
-    it('应该返回默认配置', () => {
-      const budget = new FileBudget();
-      const config = budget.getConfig();
-      expect(config.maxLines).toBe(2000);
-      expect(config.maxBytes).toBe(51200);
-    });
-
-    it('应该返回自定义配置', () => {
-      const budget = new FileBudget({ maxLines: 1000 });
-      const config = budget.getConfig();
-      expect(config.maxLines).toBe(1000);
-    });
-  });
-});

package/src/context/__tests__/progressive-loader.test.ts

@@ -1,264 +0,0 @@
-/**
- * ProgressiveLoader 测试
- */
-
-import { ProgressiveLoader, progressiveLoader } from '../progressive-loader';
-
-describe('ProgressiveLoader', () => {
-  let loader: ProgressiveLoader;
-
-  beforeEach(() => {
-    loader = new ProgressiveLoader();
-  });
-
-  describe('loadInChunks()', () => {
-    it('should load items in chunks', async () => {
-      const items = Array.from({ length: 100 }, (_, i) => i);
-      const chunks: any[] = [];
-
-      await loader.loadInChunks(items, {
-        chunkSize: 20,
-        onChunk: (chunk) => { chunks.push(chunk); },
-      });
-
-      expect(chunks.length).toBe(5);
-      expect(chunks[0].length).toBe(20);
-    });
-
-    it('should call progress callback', async () => {
-      const items = Array.from({ length: 50 }, (_, i) => i);
-      const progress: any[] = [];
-
-      await loader.loadInChunks(items, {
-        chunkSize: 10,
-        onProgress: (loaded, total) => progress.push({ loaded, total }),
-      });
-
-      expect(progress.length).toBeGreaterThan(0);
-      expect(progress[progress.length - 1].loaded).toBe(50);
-    });
-
-    it('should load in parallel when parallel=true', async () => {
-      const items = Array.from({ length: 20 }, (_, i) => i);
-      const chunks: any[] = [];
-
-      await loader.loadInChunks(items, {
-        chunkSize: 5,
-        parallel: true,
-        onChunk: (chunk) => { chunks.push(chunk); },
-      });
-
-      expect(chunks.length).toBe(4);
-    });
-
-    it('should handle delay', async () => {
-      const items = Array.from({ length: 10 }, (_, i) => i);
-
-      const start = Date.now();
-      await loader.loadInChunks(items, {
-        chunkSize: 2,
-        delay: 10,
-      });
-
-      // Should have taken some time (at least 4 delays = 40ms)
-      const elapsed = Date.now() - start;
-      expect(elapsed).toBeGreaterThanOrEqual(30);
-    });
-
-    it('should handle empty items', async () => {
-      await loader.loadInChunks([], {
-        chunkSize: 10,
-      });
-      // Should complete without error
-    });
-
-    it('should handle items not divisible by chunkSize', async () => {
-      const items = Array.from({ length: 25 }, (_, i) => i);
-      const chunks: any[] = [];
-
-      await loader.loadInChunks(items, {
-        chunkSize: 10,
-        onChunk: (chunk) => { chunks.push(chunk); },
-      });
-
-      expect(chunks.length).toBe(3);
-      expect(chunks[2].length).toBe(5);
-    });
-  });
-
-  describe('loadWithBudget()', () => {
-    it('should load items within budget', async () => {
-      const items = [
-        { text: 'short' },
-        { text: 'medium' },
-        { text: 'long' },
-      ];
-
-      const result = await loader.loadWithBudget(items, {
-        budget: 100,
-        estimator: (item) => item.text.length,
-      });
-
-      expect(result.items.length).toBe(3);
-      expect(result.tokensUsed).toBe(15);
-      expect(result.truncated).toBe(false);
-    });
-
-    it('should truncate when budget exceeded', async () => {
-      const items = [
-        { text: 'a' },
-        { text: 'b'.repeat(100) },
-        { text: 'c'.repeat(100) },
-      ];
-
-      const result = await loader.loadWithBudget(items, {
-        budget: 50,
-        estimator: (item) => item.text.length,
-        onBudgetExceeded: 'truncate',
-      });
-
-      expect(result.items.length).toBeLessThan(3);
-      expect(result.truncated).toBe(true);
-    });
-
-    it('should throw error when onBudgetExceeded=error', async () => {
-      const items = [
-        { text: 'short' },
-        { text: 'a'.repeat(200) },
-      ];
-
-      await expect(
-        loader.loadWithBudget(items, {
-          budget: 50,
-          estimator: (item) => item.text.length,
-          onBudgetExceeded: 'error',
-        })
-      ).rejects.toThrow('Token budget exceeded');
-    });
-
-    it('should skip items when onBudgetExceeded=skip', async () => {
-      const items = [
-        { text: 'short' },
-        { text: 'verylong'.repeat(100) },
-        { text: 'short2' },
-      ];
-
-      const result = await loader.loadWithBudget(items, {
-        budget: 50,
-        estimator: (item) => item.text.length,
-        onBudgetExceeded: 'skip',
-      });
-
-      expect(result.skipped).toBeGreaterThan(0);
-    });
-
-    it('should respect minItems', async () => {
-      const items = [
-        { text: 'verylong'.repeat(100) },
-        { text: 'verylong'.repeat(100) },
-      ];
-
-      const result = await loader.loadWithBudget(items, {
-        budget: 10,
-        estimator: (item) => item.text.length,
-        minItems: 1,
-        onBudgetExceeded: 'truncate',
-      });
-
-      expect(result.items.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should handle empty items', async () => {
-      const result = await loader.loadWithBudget([], {
-        budget: 100,
-        estimator: () => 0,
-      });
-
-      expect(result.items.length).toBe(0);
-      expect(result.tokensUsed).toBe(0);
-    });
-  });
-
-  describe('createStream()', () => {
-    it('should create async iterator', async () => {
-      const source = async function* () {
-        yield 1;
-        yield 2;
-        yield 3;
-        yield 4;
-        yield 5;
-      };
-
-      const stream = loader.createStream(source(), 2);
-      const chunks: any[] = [];
-
-      for await (const chunk of stream) {
-        chunks.push(chunk);
-      }
-
-      expect(chunks.length).toBe(3);
-      expect(chunks[0]).toEqual([1, 2]);
-      expect(chunks[2]).toEqual([5]);
-    });
-
-    it('should handle empty source', async () => {
-      const source = async function* () {};
-
-      const stream = loader.createStream(source(), 10);
-      const chunks: any[] = [];
-
-      for await (const chunk of stream) {
-        chunks.push(chunk);
-      }
-
-      expect(chunks.length).toBe(0);
-    });
-  });
-
-  describe('processBatch()', () => {
-    it('should process items with concurrency', async () => {
-      const items = [1, 2, 3, 4, 5];
-      const processor = async (n: number) => n * 2;
-
-      const results = await loader.processBatch(items, processor, 2);
-
-      expect(results.length).toBe(5);
-      expect(results).toContain(2);
-      expect(results).toContain(10);
-    });
-
-    it('should handle empty items', async () => {
-      const results = await loader.processBatch([], async (n) => n, 5);
-      expect(results.length).toBe(0);
-    });
-
-    it('should handle async processor', async () => {
-      const items = [1, 2, 3];
-      const processed: number[] = [];
-
-      const processor = async (n: number) => {
-        processed.push(n);
-        return n * 2;
-      };
-
-      await loader.processBatch(items, processor, 1);
-
-      // Check that all items were processed
-      expect(processed.sort()).toEqual([1, 2, 3]);
-    });
-  });
-});
-
-describe('progressiveLoader (default instance)', () => {
-  it('should be usable', async () => {
-    const items = [1, 2, 3];
-    const chunks: any[] = [];
-
-    await progressiveLoader.loadInChunks(items, {
-      chunkSize: 1,
-      onChunk: (chunk) => { chunks.push(chunk); return undefined; },
-    });
-
-    expect(chunks.length).toBe(3);
-  });
-});

package/src/context/__tests__/token-pipeline.test.ts

@@ -1,178 +0,0 @@
-/**
- * TokenPipeline 测试
- */
-
-import { TokenPipeline } from '../token-pipeline';
-import type { ContextSource, TokenBudgetAllocation } from '../types';
-
-const defaultBudget: TokenBudgetAllocation = {
-  total: 8000,
-  systemPrompt: 1000,
-  toolDefinitions: 500,
-  knowledge: 600,
-  notes: 300,
-  history: 5600,
-};
-
-function makeSource(overrides: Partial<ContextSource> & { priority: number }): ContextSource {
-  return {
-    type: 'user_message',
-    id: `src-${Math.random().toString(36).slice(2, 8)}`,
-    content: 'test content',
-    ...overrides,
-  };
-}
-
-describe('TokenPipeline', () => {
-  let pipeline: TokenPipeline;
-
-  beforeEach(() => {
-    pipeline = new TokenPipeline();
-  });
-
-  describe('run', () => {
-    it('应该执行完整流水线', () => {
-      const input = {
-        sources: [
-          makeSource({ type: 'system_prompt', priority: 1, content: 'You are helpful.' }),
-          makeSource({ type: 'user_message', priority: 6, content: 'Hello' }),
-        ],
-        budget: defaultBudget,
-      };
-
-      const result = pipeline.run(input);
-      expect(result.prompt).toContain('You are helpful.');
-      expect(result.prompt).toContain('Hello');
-      expect(result.snapshot).toBeDefined();
-      expect(result.snapshot.totalTokens).toBeGreaterThan(0);
-    });
-
-    it('应该把 P1 放在开头，P6 放在结尾', () => {
-      const input = {
-        sources: [
-          makeSource({ type: 'user_message', priority: 6, content: 'USER_MSG' }),
-          makeSource({ type: 'system_prompt', priority: 1, content: 'SYSTEM' }),
-          makeSource({ type: 'knowledge', priority: 3, content: 'KNOWLEDGE' }),
-        ],
-        budget: defaultBudget,
-      };
-
-      const result = pipeline.run(input);
-      const prompt = result.prompt;
-      const sysIdx = prompt.indexOf('SYSTEM');
-      const knowIdx = prompt.indexOf('KNOWLEDGE');
-      const userIdx = prompt.indexOf('USER_MSG');
-
-      expect(sysIdx).toBeLessThan(knowIdx);
-      expect(knowIdx).toBeLessThan(userIdx);
-    });
-
-    it('应该生成 ContextUsageSnapshot', () => {
-      const input = {
-        sources: [
-          makeSource({ type: 'system_prompt', priority: 1, content: 'system' }),
-          makeSource({ type: 'tool_output', priority: 5, content: 'output' }),
-        ],
-        budget: defaultBudget,
-      };
-
-      const result = pipeline.run(input);
-      expect(result.snapshot.breakdown.systemPrompt).toBeGreaterThan(0);
-      expect(result.snapshot.timestamp).toBeDefined();
-    });
-  });
-
-  describe('collect', () => {
-    it('应该按 priority 分组', () => {
-      const sources = [
-        makeSource({ priority: 1, content: 'a' }),
-        makeSource({ priority: 3, content: 'b' }),
-        makeSource({ priority: 1, content: 'c' }),
-      ];
-
-      const groups = pipeline.collect(sources);
-      expect(groups.length).toBe(2);
-      expect(groups[0].priority).toBe(1);
-      expect(groups[0].sources.length).toBe(2);
-      expect(groups[1].priority).toBe(3);
-    });
-  });
-
-  describe('sort', () => {
-    it('应该按 priority 排序', () => {
-      const groups = [
-        { priority: 1, sources: [makeSource({ priority: 1, content: 'p1' })] },
-        { priority: 3, sources: [makeSource({ priority: 3, content: 'p3' })] },
-      ];
-
-      const sorted = pipeline.sort(groups);
-      expect(sorted[0].priority).toBe(1);
-      expect(sorted[1].priority).toBe(3);
-    });
-  });
-
-  describe('compress', () => {
-    it('应该不压缩 P1 和 P6', () => {
-      const sorted = [
-        makeSource({ type: 'system_prompt', priority: 1, content: 'a'.repeat(5000) }),
-        makeSource({ type: 'user_message', priority: 6, content: 'b'.repeat(5000) }),
-      ];
-
-      const { compressed } = pipeline.compress(sorted, defaultBudget);
-      expect(compressed.length).toBe(2);
-    });
-
-    it('应该裁剪超出预算的 P3-P5', () => {
-      const sorted = [
-        makeSource({ priority: 3, content: 'x'.repeat(10000) }),
-        makeSource({ priority: 3, content: 'y'.repeat(10000) }),
-      ];
-
-      const { compressed, dropped } = pipeline.compress(sorted, defaultBudget);
-      // 预算不足时，部分项被截断，部分被丢弃
-      expect(compressed.length).toBeLessThanOrEqual(2);
-      expect(dropped.length).toBeGreaterThan(0);
-      expect(compressed.length + dropped.filter(d => d.reason.includes('超出预算')).length).toBe(2);
-    });
-  });
-
-  describe('applyBudget', () => {
-    it('应该按总预算裁剪', () => {
-      const compressed = [
-        makeSource({ priority: 5, content: 'x'.repeat(50000) }),
-      ];
-
-      const result = pipeline.applyBudget(compressed, { ...defaultBudget, total: 100 });
-      // 超预算的非 P1/P6 项应被丢弃
-      expect(result.length).toBeLessThanOrEqual(1);
-    });
-
-    it('应该强制保留 P1', () => {
-      const compressed = [
-        makeSource({ type: 'system_prompt', priority: 1, content: 'x'.repeat(50000) }),
-      ];
-
-      const result = pipeline.applyBudget(compressed, { ...defaultBudget, total: 100 });
-      expect(result.length).toBe(1);
-    });
-  });
-
-  describe('assemble', () => {
-    it('应该按优先级拼装', () => {
-      const budgeted = [
-        makeSource({ priority: 6, content: 'USER' }),
-        makeSource({ priority: 1, content: 'SYS' }),
-        makeSource({ priority: 3, content: 'KNOW' }),
-      ];
-
-      const prompt = pipeline.assemble(budgeted);
-      expect(prompt.indexOf('SYS')).toBeLessThan(prompt.indexOf('KNOW'));
-      expect(prompt.indexOf('KNOW')).toBeLessThan(prompt.indexOf('USER'));
-    });
-
-    it('应该处理空输入', () => {
-      const prompt = pipeline.assemble([]);
-      expect(prompt).toBe('');
-    });
-  });
-});

package/src/context/__tests__/tool-output-budget.test.ts

@@ -1,95 +0,0 @@
-/**
- * ToolOutputBudget 测试
- */
-
-import { ToolOutputBudget } from '../tool-output-budget';
-
-describe('ToolOutputBudget', () => {
-  describe('checkOutput', () => {
-    it('应该允许正常输出', () => {
-      const budget = new ToolOutputBudget();
-      const result = budget.checkOutput('short output');
-      expect(result.allowed).toBe(true);
-      expect(result.strategy).toBe('full');
-    });
-
-    it('应该标记超大输出为 preview', () => {
-      const budget = new ToolOutputBudget();
-      const largeOutput = 'x'.repeat(20000);
-      const result = budget.checkOutput(largeOutput);
-      expect(result.strategy).toBe('preview');
-      expect(result.reason).toContain('超过限制');
-    });
-
-    it('应该标记超大输出为 overflow 当配置开启', () => {
-      const budget = new ToolOutputBudget({ overflowToDisk: true });
-      const largeOutput = 'x'.repeat(20000);
-      const result = budget.checkOutput(largeOutput);
-      expect(result.strategy).toBe('overflow');
-    });
-
-    it('应该标记重复输出为 dedup', () => {
-      const budget = new ToolOutputBudget();
-      budget.checkOutput('same content');
-      const result = budget.checkOutput('same content');
-      expect(result.strategy).toBe('dedup');
-    });
-
-    it('应该按 token 比例检查', () => {
-      const budget = new ToolOutputBudget({ maxTokenRatio: 0.1 });
-      // 约 2500 tokens (10000 chars / 4)
-      const output = 'x'.repeat(10000);
-      const result = budget.checkOutput(output, 10000);
-      expect(result.strategy).toBe('preview');
-    });
-  });
-
-  describe('applyBudget', () => {
-    it('应该返回完整内容当策略为 full', () => {
-      const budget = new ToolOutputBudget();
-      const result = budget.applyBudget('hello world', 'full');
-      expect(result.content).toBe('hello world');
-      expect(result.keptTokens).toBe(result.originalTokens);
-    });
-
-    it('应该生成预览当策略为 preview', () => {
-      const budget = new ToolOutputBudget({ previewLines: 3 });
-      const lines = Array.from({ length: 100 }, (_, i) => `line ${i} with some extra content to make it longer`);
-      const result = budget.applyBudget(lines.join('\n'), 'preview');
-      expect(result.content).toContain('line 0');
-      expect(result.content).toContain('省略');
-      expect(result.keptTokens).toBeLessThan(result.originalTokens);
-    });
-
-    it('应该返回省略提示当策略为 dedup', () => {
-      const budget = new ToolOutputBudget();
-      const result = budget.applyBudget('duplicate content', 'dedup');
-      expect(result.content).toContain('重复内容');
-    });
-
-    it('应该处理 overflow 策略', () => {
-      const budget = new ToolOutputBudget({ previewLines: 2 });
-      const content = Array.from({ length: 20 }, (_, i) => `line${i}`).join('\n');
-      const result = budget.applyBudget(content, 'overflow');
-      expect(result.content).toContain('输出已写入磁盘');
-      expect(result.offloaded).toBeDefined();
-    });
-  });
-
-  describe('clearDedupCache', () => {
-    it('应该清除去重缓存', () => {
-      const budget = new ToolOutputBudget();
-      budget.checkOutput('content');
-      budget.clearDedupCache();
-      const result = budget.checkOutput('content');
-      expect(result.strategy).toBe('full');
-    });
-  });
-
-  describe('getConfig', () => {
-    it('应该返回配置', () => {
-      const budget = new ToolOutputBudget({ maxChars: 8000 });
-      expect(budget.getConfig().maxChars).toBe(8000);
-    });
-  });
-});