@soleri/core 2.0.0 → 2.0.2

package/src/__tests__/brain.test.ts

@@ -1,9 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Vault } from '../vault/vault.js';
 import { Brain } from '../brain/brain.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
-import type { CogneeClient } from '../cognee/client.js';
-import type { CogneeSearchResult, CogneeStatus } from '../cognee/types.js';
 
 function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
   return {
@@ -17,36 +15,6 @@ function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntr
   };
 }
 
-function makeMockCognee(
-  overrides: {
-    available?: boolean;
-    searchResults?: CogneeSearchResult[];
-    searchError?: boolean;
-  } = {},
-): CogneeClient {
-  const available = overrides.available ?? true;
-  return {
-    get isAvailable() {
-      return available;
-    },
-    search: overrides.searchError
-      ? vi.fn().mockRejectedValue(new Error('timeout'))
-      : vi.fn().mockResolvedValue(overrides.searchResults ?? []),
-    addEntries: vi.fn().mockResolvedValue({ added: 0 }),
-    cognify: vi.fn().mockResolvedValue({ status: 'ok' }),
-    healthCheck: vi
-      .fn()
-      .mockResolvedValue({ available, url: 'http://localhost:8000', latencyMs: 1 } as CogneeStatus),
-    getConfig: vi.fn().mockReturnValue({
-      baseUrl: 'http://localhost:8000',
-      dataset: 'vault',
-      timeoutMs: 5000,
-      healthCacheTtlMs: 60000,
-    }),
-    getStatus: vi.fn().mockReturnValue(null),
-  } as unknown as CogneeClient;
-}
-
 describe('Brain', () => {
   let vault: Vault;
   let brain: Brain;
@@ -85,12 +53,6 @@ describe('Brain', () => {
       const brain2 = new Brain(vault);
       expect(brain2.getVocabularySize()).toBeGreaterThan(0);
     });
-
-    it('should accept optional CogneeClient', () => {
-      const cognee = makeMockCognee();
-      const brain2 = new Brain(vault, cognee);
-      expect(brain2.getVocabularySize()).toBe(0);
-    });
   });
 
   // ─── Intelligent Search ──────────────────────────────────────
@@ -127,52 +89,49 @@ describe('Brain', () => {
       brain = new Brain(vault);
     });
 
-    it('should return ranked results', async () => {
-      const results = await brain.intelligentSearch('validation input');
+    it('should return ranked results', () => {
+      const results = brain.intelligentSearch('validation input');
       expect(results.length).toBeGreaterThan(0);
       expect(results[0].entry.id).toBe('is-1');
     });
 
-    it('should include score breakdown with vector field', async () => {
-      const results = await brain.intelligentSearch('validation');
+    it('should include score breakdown', () => {
+      const results = brain.intelligentSearch('validation');
       expect(results.length).toBeGreaterThan(0);
       const breakdown = results[0].breakdown;
       expect(breakdown).toHaveProperty('semantic');
-      expect(breakdown).toHaveProperty('vector');
       expect(breakdown).toHaveProperty('severity');
       expect(breakdown).toHaveProperty('recency');
       expect(breakdown).toHaveProperty('tagOverlap');
       expect(breakdown).toHaveProperty('domainMatch');
       expect(breakdown).toHaveProperty('total');
       expect(breakdown.total).toBe(results[0].score);
-      // Without cognee, vector should be 0
-      expect(breakdown.vector).toBe(0);
     });
 
-    it('should return empty array for no matches', async () => {
-      const results = await brain.intelligentSearch('xyznonexistent');
+    it('should return empty array for no matches', () => {
+      const results = brain.intelligentSearch('xyznonexistent');
       expect(results).toEqual([]);
     });
 
-    it('should respect limit', async () => {
-      const results = await brain.intelligentSearch('pattern', { limit: 1 });
+    it('should respect limit', () => {
+      const results = brain.intelligentSearch('pattern', { limit: 1 });
       expect(results.length).toBeLessThanOrEqual(1);
     });
 
-    it('should filter by domain', async () => {
-      const results = await brain.intelligentSearch('pattern', { domain: 'security' });
+    it('should filter by domain', () => {
+      const results = brain.intelligentSearch('pattern', { domain: 'security' });
       expect(results.every((r) => r.entry.domain === 'security')).toBe(true);
     });
 
-    it('should boost domain matches when domain is specified', async () => {
-      const withDomain = await brain.intelligentSearch('pattern', { domain: 'security' });
+    it('should boost domain matches when domain is specified', () => {
+      const withDomain = brain.intelligentSearch('pattern', { domain: 'security' });
       if (withDomain.length > 0) {
         expect(withDomain[0].breakdown.domainMatch).toBe(1.0);
       }
     });
 
-    it('should boost severity in scoring', async () => {
-      const results = await brain.intelligentSearch('pattern');
+    it('should boost severity in scoring', () => {
+      const results = brain.intelligentSearch('pattern');
       if (results.length >= 2) {
         const critical = results.find((r) => r.entry.severity === 'critical');
         const suggestion = results.find((r) => r.entry.severity === 'suggestion');
@@ -182,10 +141,8 @@ describe('Brain', () => {
       }
     });
 
-    it('should boost tag overlap when tags provided', async () => {
-      const results = await brain.intelligentSearch('pattern', {
-        tags: ['validation', 'security'],
-      });
+    it('should boost tag overlap when tags provided', () => {
+      const results = brain.intelligentSearch('pattern', { tags: ['validation', 'security'] });
       if (results.length > 0) {
         const secEntry = results.find((r) => r.entry.id === 'is-1');
         if (secEntry) {
@@ -194,142 +151,15 @@ describe('Brain', () => {
       }
     });
 
-    it('should handle search on empty vault gracefully', async () => {
+    it('should handle search on empty vault gracefully', () => {
       const emptyVault = new Vault(':memory:');
       const emptyBrain = new Brain(emptyVault);
-      const results = await emptyBrain.intelligentSearch('anything');
+      const results = emptyBrain.intelligentSearch('anything');
       expect(results).toEqual([]);
       emptyVault.close();
     });
   });
 
-  // ─── Hybrid Search (with Cognee) ──────────────────────────────
-
-  describe('hybrid search with Cognee', () => {
-    beforeEach(() => {
-      vault.seed([
-        makeEntry({
-          id: 'hs-1',
-          title: 'Authentication flow',
-          description: 'JWT-based authentication for API endpoints.',
-          domain: 'security',
-          severity: 'critical',
-          tags: ['auth', 'jwt'],
-        }),
-        makeEntry({
-          id: 'hs-2',
-          title: 'Logging best practices',
-          description: 'Structured logging with correlation IDs for debugging.',
-          domain: 'observability',
-          severity: 'warning',
-          tags: ['logging', 'debugging'],
-        }),
-      ]);
-    });
-
-    it('should include vector scores from Cognee in breakdown', async () => {
-      const cognee = makeMockCognee({
-        searchResults: [{ id: 'hs-1', score: 0.92, text: 'Auth flow', searchType: 'INSIGHTS' }],
-      });
-      const hybridBrain = new Brain(vault, cognee);
-      const results = await hybridBrain.intelligentSearch('authentication');
-      expect(results.length).toBeGreaterThan(0);
-      const authResult = results.find((r) => r.entry.id === 'hs-1');
-      expect(authResult).toBeDefined();
-      expect(authResult!.breakdown.vector).toBe(0.92);
-    });
-
-    it('should use cognee-aware weights when vector results are present', async () => {
-      const cognee = makeMockCognee({
-        searchResults: [{ id: 'hs-1', score: 0.9, text: 'Auth', searchType: 'INSIGHTS' }],
-      });
-      const hybridBrain = new Brain(vault, cognee);
-      const results = await hybridBrain.intelligentSearch('authentication');
-      // With cognee weights, vector contributes significantly
-      const authResult = results.find((r) => r.entry.id === 'hs-1');
-      expect(authResult).toBeDefined();
-      // vector=0.9 * weight=0.35 = 0.315 contribution
-      expect(authResult!.breakdown.vector).toBe(0.9);
-    });
-
-    it('should merge cognee-only entries into results', async () => {
-      // hs-2 may not match FTS5 for "authentication" but Cognee finds it via semantic similarity
-      const cognee = makeMockCognee({
-        searchResults: [
-          { id: 'hs-1', score: 0.95, text: 'Auth', searchType: 'INSIGHTS' },
-          { id: 'hs-2', score: 0.6, text: 'Logging', searchType: 'INSIGHTS' },
-        ],
-      });
-      const hybridBrain = new Brain(vault, cognee);
-      const results = await hybridBrain.intelligentSearch('authentication');
-      // Both entries should be in results (hs-2 merged from Cognee even if not in FTS5)
-      const ids = results.map((r) => r.entry.id);
-      expect(ids).toContain('hs-1');
-      expect(ids).toContain('hs-2');
-      const loggingResult = results.find((r) => r.entry.id === 'hs-2');
-      expect(loggingResult).toBeDefined();
-      expect(loggingResult!.breakdown.vector).toBe(0.6);
-    });
-
-    it('should fall back to FTS5-only on Cognee search error', async () => {
-      const cognee = makeMockCognee({ searchError: true });
-      const hybridBrain = new Brain(vault, cognee);
-      const results = await hybridBrain.intelligentSearch('authentication');
-      // Should still work, just without vector scores
-      for (const r of results) {
-        expect(r.breakdown.vector).toBe(0);
-      }
-    });
-
-    it('should work without Cognee (backward compatible)', async () => {
-      const noCogneeBrain = new Brain(vault);
-      const results = await noCogneeBrain.intelligentSearch('authentication');
-      for (const r of results) {
-        expect(r.breakdown.vector).toBe(0);
-      }
-    });
-
-    it('should handle unavailable Cognee gracefully', async () => {
-      const cognee = makeMockCognee({ available: false });
-      const hybridBrain = new Brain(vault, cognee);
-      const results = await hybridBrain.intelligentSearch('authentication');
-      for (const r of results) {
-        expect(r.breakdown.vector).toBe(0);
-      }
-      // search should not have been called
-      expect(cognee.search).not.toHaveBeenCalled();
-    });
-  });
-
-  // ─── syncToCognee ──────────────────────────────────────────────
-
-  describe('syncToCognee', () => {
-    it('should return 0 when Cognee not available', async () => {
-      const result = await brain.syncToCognee();
-      expect(result).toEqual({ synced: 0, cognified: false });
-    });
-
-    it('should sync all entries and cognify', async () => {
-      vault.seed([makeEntry({ id: 'sync-1' }), makeEntry({ id: 'sync-2' })]);
-      const cognee = makeMockCognee();
-      (cognee.addEntries as ReturnType<typeof vi.fn>).mockResolvedValue({ added: 2 });
-      const hybridBrain = new Brain(vault, cognee);
-      const result = await hybridBrain.syncToCognee();
-      expect(result.synced).toBe(2);
-      expect(result.cognified).toBe(true);
-      expect(cognee.addEntries).toHaveBeenCalledTimes(1);
-      expect(cognee.cognify).toHaveBeenCalledTimes(1);
-    });
-
-    it('should skip cognify when no entries added', async () => {
-      const cognee = makeMockCognee();
-      const hybridBrain = new Brain(vault, cognee);
-      const result = await hybridBrain.syncToCognee();
-      expect(result.synced).toBe(0);
-      expect(result.cognified).toBe(false);
-    });
-  });
-
   // ─── Enrich and Capture ─────────────────────────────────────
 
   describe('enrichAndCapture', () => {
@@ -413,21 +243,6 @@ describe('Brain', () => {
       const entry = vault.get('cap-5');
       expect(entry!.tags.length).toBeGreaterThan(0);
     });
-
-    it('should fire-and-forget sync to Cognee on capture', () => {
-      const cognee = makeMockCognee();
-      const hybridBrain = new Brain(vault, cognee);
-      hybridBrain.enrichAndCapture({
-        id: 'cap-cognee-1',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Cognee sync test',
-        severity: 'warning',
-        description: 'Testing fire-and-forget Cognee sync.',
-        tags: [],
-      });
-      expect(cognee.addEntries).toHaveBeenCalledTimes(1);
-    });
   });
 
   // ─── Duplicate Detection ────────────────────────────────────
@@ -539,7 +354,6 @@ describe('Brain', () => {
       const stats = brain.getStats();
       const sum =
         stats.weights.semantic +
-        stats.weights.vector +
         stats.weights.severity +
         stats.weights.recency +
         stats.weights.tagOverlap +
@@ -557,11 +371,6 @@ describe('Brain', () => {
       const stats = brain.getStats();
       expect(stats.weights.semantic).toBeCloseTo(0.4, 1);
     });
-
-    it('should keep vector weight at 0 in base weights', () => {
-      const stats = brain.getStats();
-      expect(stats.weights.vector).toBe(0);
-    });
   });
 
   // ─── Vocabulary ─────────────────────────────────────────────
@@ -633,7 +442,6 @@ describe('Brain', () => {
       expect(stats.vocabularySize).toBe(0);
       expect(stats.feedbackCount).toBe(0);
       expect(stats.weights.semantic).toBeCloseTo(0.4, 2);
-      expect(stats.weights.vector).toBe(0);
     });
 
     it('should return correct vocabulary size after seeding', () => {
@@ -667,7 +475,7 @@ describe('Brain', () => {
   // ─── Get Relevant Patterns ──────────────────────────────────
 
   describe('getRelevantPatterns', () => {
-    it('should return ranked results for query context', async () => {
+    it('should return ranked results for query context', () => {
       vault.seed([
         makeEntry({
           id: 'rel-1',
@@ -685,15 +493,12 @@ describe('Brain', () => {
         }),
       ]);
       brain = new Brain(vault);
-      const results = await brain.getRelevantPatterns({
-        query: 'authentication',
-        domain: 'security',
-      });
+      const results = brain.getRelevantPatterns({ query: 'authentication', domain: 'security' });
       expect(results.length).toBeGreaterThan(0);
     });
 
-    it('should return empty for no context matches', async () => {
-      const results = await brain.getRelevantPatterns({ query: 'nonexistent' });
+    it('should return empty for no context matches', () => {
+      const results = brain.getRelevantPatterns({ query: 'nonexistent' });
       expect(results).toEqual([]);
     });
   });
@@ -701,13 +506,13 @@ describe('Brain', () => {
   // ─── Graceful Degradation ───────────────────────────────────
 
   describe('graceful degradation', () => {
-    it('should work without vocabulary (empty vault)', async () => {
+    it('should work without vocabulary (empty vault)', () => {
       expect(brain.getVocabularySize()).toBe(0);
-      const results = await brain.intelligentSearch('anything');
+      const results = brain.intelligentSearch('anything');
       expect(results).toEqual([]);
     });
 
-    it('should fall back to severity + recency scoring when vocabulary is empty', async () => {
+    it('should fall back to severity + recency scoring when vocabulary is empty', () => {
       vault.seed([
         makeEntry({
           id: 'gd-1',
@@ -718,7 +523,7 @@ describe('Brain', () => {
         }),
       ]);
       brain = new Brain(vault);
-      const results = await brain.intelligentSearch('fallback test');
+      const results = brain.intelligentSearch('fallback test');
       expect(results.length).toBeGreaterThan(0);
       expect(results[0].score).toBeGreaterThan(0);
     });

package/src/__tests__/core-ops.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createCoreOps } from '../runtime/core-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createCoreOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let plannerDir: string;
+
+  beforeEach(() => {
+    plannerDir = join(tmpdir(), 'core-ops-test-' + Date.now());
+    mkdirSync(plannerDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'test-core-ops',
+      vaultPath: ':memory:',
+      plansPath: join(plannerDir, 'plans.json'),
+    });
+    ops = createCoreOps(runtime);
+  });
+
+  afterEach(() => {
+    runtime.close();
+    rmSync(plannerDir, { recursive: true, force: true });
+  });
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('should return 26 ops', () => {
+    expect(ops.length).toBe(26);
+  });
+
+  it('should have all expected op names', () => {
+    const names = ops.map((o) => o.name);
+    // Search/Vault
+    expect(names).toContain('search');
+    expect(names).toContain('vault_stats');
+    expect(names).toContain('list_all');
+    expect(names).toContain('register');
+    // Memory
+    expect(names).toContain('memory_search');
+    expect(names).toContain('memory_capture');
+    expect(names).toContain('memory_list');
+    expect(names).toContain('session_capture');
+    // Export
+    expect(names).toContain('export');
+    // Planning
+    expect(names).toContain('create_plan');
+    expect(names).toContain('get_plan');
+    expect(names).toContain('approve_plan');
+    expect(names).toContain('update_task');
+    expect(names).toContain('complete_plan');
+    // Brain
+    expect(names).toContain('record_feedback');
+    expect(names).toContain('rebuild_vocabulary');
+    expect(names).toContain('brain_stats');
+    expect(names).toContain('llm_status');
+    // Curator
+    expect(names).toContain('curator_status');
+    expect(names).toContain('curator_detect_duplicates');
+    expect(names).toContain('curator_contradictions');
+    expect(names).toContain('curator_resolve_contradiction');
+    expect(names).toContain('curator_groom');
+    expect(names).toContain('curator_groom_all');
+    expect(names).toContain('curator_consolidate');
+    expect(names).toContain('curator_health_audit');
+  });
+
+  it('search should query vault via brain', async () => {
+    runtime.vault.seed([{
+      id: 'co-1',
+      type: 'pattern',
+      domain: 'testing',
+      title: 'Test pattern for core ops',
+      severity: 'warning',
+      description: 'Core ops test.',
+      tags: ['test'],
+    }]);
+    runtime.brain.rebuildVocabulary();
+
+    // Re-create ops since brain state changed
+    ops = createCoreOps(runtime);
+    const results = await findOp('search').handler({ query: 'core ops test' }) as unknown[];
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('vault_stats should return counts', async () => {
+    runtime.vault.seed([{
+      id: 'vs-1',
+      type: 'pattern',
+      domain: 'd1',
+      title: 'T',
+      severity: 'warning',
+      description: 'D',
+      tags: ['t'],
+    }]);
+    const stats = await findOp('vault_stats').handler({}) as { totalEntries: number };
+    expect(stats.totalEntries).toBe(1);
+  });
+
+  it('create_plan + get_plan should work', async () => {
+    const created = await findOp('create_plan').handler({
+      objective: 'Test plan',
+      scope: 'core-ops test',
+      tasks: [{ title: 'Task 1', description: 'Do something' }],
+    }) as { created: boolean; plan: { id: string; status: string } };
+    expect(created.created).toBe(true);
+    expect(created.plan.status).toBe('draft');
+
+    const plan = await findOp('get_plan').handler({ planId: created.plan.id }) as { id: string };
+    expect(plan.id).toBe(created.plan.id);
+  });
+
+  it('brain_stats should return stats', async () => {
+    const stats = await findOp('brain_stats').handler({}) as { vocabularySize: number; feedbackCount: number };
+    expect(stats.vocabularySize).toBe(0);
+    expect(stats.feedbackCount).toBe(0);
+  });
+
+  it('llm_status should return provider info', async () => {
+    const status = await findOp('llm_status').handler({}) as {
+      providers: {
+        openai: { available: boolean };
+        anthropic: { available: boolean };
+      };
+      routes: unknown[];
+    };
+    expect(typeof status.providers.openai.available).toBe('boolean');
+    expect(typeof status.providers.anthropic.available).toBe('boolean');
+    expect(Array.isArray(status.routes)).toBe(true);
+  });
+
+  it('curator_status should return initialized', async () => {
+    const status = await findOp('curator_status').handler({}) as { initialized: boolean };
+    expect(status.initialized).toBe(true);
+  });
+
+  it('curator_health_audit should return score', async () => {
+    runtime.vault.seed([{
+      id: 'ha-1',
+      type: 'pattern',
+      domain: 'testing',
+      title: 'Health pattern',
+      severity: 'warning',
+      description: 'Testing health.',
+      tags: ['health'],
+    }]);
+    runtime.curator.groomAll();
+    const result = await findOp('curator_health_audit').handler({}) as { score: number };
+    expect(result.score).toBeGreaterThan(0);
+  });
+
+  it('memory_capture + memory_search should work', async () => {
+    await findOp('memory_capture').handler({
+      projectPath: '/test',
+      type: 'lesson',
+      context: 'Testing core ops',
+      summary: 'Core ops memory test works',
+      topics: ['testing'],
+      filesModified: [],
+      toolsUsed: [],
+    });
+
+    const results = await findOp('memory_search').handler({ query: 'core ops memory' }) as unknown[];
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('export should return bundles', async () => {
+    runtime.vault.seed([{
+      id: 'exp-1',
+      type: 'pattern',
+      domain: 'security',
+      title: 'Export test',
+      severity: 'warning',
+      description: 'Testing export.',
+      tags: ['export'],
+    }]);
+    const result = await findOp('export').handler({}) as { exported: boolean; totalEntries: number };
+    expect(result.exported).toBe(true);
+    expect(result.totalEntries).toBe(1);
+  });
+});