cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,366 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { KnowledgeBank } from '../../src/memory/knowledge-bank.js';
+import { KnowledgeDefragmenter } from '../../src/memory/knowledge-defrag.js';
+import type { KnowledgeBankConfig, DefragConfig } 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('KnowledgeDefragmenter', () => {
+  let tmpDir: string;
+  let bank: KnowledgeBank;
+  let defragmenter: KnowledgeDefragmenter;
+  const config = defaultConfig();
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'kb-defrag-test-'));
+    bank = new KnowledgeBank(tmpDir, config);
+    await bank.init();
+    defragmenter = new KnowledgeDefragmenter(bank, config.defrag);
+  });
+
+  afterEach(async () => {
+    try {
+      await bank.close();
+    } catch {
+      // ignore
+    }
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // =========================================================================
+  // Full Cycle
+  // =========================================================================
+
+  describe('full defrag cycle', () => {
+    it('should run all 7 steps on empty bank', async () => {
+      const result = await defragmenter.defragment();
+
+      expect(result.inbox.processed).toBe(0);
+      expect(result.consolidated).toBe(0);
+      expect(result.contradictions).toBe(0);
+      expect(result.graphRebuilt).toBe(true);
+      expect(result.domainSummariesRegenerated).toBe(0);
+      expect(result.decay.decayed).toBe(0);
+    });
+
+    it('should run full cycle with some notes', async () => {
+      // Add a few observations
+      for (let i = 0; i < 3; i++) {
+        await bank.addObservation(
+          createObservation({
+            id: `k-cycle-${i}`,
+            title: `Cycle ${i}`,
+            body: `Observation ${i}.`,
+            domain: ['code'],
+            entities: ['vitest'],
+            tags: [],
+            source: { origin: 'extracted' },
+          })
+        );
+      }
+
+      const result = await defragmenter.defragment();
+      expect(result.graphRebuilt).toBe(true);
+      // Should have consolidated 3 observations about 'vitest'
+      expect(result.consolidated).toBeGreaterThanOrEqual(3);
+      // Should have regenerated domain summary for 'code'
+      expect(result.domainSummariesRegenerated).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  // =========================================================================
+  // Consolidation
+  // =========================================================================
+
+  describe('consolidation', () => {
+    it('should create entity note from ≥3 observations with same entity', async () => {
+      for (let i = 0; i < 3; i++) {
+        await bank.addObservation(
+          createObservation({
+            id: `k-cons-${i}`,
+            title: `Cons ${i}`,
+            body: `Fact about prisma ${i}.`,
+            domain: ['db'],
+            entities: ['prisma'],
+            tags: [],
+            source: { origin: 'extracted' },
+          })
+        );
+      }
+
+      const result = await defragmenter.defragment();
+      expect(result.consolidated).toBeGreaterThanOrEqual(3);
+
+      // Entity note should exist
+      const entity = await bank.getEntity('prisma');
+      expect(entity).not.toBeNull();
+      expect(entity!.frontmatter.type).toBe('entity');
+    });
+
+    it('should add generalizes links from entity to observations', async () => {
+      for (let i = 0; i < 3; i++) {
+        await bank.addObservation(
+          createObservation({
+            id: `k-gen-${i}`,
+            title: `Gen ${i}`,
+            body: `Fact about react ${i}.`,
+            domain: ['web'],
+            entities: ['react'],
+            tags: [],
+            source: { origin: 'extracted' },
+          })
+        );
+      }
+
+      await defragmenter.defragment();
+
+      const semanticLayer = bank.graph.getLayer('semantic');
+      expect(semanticLayer).not.toBeNull();
+      const edges = semanticLayer!.getEdges('react', 'outgoing');
+      const generalizeEdges = edges.filter(
+        (e) => e.relation === 'generalizes'
+      );
+      expect(generalizeEdges.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('should not consolidate below threshold', async () => {
+      // Only 2 observations about the same entity (threshold is 3)
+      for (let i = 0; i < 2; i++) {
+        await bank.addObservation(
+          createObservation({
+            id: `k-below-${i}`,
+            title: `Below ${i}`,
+            body: `Fact about vue ${i}.`,
+            domain: ['web'],
+            entities: ['vue'],
+            tags: [],
+            source: { origin: 'extracted' },
+          })
+        );
+      }
+
+      const result = await defragmenter.defragment();
+      expect(result.consolidated).toBe(0);
+
+      const entity = await bank.getEntity('vue');
+      expect(entity).toBeNull();
+    });
+
+    it('should append to existing entity note', async () => {
+      // Create an existing entity
+      const entity = createEntityNote({
+        entityName: 'typescript',
+        body: 'A typed superset of JavaScript.',
+        domain: ['code'],
+        source: { origin: 'extracted' },
+      });
+      await bank.addObservation(entity);
+
+      // Add 3 observations about it
+      for (let i = 0; i < 3; i++) {
+        await bank.addObservation(
+          createObservation({
+            id: `k-ts-${i}`,
+            title: `TS ${i}`,
+            body: `TypeScript fact ${i}.`,
+            domain: ['code'],
+            entities: ['typescript'],
+            tags: [],
+            source: { origin: 'extracted' },
+          })
+        );
+      }
+
+      await defragmenter.defragment();
+
+      const updatedEntity = await bank.getEntity('typescript');
+      expect(updatedEntity).not.toBeNull();
+      expect(updatedEntity!.body).toContain('Consolidated Observations');
+    });
+  });
+
+  // =========================================================================
+  // Domain Summaries
+  // =========================================================================
+
+  describe('domain summary regeneration', () => {
+    it('should regenerate domain summaries', async () => {
+      await bank.addObservation(
+        createObservation({
+          id: 'k-domain-obs',
+          title: 'Domain Obs',
+          body: 'A code observation.',
+          domain: ['code'],
+          entities: ['node'],
+          tags: [],
+          source: { origin: 'extracted' },
+        })
+      );
+
+      const result = await defragmenter.defragment();
+      expect(result.domainSummariesRegenerated).toBeGreaterThanOrEqual(1);
+
+      const summary = await bank.getDomainSummary('code');
+      expect(summary).not.toBeNull();
+      expect(summary!.frontmatter.type).toBe('domain-summary');
+    });
+  });
+
+  // =========================================================================
+  // Graph Rebuild
+  // =========================================================================
+
+  describe('graph rebuild', () => {
+    it('should rebuild graph during defrag', async () => {
+      await bank.addObservation(
+        createObservation({
+          id: 'k-rebuild',
+          title: 'Rebuild',
+          body: 'A note.',
+          domain: ['code'],
+          entities: [],
+          tags: [],
+          source: { origin: 'extracted' },
+        })
+      );
+
+      const result = await defragmenter.defragment();
+      expect(result.graphRebuilt).toBe(true);
+
+      // Node should still exist after rebuild
+      const node = bank.graph.getNode('k-rebuild');
+      expect(node).toBeDefined();
+    });
+  });
+
+  // =========================================================================
+  // Manifest
+  // =========================================================================
+
+  describe('manifest update', () => {
+    it('should write manifest.json and domain-index.json', async () => {
+      await bank.addObservation(
+        createObservation({
+          id: 'k-manifest',
+          title: 'Manifest',
+          body: 'A note.',
+          domain: ['code'],
+          entities: [],
+          tags: [],
+          source: { origin: 'extracted' },
+        })
+      );
+
+      await defragmenter.defragment();
+
+      const indexDir = bank.getIndexDir();
+
+      const manifest = JSON.parse(
+        await readFile(join(indexDir, 'manifest.json'), 'utf-8')
+      );
+      expect(manifest['k-manifest']).toBeDefined();
+      expect(manifest['k-manifest'].type).toBe('observation');
+
+      const domainIndex = JSON.parse(
+        await readFile(join(indexDir, 'domain-index.json'), 'utf-8')
+      );
+      expect(domainIndex['code']).toContain('k-manifest');
+    });
+  });
+
+  // =========================================================================
+  // shouldDefragment
+  // =========================================================================
+
+  describe('shouldDefragment', () => {
+    it('should return false when inbox is below threshold', async () => {
+      expect(await defragmenter.shouldDefragment()).toBe(false);
+    });
+
+    it('should return true when inbox meets threshold', 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 defragmenter.shouldDefragment()).toBe(true);
+    });
+  });
+
+  // =========================================================================
+  // Decay during defrag
+  // =========================================================================
+
+  describe('staleness sweep', () => {
+    it('should apply decay during defrag cycle', async () => {
+      const obs = createObservation({
+        id: 'k-defrag-decay',
+        title: 'Old',
+        body: 'Old note.',
+        domain: ['code'],
+        entities: [],
+        tags: [],
+        confidence: 0.5,
+        source: { origin: 'extracted' },
+      });
+      obs.frontmatter.updated = new Date(
+        Date.now() - 100 * 24 * 60 * 60 * 1000
+      ).toISOString();
+      await bank.addObservation(obs);
+
+      const result = await defragmenter.defragment();
+      expect(result.decay.decayed).toBeGreaterThanOrEqual(1);
+    });
+  });
+});