@dommaker/harness 0.13.0 → 0.13.2

package/src/knowledge/__tests__/ingest.test.ts

@@ -0,0 +1,125 @@
+/**
+ * KnowledgeIngest 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { KnowledgeStore } from '../store';
+import { KnowledgeIngest } from '../ingest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('KnowledgeIngest', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-ingest');
+  let store: KnowledgeStore;
+  let ingest: KnowledgeIngest;
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    const files = fs.readdirSync(tempDir);
+    for (const f of files) {
+      fs.unlinkSync(path.join(tempDir, f));
+    }
+    store = new KnowledgeStore({ baseDir: tempDir });
+    ingest = new KnowledgeIngest(store);
+  });
+
+  describe('ingestEntry', () => {
+    it('should ingest a new entry with auto-generated id', () => {
+      const entry = ingest.ingestEntry(
+        { title: 'Test', content: 'Content', type: 'decision' },
+        { source: 'test', layer: 'project' },
+      );
+      expect(entry.id).toMatch(/^DEC-\d{3}$/);
+      expect(entry.title).toBe('Test');
+      expect(entry.maturity).toBe('draft');
+    });
+
+    it('should use provided id', () => {
+      const entry = ingest.ingestEntry(
+        { id: 'CUSTOM-001', title: 'Test', type: 'guideline' },
+        { source: 'test', layer: 'project' },
+      );
+      expect(entry.id).toBe('CUSTOM-001');
+    });
+
+    it('should merge tags from options and entry', () => {
+      const entry = ingest.ingestEntry(
+        { title: 'Test', type: 'decision', tags: ['arch'] },
+        { source: 'test', layer: 'project', tags: ['db'] },
+      );
+      expect(entry.tags).toContain('arch');
+      expect(entry.tags).toContain('db');
+    });
+
+    it('should use maturity from options', () => {
+      const entry = ingest.ingestEntry(
+        { title: 'Test', type: 'decision' },
+        { source: 'test', layer: 'project', maturity: 'verified' },
+      );
+      expect(entry.maturity).toBe('verified');
+    });
+
+    it('should merge duplicate entries', () => {
+      ingest.ingestEntry(
+        { title: 'Duplicate', content: 'Original', type: 'decision' },
+        { source: 'test', layer: 'project' },
+      );
+      const merged = ingest.ingestEntry(
+        { title: 'Duplicate', content: 'Updated', type: 'decision', contributors: ['alice'] },
+        { source: 'test', layer: 'project' },
+      );
+      expect(merged.content).toBe('Updated');
+      expect(merged.contributors).toContain('alice');
+      // Should only have one entry in the store
+      expect(store.list()).toHaveLength(1);
+    });
+  });
+
+  describe('ingestBatch', () => {
+    it('should ingest multiple entries', () => {
+      const entries = ingest.ingestBatch(
+        [
+          { title: 'First', type: 'decision' },
+          { title: 'Second', type: 'pitfall' },
+        ],
+        { source: 'test', layer: 'project' },
+      );
+      expect(entries).toHaveLength(2);
+      expect(store.list()).toHaveLength(2);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should default to guideline type when type is not provided', () => {
+      const entry = ingest.ingestEntry(
+        { title: 'No Type' },
+        { source: 'test', layer: 'project' },
+      );
+      expect(entry.type).toBe('guideline');
+    });
+
+    it('should dedup case-insensitively', () => {
+      ingest.ingestEntry(
+        { title: 'My Decision', type: 'decision' },
+        { source: 'test', layer: 'project' },
+      );
+      const merged = ingest.ingestEntry(
+        { title: 'my decision', type: 'decision', content: 'updated' },
+        { source: 'test', layer: 'project' },
+      );
+      expect(merged.content).toBe('updated');
+      expect(store.list()).toHaveLength(1);
+    });
+  });
+});

package/src/knowledge/__tests__/lifecycle-hooks.test.ts

@@ -0,0 +1,137 @@
+/**
+ * KnowledgeLifecycleHooks 测试
+ */
+
+import { KnowledgeLifecycleHooks } from '../lifecycle-hooks';
+import { KnowledgeStore } from '../store';
+import { KnowledgeQuery } from '../query';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('KnowledgeLifecycleHooks', () => {
+  let store: KnowledgeStore;
+  let query: KnowledgeQuery;
+  let hooks: KnowledgeLifecycleHooks;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
+    store = new KnowledgeStore({ baseDir: path.join(tmpDir, 'knowledge') });
+    query = new KnowledgeQuery(store);
+    hooks = new KnowledgeLifecycleHooks({ store, 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',
+      maturity: 'verified',
+      layer: 'project',
+      created: new Date().toISOString(),
+      lastReferenced: new Date().toISOString(),
+      contributors: [],
+      projects: [],
+      tags: [],
+      applicablePhases: [],
+      sourceReferences: [],
+      referencedBy: [],
+      ...overrides,
+    });
+  }
+
+  describe('onSessionStart', () => {
+    it('应该返回空数组当无知识条目', () => {
+      const sources = hooks.onSessionStart();
+      expect(sources.length).toBe(0);
+    });
+
+    it('应该注入知识条目为 ContextSource', () => {
+      saveEntry({ id: 'dec-001', title: 'Use TypeScript', content: 'Always use TS', tags: ['typescript', 'best-practice'] });
+      const sources = hooks.onSessionStart({ budget: 8000 });
+      expect(sources.length).toBe(1);
+      expect(sources[0].type).toBe('knowledge');
+      expect(sources[0].priority).toBe(3);
+      expect(sources[0].content).toContain('Use TypeScript');
+      expect(sources[0].content).toContain('typescript');
+    });
+
+    it('应该排除指定条目', () => {
+      saveEntry({ id: 'ex-1', title: 'Excluded' });
+      const sources = hooks.onSessionStart({ budget: 8000, exclude: ['ex-1'] });
+      expect(sources.length).toBe(0);
+    });
+  });
+
+  describe('onTaskComplete', () => {
+    it('应该从错误中提取 pitfall', () => {
+      const result = hooks.onTaskComplete({
+        taskDescription: 'Fix login bug',
+        errors: ['TypeError: Cannot read property of undefined'],
+      });
+
+      expect(result.entries.length).toBe(1);
+      expect(result.entries[0].type).toBe('pitfall');
+      expect(result.entries[0].tags).toContain('auto-extract');
+      expect(result.source).toBe('archive');
+    });
+
+    it('应该从决策中提取 decision', () => {
+      const result = hooks.onTaskComplete({
+        taskDescription: 'Choose architecture',
+        decisions: ['使用微服务架构因为需要独立部署'],
+      });
+
+      expect(result.entries.length).toBe(1);
+      expect(result.entries[0].type).toBe('decision');
+    });
+
+    it('应该限制提取数量', () => {
+      const errors = Array.from({ length: 10 }, (_, i) => `Error ${i}`);
+      const result = hooks.onTaskComplete({
+        taskDescription: 'Test',
+        errors,
+      });
+
+      expect(result.entries.length).toBeLessThanOrEqual(3);
+    });
+
+    it('应该处理空上下文', () => {
+      const result = hooks.onTaskComplete({ taskDescription: 'Empty' });
+      expect(result.entries.length).toBe(0);
+    });
+  });
+
+  describe('onError', () => {
+    it('应该从错误中提取知识', () => {
+      const result = hooks.onError(new Error('Connection timeout'), {
+        taskDescription: 'API call',
+        stackTrace: 'at line 42',
+      });
+
+      expect(result.entries.length).toBe(1);
+      expect(result.entries[0].type).toBe('pitfall');
+      expect(result.entries[0].content).toContain('Connection timeout');
+      expect(result.entries[0].content).toContain('API call');
+      expect(result.source).toBe('error');
+    });
+
+    it('应该保存到知识库', () => {
+      hooks.onError(new Error('Test error'));
+      const entries = store.list({ excludeArchived: false });
+      expect(entries.length).toBe(1);
+      expect(entries[0].title).toContain('Test error');
+    });
+
+    it('应该处理无上下文的错误', () => {
+      const result = hooks.onError(new Error('Simple error'));
+      expect(result.entries.length).toBe(1);
+    });
+  });
+});

package/src/knowledge/__tests__/lifecycle.test.ts

@@ -0,0 +1,248 @@
+/**
+ * KnowledgeLifecycle 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { KnowledgeStore } from '../store';
+import { KnowledgeLifecycle } from '../lifecycle';
+import type { KnowledgeEntry } from '../types';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('KnowledgeLifecycle', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-lifecycle');
+  let store: KnowledgeStore;
+  let lifecycle: KnowledgeLifecycle;
+
+  const makeEntry = (overrides?: Partial<KnowledgeEntry>): KnowledgeEntry => ({
+    id: 'DEC-001',
+    type: 'decision',
+    title: 'Test Decision',
+    content: 'Content.',
+    maturity: 'draft',
+    layer: 'project',
+    created: '2026-05-01T00:00:00.000Z',
+    lastReferenced: '',
+    contributors: [],
+    projects: [],
+    tags: [],
+    applicablePhases: [],
+    sourceReferences: [],
+    referencedBy: [],
+    ...overrides,
+  });
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    const files = fs.readdirSync(tempDir);
+    for (const f of files) {
+      fs.unlinkSync(path.join(tempDir, f));
+    }
+    store = new KnowledgeStore({ baseDir: tempDir });
+    lifecycle = new KnowledgeLifecycle(store);
+  });
+
+  describe('recordReference', () => {
+    it('should update lastReferenced', () => {
+      store.save(makeEntry());
+      lifecycle.recordReference('DEC-001');
+      const entry = store.get('DEC-001');
+      expect(entry!.lastReferenced).toBeTruthy();
+    });
+
+    it('should add contributor', () => {
+      store.save(makeEntry());
+      lifecycle.recordReference('DEC-001', 'alice');
+      const entry = store.get('DEC-001');
+      expect(entry!.contributors).toContain('alice');
+    });
+
+    it('should not duplicate contributor', () => {
+      store.save(makeEntry({ contributors: ['alice'] }));
+      lifecycle.recordReference('DEC-001', 'alice');
+      const entry = store.get('DEC-001');
+      expect(entry!.contributors).toEqual(['alice']);
+    });
+
+    it('should return undefined for non-existent entry', () => {
+      expect(lifecycle.recordReference('NON-EXISTENT')).toBeUndefined();
+    });
+  });
+
+  describe('checkPromotion', () => {
+    it('should promote draft to verified when referenced', () => {
+      store.save(makeEntry({ maturity: 'draft', lastReferenced: '2026-05-01' }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBe('verified');
+    });
+
+    it('should not promote unreferenced draft', () => {
+      store.save(makeEntry({ maturity: 'draft', lastReferenced: '' }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBeUndefined();
+    });
+
+    it('should promote verified to proven when criteria met', () => {
+      store.save(makeEntry({
+        maturity: 'verified',
+        contributors: ['a', 'b', 'c'],
+        projects: ['p1', 'p2'],
+      }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBe('proven');
+    });
+
+    it('should not promote verified without enough contributors', () => {
+      store.save(makeEntry({
+        maturity: 'verified',
+        contributors: ['a'],
+        projects: ['p1', 'p2'],
+      }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBeUndefined();
+    });
+
+    it('should not promote verified without enough projects', () => {
+      store.save(makeEntry({
+        maturity: 'verified',
+        contributors: ['a', 'b', 'c'],
+        projects: ['p1'],
+      }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBeUndefined();
+    });
+  });
+
+  describe('checkEntryDecay', () => {
+    it('should decay proven after 12 months', () => {
+      const oldDate = new Date();
+      oldDate.setMonth(oldDate.getMonth() - 13);
+      store.save(makeEntry({
+        maturity: 'proven',
+        lastReferenced: oldDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBe('verified');
+    });
+
+    it('should not decay proven within 12 months', () => {
+      const recentDate = new Date();
+      recentDate.setMonth(recentDate.getMonth() - 6);
+      store.save(makeEntry({
+        maturity: 'proven',
+        lastReferenced: recentDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBeUndefined();
+    });
+
+    it('should decay verified after 6 months', () => {
+      const oldDate = new Date();
+      oldDate.setMonth(oldDate.getMonth() - 7);
+      store.save(makeEntry({
+        maturity: 'verified',
+        lastReferenced: oldDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBe('draft');
+    });
+
+    it('should decay draft after 3 months', () => {
+      const oldDate = new Date();
+      oldDate.setMonth(oldDate.getMonth() - 4);
+      store.save(makeEntry({
+        maturity: 'draft',
+        lastReferenced: oldDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBe('archived');
+    });
+  });
+
+  describe('runDecayCycle', () => {
+    it('should apply decay to all eligible entries', () => {
+      const oldDate = new Date();
+      oldDate.setMonth(oldDate.getMonth() - 13);
+      store.save(makeEntry({ id: 'DEC-001', maturity: 'proven', lastReferenced: oldDate.toISOString() }));
+      store.save(makeEntry({ id: 'DEC-002', maturity: 'draft', lastReferenced: '2026-05-01' }));
+
+      const changes = lifecycle.runDecayCycle();
+      expect(changes).toHaveLength(1);
+      expect(changes[0].entryId).toBe('DEC-001');
+      expect(changes[0].from).toBe('proven');
+      expect(changes[0].to).toBe('verified');
+    });
+  });
+
+  describe('tryPromote', () => {
+    it('should promote eligible entry', () => {
+      store.save(makeEntry({ maturity: 'draft', lastReferenced: '2026-05-01' }));
+      const change = lifecycle.tryPromote('DEC-001');
+      expect(change).toBeDefined();
+      expect(change!.from).toBe('draft');
+      expect(change!.to).toBe('verified');
+
+      const entry = store.get('DEC-001');
+      expect(entry!.maturity).toBe('verified');
+    });
+
+    it('should return undefined for non-eligible entry', () => {
+      store.save(makeEntry({ maturity: 'draft', lastReferenced: '' }));
+      expect(lifecycle.tryPromote('DEC-001')).toBeUndefined();
+    });
+
+    it('should return undefined for non-existent entry', () => {
+      expect(lifecycle.tryPromote('NON-EXISTENT')).toBeUndefined();
+    });
+  });
+
+  describe('checkPromotion edge cases', () => {
+    it('should return undefined for proven entry', () => {
+      store.save(makeEntry({ maturity: 'proven', lastReferenced: '2026-05-01' }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBeUndefined();
+    });
+
+    it('should return undefined for archived entry', () => {
+      store.save(makeEntry({ maturity: 'archived' }));
+      expect(lifecycle.checkPromotion('DEC-001')).toBeUndefined();
+    });
+
+    it('should return undefined for non-existent entry', () => {
+      expect(lifecycle.checkPromotion('NON-EXISTENT')).toBeUndefined();
+    });
+  });
+
+  describe('checkEntryDecay edge cases', () => {
+    it('should not decay verified within threshold', () => {
+      const recentDate = new Date();
+      recentDate.setMonth(recentDate.getMonth() - 3);
+      store.save(makeEntry({
+        maturity: 'verified',
+        lastReferenced: recentDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBeUndefined();
+    });
+
+    it('should return undefined for archived entry', () => {
+      store.save(makeEntry({ maturity: 'archived' }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBeUndefined();
+    });
+
+    it('should return undefined for non-existent entry', () => {
+      expect(lifecycle.checkEntryDecay('NON-EXISTENT')).toBeUndefined();
+    });
+
+    it('should use created date when lastReferenced is empty', () => {
+      const oldDate = new Date();
+      oldDate.setMonth(oldDate.getMonth() - 13);
+      store.save(makeEntry({
+        maturity: 'proven',
+        lastReferenced: '',
+        created: oldDate.toISOString(),
+      }));
+      expect(lifecycle.checkEntryDecay('DEC-001')).toBe('verified');
+    });
+  });
+});