cognitive-core 0.1.0 → 0.2.0

package/tests/memory/knowledge-inbox.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { KnowledgeBank } from '../../src/memory/knowledge-bank.js';
+import type { KnowledgeBankConfig } from '../../src/types/config.js';
+import {
+  createObservation,
+  createEntityNote,
+} from '../../src/types/knowledge.js';
+import { serializeKnowledgeNote } from '../../src/utils/frontmatter.js';
+
+function defaultConfig(): KnowledgeBankConfig {
+  return {
+    enabled: true,
+    memoryDir: 'memory',
+    extraction: {
+      enabled: true,
+      useLlmExtraction: false,
+      minAttributionScore: 0.3,
+    },
+    defrag: {
+      minInboxItems: 5,
+      autoConsolidate: true,
+      consolidationThreshold: 3,
+      autoRegenerateSummaries: true,
+      llmSummaryGeneration: false,
+      autoResolveContradictions: false,
+    },
+    confidence: {
+      extractedInitial: 0.3,
+      agentAuthoredInitial: 0.5,
+      reinforcementAlpha: 0.1,
+      contradictionPenalty: 0.3,
+      dailyDecayRate: 0.001,
+      staleThreshold: 0.2,
+      decayGracePeriodDays: 90,
+    },
+    graph: {
+      enabledLayers: ['semantic', 'entity', 'temporal', 'causal'],
+      inferTemporalEdges: true,
+      inferCausalEdges: true,
+      inferEntityEdges: true,
+      domainSplitThreshold: 500,
+      sqlitePromotionThreshold: 10000,
+    },
+    surfacing: {
+      includeDomainSummaries: true,
+      includeEntityNotes: true,
+      maxNotesPerTask: 5,
+      maxTokensForKnowledge: 2000,
+      includeEvidence: true,
+      includeLinks: false,
+    },
+    minimemAware: false,
+  };
+}
+
+describe('KnowledgeBank Inbox Processing', () => {
+  let tmpDir: string;
+  let bank: KnowledgeBank;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'kb-inbox-test-'));
+    bank = new KnowledgeBank(tmpDir, defaultConfig());
+    await bank.init();
+  });
+
+  afterEach(async () => {
+    try {
+      await bank.close();
+    } catch {
+      // ignore
+    }
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should return zero counts on empty inbox', async () => {
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(0);
+    expect(result.failed).toBe(0);
+    expect(result.movedToObservations).toBe(0);
+    expect(result.movedToEntities).toBe(0);
+    expect(result.movedToDomains).toBe(0);
+  });
+
+  it('should process valid observation notes from inbox', async () => {
+    const obs = createObservation({
+      id: 'k-inbox-obs-1',
+      title: 'Inbox Observation',
+      body: 'A fact from inbox.',
+      domain: ['code'],
+      entities: [],
+      tags: [],
+      source: { origin: 'extracted' },
+    });
+
+    const content = serializeKnowledgeNote(obs);
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(join(inboxDir, 'k-inbox-obs-1.md'), content, 'utf-8');
+
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(1);
+    expect(result.movedToObservations).toBe(1);
+
+    // Should be retrievable from observations dir
+    const note = await bank.getNote('k-inbox-obs-1');
+    expect(note).not.toBeNull();
+    expect(note!.frontmatter.type).toBe('observation');
+  });
+
+  it('should process valid entity notes from inbox', async () => {
+    const entity = createEntityNote({
+      entityName: 'vitest',
+      body: 'Testing framework.',
+      domain: ['testing'],
+      source: { origin: 'extracted' },
+    });
+
+    const content = serializeKnowledgeNote(entity);
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(join(inboxDir, 'vitest.md'), content, 'utf-8');
+
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(1);
+    expect(result.movedToEntities).toBe(1);
+
+    const note = await bank.getEntity('vitest');
+    expect(note).not.toBeNull();
+  });
+
+  it('should apply heuristic to raw files without frontmatter', async () => {
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(
+      join(inboxDir, 'random-note.md'),
+      'This is just a plain text note with no frontmatter.',
+      'utf-8'
+    );
+
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(1);
+    expect(result.movedToObservations).toBe(1);
+
+    // Should be retrievable with heuristic classification
+    const note = await bank.getNote('random-note');
+    expect(note).not.toBeNull();
+    expect(note!.frontmatter.type).toBe('observation');
+    expect(note!.frontmatter.source.origin).toBe('agent-authored');
+    expect(note!.frontmatter.tags).toContain('inbox-processed');
+    // Should use agentAuthoredInitial confidence (0.5)
+    expect(note!.frontmatter.confidence).toBe(0.5);
+  });
+
+  it('should remove files from inbox after processing', async () => {
+    const obs = createObservation({
+      id: 'k-inbox-remove',
+      title: 'Removable',
+      body: 'Will be moved.',
+      domain: ['code'],
+      entities: [],
+      tags: [],
+      source: { origin: 'extracted' },
+    });
+
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(
+      join(inboxDir, 'k-inbox-remove.md'),
+      serializeKnowledgeNote(obs),
+      'utf-8'
+    );
+
+    await bank.processInbox();
+
+    // Inbox should be empty now
+    const stats = await bank.getStats();
+    expect(stats.inboxCount).toBe(0);
+  });
+
+  it('should add processed notes to graph', async () => {
+    const obs = createObservation({
+      id: 'k-inbox-graph',
+      title: 'Graph node',
+      body: 'Should be in graph.',
+      domain: ['code'],
+      entities: ['vitest'],
+      tags: [],
+      source: { origin: 'extracted' },
+    });
+
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(
+      join(inboxDir, 'k-inbox-graph.md'),
+      serializeKnowledgeNote(obs),
+      'utf-8'
+    );
+
+    await bank.processInbox();
+
+    const graphNode = bank.graph.getNode('k-inbox-graph');
+    expect(graphNode).toBeDefined();
+    expect(graphNode!.type).toBe('observation');
+  });
+
+  it('should process multiple files', async () => {
+    const inboxDir = join(tmpDir, 'inbox');
+
+    for (let i = 0; i < 3; i++) {
+      const obs = createObservation({
+        id: `k-inbox-multi-${i}`,
+        title: `Multi ${i}`,
+        body: `Note ${i}.`,
+        domain: ['code'],
+        entities: [],
+        tags: [],
+        source: { origin: 'extracted' },
+      });
+      await writeFile(
+        join(inboxDir, `k-inbox-multi-${i}.md`),
+        serializeKnowledgeNote(obs),
+        'utf-8'
+      );
+    }
+
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(3);
+  });
+
+  it('should ignore non-md files in inbox', async () => {
+    const inboxDir = join(tmpDir, 'inbox');
+    await writeFile(join(inboxDir, 'data.json'), '{"key": "value"}', 'utf-8');
+    await writeFile(join(inboxDir, 'readme.txt'), 'text file', 'utf-8');
+
+    const result = await bank.processInbox();
+    expect(result.processed).toBe(0);
+  });
+
+  describe('shouldDefragment', () => {
+    it('should return false when inbox is empty', async () => {
+      expect(await bank.shouldDefragment()).toBe(false);
+    });
+
+    it('should return true when inbox count >= minInboxItems', async () => {
+      const inboxDir = join(tmpDir, 'inbox');
+      for (let i = 0; i < 5; i++) {
+        await writeFile(join(inboxDir, `note-${i}.md`), 'content', 'utf-8');
+      }
+      expect(await bank.shouldDefragment()).toBe(true);
+    });
+
+    it('should return false when inbox count < minInboxItems', async () => {
+      const inboxDir = join(tmpDir, 'inbox');
+      for (let i = 0; i < 3; i++) {
+        await writeFile(join(inboxDir, `note-${i}.md`), 'content', 'utf-8');
+      }
+      expect(await bank.shouldDefragment()).toBe(false);
+    });
+  });
+});

package/tests/memory/knowledge-minimem.test.ts

@@ -0,0 +1,251 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, rm, readdir, access } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { KnowledgeBank } from '../../src/memory/knowledge-bank.js';
+import type { KnowledgeBankConfig } from '../../src/types/config.js';
+import { createObservation } from '../../src/types/knowledge.js';
+import { TextSimilaritySearchProvider } from '../../src/memory/search-providers/text-similarity.js';
+import {
+  MinimemSearchProvider,
+  type MinimemSearchClient,
+} from '../../src/memory/search-providers/minimem.js';
+
+function defaultConfig(overrides?: Partial<KnowledgeBankConfig>): KnowledgeBankConfig {
+  return {
+    enabled: true,
+    memoryDir: 'memory',
+    extraction: {
+      enabled: true,
+      useLlmExtraction: false,
+      minAttributionScore: 0.3,
+    },
+    defrag: {
+      minInboxItems: 5,
+      autoConsolidate: true,
+      consolidationThreshold: 3,
+      autoRegenerateSummaries: true,
+      llmSummaryGeneration: false,
+      autoResolveContradictions: false,
+    },
+    confidence: {
+      extractedInitial: 0.3,
+      agentAuthoredInitial: 0.5,
+      reinforcementAlpha: 0.1,
+      contradictionPenalty: 0.3,
+      dailyDecayRate: 0.001,
+      staleThreshold: 0.2,
+      decayGracePeriodDays: 90,
+    },
+    graph: {
+      enabledLayers: ['semantic'],
+      inferTemporalEdges: true,
+      inferCausalEdges: true,
+      inferEntityEdges: true,
+      domainSplitThreshold: 500,
+      sqlitePromotionThreshold: 10000,
+    },
+    surfacing: {
+      includeDomainSummaries: true,
+      includeEntityNotes: true,
+      maxNotesPerTask: 5,
+      maxTokensForKnowledge: 2000,
+      includeEvidence: false,
+      includeLinks: false,
+    },
+    minimemAware: false,
+    ...overrides,
+  };
+}
+
+function sampleNote(id: string, body: string) {
+  return createObservation({
+    id,
+    title: `Note ${id}`,
+    body,
+    domain: ['testing'],
+    entities: [],
+    tags: [],
+    source: { origin: 'extracted' },
+  });
+}
+
+describe('KnowledgeBank: minimem integration', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'kb-minimem-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // =========================================================================
+  // File layout
+  // =========================================================================
+
+  describe('file layout', () => {
+    it('minimemAware: false places files under knowledge/', async () => {
+      const bank = new KnowledgeBank(tmpDir, defaultConfig());
+      await bank.addObservation(sampleNote('k-std', 'Standard layout'));
+      await bank.close();
+
+      const dirs = await readdir(tmpDir, { recursive: true });
+      const dirNames = dirs.map(String);
+
+      expect(dirNames).toContain(join('knowledge', 'observations'));
+      // Should NOT have memory/knowledge path
+      const hasMemoryKnowledge = dirNames.some((d) =>
+        d.startsWith(join('memory', 'knowledge'))
+      );
+      expect(hasMemoryKnowledge).toBe(false);
+    });
+
+    it('minimemAware: true places files under memory/knowledge/', async () => {
+      const bank = new KnowledgeBank(
+        tmpDir,
+        defaultConfig({ minimemAware: true })
+      );
+      await bank.addObservation(sampleNote('k-mm', 'Minimem layout'));
+      await bank.close();
+
+      const dirs = await readdir(tmpDir, { recursive: true });
+      const dirNames = dirs.map(String);
+
+      expect(dirNames).toContain(
+        join('memory', 'knowledge', 'observations')
+      );
+    });
+
+    it('minimemAware: true does not create MEMORY.md', async () => {
+      const bank = new KnowledgeBank(
+        tmpDir,
+        defaultConfig({ minimemAware: true })
+      );
+      await bank.init();
+      await bank.close();
+
+      await expect(
+        access(join(tmpDir, 'MEMORY.md'))
+      ).rejects.toThrow();
+    });
+
+    it('notes persist and reload with minimem-aware paths', async () => {
+      const config = defaultConfig({ minimemAware: true });
+      const bank1 = new KnowledgeBank(tmpDir, config);
+      await bank1.addObservation(sampleNote('k-persist', 'Persisted note'));
+      await bank1.close();
+
+      const bank2 = new KnowledgeBank(tmpDir, config);
+      await bank2.init();
+      const note = await bank2.getNote('k-persist');
+      expect(note).not.toBeNull();
+      expect(note!.body).toContain('Persisted note');
+      await bank2.close();
+    });
+  });
+
+  // =========================================================================
+  // Search delegation
+  // =========================================================================
+
+  describe('search delegation', () => {
+    it('delegates to mock MinimemSearchClient and maps results', async () => {
+      const bank = new KnowledgeBank(tmpDir, defaultConfig());
+      const note = sampleNote('k-delegated', 'Delegated search content');
+      await bank.addObservation(note);
+
+      const mockClient: MinimemSearchClient = {
+        search: vi.fn().mockResolvedValue([
+          { path: note.filePath, score: 0.95 },
+        ]),
+      };
+      const provider = new MinimemSearchProvider(mockClient);
+      bank.setSearchProvider(provider);
+
+      const results = await bank.search('delegated');
+      expect(results.length).toBe(1);
+      expect(results[0].note.frontmatter.id).toBe('k-delegated');
+      expect(results[0].score).toBe(0.95);
+      expect(results[0].matchType).toBe('semantic');
+    });
+
+    it('returns empty when mock throws', async () => {
+      const bank = new KnowledgeBank(tmpDir, defaultConfig());
+      await bank.addObservation(sampleNote('k-err', 'Error test'));
+
+      const mockClient: MinimemSearchClient = {
+        search: vi.fn().mockRejectedValue(new Error('connection failed')),
+      };
+      const provider = new MinimemSearchProvider(mockClient);
+      bank.setSearchProvider(provider);
+
+      const results = await bank.search('error');
+      expect(results).toEqual([]);
+    });
+
+    it('setSearchProvider() replaces the active provider', async () => {
+      const bank = new KnowledgeBank(tmpDir, defaultConfig());
+      await bank.init();
+
+      expect(bank.getSearchProviderName()).toBe('text-similarity');
+
+      const mockClient: MinimemSearchClient = {
+        search: vi.fn().mockResolvedValue([]),
+      };
+      bank.setSearchProvider(new MinimemSearchProvider(mockClient));
+
+      expect(bank.getSearchProviderName()).toBe('minimem');
+      await bank.close();
+    });
+
+    it('getSearchProviderName() reflects the active provider', async () => {
+      const bank = new KnowledgeBank(tmpDir, defaultConfig());
+      await bank.init();
+      expect(bank.getSearchProviderName()).toBe('text-similarity');
+      await bank.close();
+    });
+
+    it('minimemAware: true without .minimem/ falls back to text-similarity', async () => {
+      // No .minimem dir or MEMORY.md exists — should fall back
+      const bank = new KnowledgeBank(
+        tmpDir,
+        defaultConfig({ minimemAware: true })
+      );
+      await bank.init();
+
+      // Should still use text-similarity since minimem is not installed
+      expect(bank.getSearchProviderName()).toBe('text-similarity');
+      await bank.close();
+    });
+  });
+
+  // =========================================================================
+  // SearchProvider abstraction
+  // =========================================================================
+
+  describe('SearchProvider abstraction', () => {
+    it('TextSimilaritySearchProvider produces correct results', () => {
+      const provider = new TextSimilaritySearchProvider();
+      const notes = [
+        sampleNote('k-match', 'Database migration patterns and approaches'),
+        sampleNote('k-other', 'React component lifecycle hooks'),
+      ];
+
+      const results = provider.search('database migration', notes, {
+        maxResults: 5,
+      });
+
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0].noteId).toBe('k-match');
+      expect(results[0].score).toBeGreaterThan(0);
+    });
+
+    it('returns empty for zero candidates', () => {
+      const provider = new TextSimilaritySearchProvider();
+      const results = provider.search('anything', [], { maxResults: 5 });
+      expect(results).toEqual([]);
+    });
+  });
+});