@dommaker/harness 0.13.0 → 0.13.2

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

@@ -0,0 +1,142 @@
+/**
+ * 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__/knowledge-injector.test.ts

@@ -0,0 +1,148 @@
+/**
+ * KnowledgeInjector 测试
+ */
+
+import { KnowledgeInjector } from '../knowledge-injector';
+import { KnowledgeQuery } from '../../knowledge/query';
+import { KnowledgeStore } from '../../knowledge/store';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('KnowledgeInjector', () => {
+  let store: KnowledgeStore;
+  let query: KnowledgeQuery;
+  let injector: KnowledgeInjector;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'injector-test-'));
+    store = new KnowledgeStore({ baseDir: path.join(tmpDir, 'knowledge') });
+    query = new KnowledgeQuery(store);
+    injector = new KnowledgeInjector(query);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function saveEntry(overrides: any = {}) {
+    store.save({
+      id: overrides.id || `test-${Math.random().toString(36).slice(2, 6)}`,
+      type: 'decision',
+      title: 'Test Decision',
+      content: 'Some content for testing',
+      maturity: 'verified',
+      layer: 'project',
+      created: new Date().toISOString(),
+      lastReferenced: new Date().toISOString(),
+      contributors: [],
+      projects: [],
+      tags: [],
+      applicablePhases: [],
+      sourceReferences: [],
+      referencedBy: [],
+      ...overrides,
+    });
+  }
+
+  describe('inject', () => {
+    it('应该返回空结果当无知识条目', () => {
+      const result = injector.inject({ budget: 800 });
+      expect(result.sources.length).toBe(0);
+      expect(result.entriesIncluded).toBe(0);
+    });
+
+    it('应该注入知识条目为 ContextSource', () => {
+      saveEntry({ id: 'dec-001', title: 'Use TypeScript', content: 'Always use TS' });
+      const result = injector.inject({ budget: 8000 });
+      expect(result.sources.length).toBe(1);
+      expect(result.sources[0].type).toBe('knowledge');
+      expect(result.sources[0].priority).toBe(3);
+      expect(result.sources[0].content).toContain('Use TypeScript');
+    });
+
+    it('应该按预算裁剪', () => {
+      saveEntry({ id: 'a', title: 'A', content: 'x'.repeat(5000) });
+      saveEntry({ id: 'b', title: 'B', content: 'y'.repeat(5000) });
+      const result = injector.inject({ budget: 500 });
+      // 只能容纳部分
+      expect(result.entriesIncluded).toBeLessThan(2);
+    });
+
+    it('应该降级为摘要当完整条目超出预算', () => {
+      saveEntry({ id: 'big-1', title: 'Big Entry', content: 'x'.repeat(5000) });
+      // 预算够查询返回条目，但不够注入完整内容
+      const result = injector.inject({ budget: 1500 });
+      expect(result.entriesIncluded).toBe(0);
+      expect(result.entriesSummarized).toBe(1);
+      expect(result.sources.some(s => s.id === 'knowledge-summary-big-1')).toBe(true);
+    });
+
+    it('应该排除已注入的条目', () => {
+      saveEntry({ id: 'ex-1', title: 'Excluded' });
+      const result = injector.inject({ budget: 8000, exclude: ['ex-1'] });
+      expect(result.entriesExcluded).toBe(1);
+      expect(result.entriesIncluded).toBe(0);
+    });
+
+    it('应该为已排除条目注入摘要', () => {
+      saveEntry({ id: 'ex-2', title: 'Excluded', content: 'Some long content here' });
+      const result = injector.inject({
+        budget: 8000,
+        exclude: ['ex-2'],
+        injectSummaryForExcluded: true,
+      });
+      expect(result.entriesSummarized).toBe(1);
+      expect(result.sources.some(s => s.id === 'knowledge-summary-ex-2')).toBe(true);
+    });
+
+    it('应该不注入摘要当配置关闭', () => {
+      saveEntry({ id: 'ex-3', title: 'Excluded' });
+      const result = injector.inject({
+        budget: 8000,
+        exclude: ['ex-3'],
+        injectSummaryForExcluded: false,
+      });
+      expect(result.entriesSummarized).toBe(0);
+    });
+  });
+
+  describe('formatEntry', () => {
+    it('应该格式化完整条目', () => {
+      saveEntry({ id: 'fmt-1', title: 'My Decision', type: 'decision', maturity: 'proven', tags: ['auth', 'api'] });
+      const entry = store.get('fmt-1')!;
+      const formatted = injector.formatEntry(entry);
+      expect(formatted).toContain('[DECISION]');
+      expect(formatted).toContain('My Decision');
+      expect(formatted).toContain('proven');
+      expect(formatted).toContain('auth, api');
+    });
+  });
+
+  describe('formatEntrySummary', () => {
+    it('应该生成一行摘要', () => {
+      saveEntry({ id: 'sum-1', title: 'Short', content: 'Brief content' });
+      const entry = store.get('sum-1')!;
+      const summary = injector.formatEntrySummary(entry);
+      expect(summary).toContain('[sum-1]');
+      expect(summary).toContain('Short');
+      expect(summary).toContain('verified');
+      expect(summary.split('\n').length).toBe(1);
+    });
+
+    it('应该截断长内容', () => {
+      saveEntry({ id: 'sum-2', title: 'Long', content: 'x'.repeat(200) });
+      const entry = store.get('sum-2')!;
+      const summary = injector.formatEntrySummary(entry);
+      expect(summary).toContain('...');
+      expect(summary.length).toBeLessThan(200);
+    });
+  });
+
+  describe('getQuery', () => {
+    it('应该返回查询引擎', () => {
+      expect(injector.getQuery()).toBe(query);
+    });
+  });
+});

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

@@ -0,0 +1,264 @@
+/**
+ * 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, index) => { 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, index) => { 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, index) => { 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: (item) => 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;
+      };
+
+      const results = 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, index) => { chunks.push(chunk); return undefined; },
+    });
+
+    expect(chunks.length).toBe(3);
+  });
+});