@soleri/core 2.0.1 → 2.1.0

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

@@ -0,0 +1,160 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createDomainFacade, createDomainFacades } from '../runtime/domain-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+describe('createDomainFacade', () => {
+  let runtime: AgentRuntime;
+
+  beforeEach(() => {
+    runtime = createAgentRuntime({
+      agentId: 'test-domain',
+      vaultPath: ':memory:',
+    });
+  });
+
+  afterEach(() => {
+    runtime.close();
+  });
+
+  it('should create facade with correct name', () => {
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    expect(facade.name).toBe('test-domain_security');
+  });
+
+  it('should create facade with 5 ops', () => {
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    expect(facade.ops.length).toBe(5);
+    const names = facade.ops.map((o) => o.name);
+    expect(names).toContain('get_patterns');
+    expect(names).toContain('search');
+    expect(names).toContain('get_entry');
+    expect(names).toContain('capture');
+    expect(names).toContain('remove');
+  });
+
+  it('should handle kebab-case domain names', () => {
+    const facade = createDomainFacade(runtime, 'test-domain', 'api-design');
+    expect(facade.name).toBe('test-domain_api_design');
+  });
+
+  it('get_patterns should scope to domain', async () => {
+    runtime.vault.seed([
+      {
+        id: 'sec-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Auth',
+        severity: 'warning',
+        description: 'Auth.',
+        tags: ['auth'],
+      },
+      {
+        id: 'api-1',
+        type: 'pattern',
+        domain: 'api-design',
+        title: 'REST',
+        severity: 'warning',
+        description: 'REST.',
+        tags: ['rest'],
+      },
+    ]);
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    const op = facade.ops.find((o) => o.name === 'get_patterns')!;
+    const results = (await op.handler({})) as IntelligenceEntry[];
+    expect(results.every((e) => e.domain === 'security')).toBe(true);
+  });
+
+  it('capture should add entry with correct domain', async () => {
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    const captureOp = facade.ops.find((o) => o.name === 'capture')!;
+    await captureOp.handler({
+      id: 'cap-1',
+      type: 'pattern',
+      title: 'Captured Pattern',
+      severity: 'warning',
+      description: 'Test capture.',
+      tags: ['test'],
+    });
+    const entry = runtime.vault.get('cap-1');
+    expect(entry).not.toBeNull();
+    expect(entry!.domain).toBe('security');
+  });
+
+  it('remove should delete entry', async () => {
+    runtime.vault.seed([
+      {
+        id: 'rm-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Remove me',
+        severity: 'warning',
+        description: 'Remove.',
+        tags: ['test'],
+      },
+    ]);
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    const removeOp = facade.ops.find((o) => o.name === 'remove')!;
+    const result = (await removeOp.handler({ id: 'rm-1' })) as { removed: boolean };
+    expect(result.removed).toBe(true);
+    expect(runtime.vault.get('rm-1')).toBeNull();
+  });
+
+  it('get_entry should return specific entry', async () => {
+    runtime.vault.seed([
+      {
+        id: 'ge-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Get me',
+        severity: 'warning',
+        description: 'Get.',
+        tags: ['test'],
+      },
+    ]);
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    const getOp = facade.ops.find((o) => o.name === 'get_entry')!;
+    const result = (await getOp.handler({ id: 'ge-1' })) as IntelligenceEntry;
+    expect(result.id).toBe('ge-1');
+  });
+
+  it('get_entry should return error for missing entry', async () => {
+    const facade = createDomainFacade(runtime, 'test-domain', 'security');
+    const getOp = facade.ops.find((o) => o.name === 'get_entry')!;
+    const result = (await getOp.handler({ id: 'nope' })) as { error: string };
+    expect(result.error).toBeDefined();
+  });
+});
+
+describe('createDomainFacades', () => {
+  let runtime: AgentRuntime;
+
+  beforeEach(() => {
+    runtime = createAgentRuntime({
+      agentId: 'test-multi',
+      vaultPath: ':memory:',
+    });
+  });
+
+  afterEach(() => {
+    runtime.close();
+  });
+
+  it('should create one facade per domain', () => {
+    const facades = createDomainFacades(runtime, 'test-multi', [
+      'security',
+      'api-design',
+      'testing',
+    ]);
+    expect(facades.length).toBe(3);
+    expect(facades[0].name).toBe('test-multi_security');
+    expect(facades[1].name).toBe('test-multi_api_design');
+    expect(facades[2].name).toBe('test-multi_testing');
+  });
+
+  it('should return empty array for no domains', () => {
+    const facades = createDomainFacades(runtime, 'test-multi', []);
+    expect(facades.length).toBe(0);
+  });
+});

package/src/__tests__/llm-client.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { LLMClient } from '../llm/llm-client.js';
+import { KeyPool } from '../llm/key-pool.js';
+
+describe('LLMClient', () => {
+  it('should create with empty key pools', () => {
+    const openai = new KeyPool({ keys: [] });
+    const anthropic = new KeyPool({ keys: [] });
+    const client = new LLMClient(openai, anthropic);
+
+    expect(client.isAvailable()).toEqual({ openai: false, anthropic: false });
+  });
+
+  it('should report availability when keys present', () => {
+    const openai = new KeyPool({ keys: ['sk-test'] });
+    const anthropic = new KeyPool({ keys: ['sk-ant-test'] });
+    const client = new LLMClient(openai, anthropic);
+
+    expect(client.isAvailable()).toEqual({ openai: true, anthropic: true });
+  });
+
+  it('should accept agentId parameter', () => {
+    const openai = new KeyPool({ keys: [] });
+    const anthropic = new KeyPool({ keys: [] });
+    // Should not throw — agentId is used for model routing config
+    const client = new LLMClient(openai, anthropic, 'test-agent');
+    expect(client.isAvailable()).toEqual({ openai: false, anthropic: false });
+  });
+
+  it('should return empty routes by default', () => {
+    const openai = new KeyPool({ keys: [] });
+    const anthropic = new KeyPool({ keys: [] });
+    const client = new LLMClient(openai, anthropic);
+
+    expect(client.getRoutes()).toEqual([]);
+  });
+
+  it('should throw on callOpenAI without keys', async () => {
+    const openai = new KeyPool({ keys: [] });
+    const anthropic = new KeyPool({ keys: [] });
+    const client = new LLMClient(openai, anthropic);
+
+    await expect(
+      client.complete({
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        systemPrompt: 'test',
+        userPrompt: 'test',
+        caller: 'test',
+      }),
+    ).rejects.toThrow('OpenAI API key not configured');
+  });
+
+  it('should throw on callAnthropic without keys', async () => {
+    const openai = new KeyPool({ keys: [] });
+    const anthropic = new KeyPool({ keys: [] });
+    const client = new LLMClient(openai, anthropic);
+
+    await expect(
+      client.complete({
+        provider: 'anthropic',
+        model: 'claude-sonnet-4-20250514',
+        systemPrompt: 'test',
+        userPrompt: 'test',
+        caller: 'test',
+      }),
+    ).rejects.toThrow('Anthropic API key not configured');
+  });
+});

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import type { AgentRuntime } from '../runtime/types.js';
+
+describe('createAgentRuntime', () => {
+  let runtime: AgentRuntime | null = null;
+
+  afterEach(() => {
+    runtime?.close();
+    runtime = null;
+  });
+
+  it('should create a runtime with all modules initialized', () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-agent',
+      vaultPath: ':memory:',
+    });
+
+    expect(runtime.config.agentId).toBe('test-agent');
+    expect(runtime.vault).toBeDefined();
+    expect(runtime.brain).toBeDefined();
+    expect(runtime.planner).toBeDefined();
+    expect(runtime.curator).toBeDefined();
+    expect(runtime.keyPool.openai).toBeDefined();
+    expect(runtime.keyPool.anthropic).toBeDefined();
+    expect(runtime.llmClient).toBeDefined();
+  });
+
+  it('should use :memory: vault when specified', () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-mem',
+      vaultPath: ':memory:',
+    });
+
+    const stats = runtime.vault.stats();
+    expect(stats.totalEntries).toBe(0);
+  });
+
+  it('should preserve config on runtime', () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-cfg',
+      vaultPath: ':memory:',
+      dataDir: '/nonexistent',
+    });
+
+    expect(runtime.config.agentId).toBe('test-cfg');
+    expect(runtime.config.vaultPath).toBe(':memory:');
+    expect(runtime.config.dataDir).toBe('/nonexistent');
+  });
+
+  it('close() should not throw', () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-close',
+      vaultPath: ':memory:',
+    });
+
+    expect(() => runtime!.close()).not.toThrow();
+    runtime = null; // already closed
+  });
+
+  it('brain should be wired to vault', async () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-brain-wire',
+      vaultPath: ':memory:',
+    });
+
+    // Seed some data through vault
+    runtime.vault.seed([
+      {
+        id: 'rt-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Runtime test pattern',
+        severity: 'warning',
+        description: 'A test.',
+        tags: ['test'],
+      },
+    ]);
+
+    // Brain should find it
+    runtime.brain.rebuildVocabulary();
+    const results = await runtime.brain.intelligentSearch('runtime test', { limit: 5 });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('curator should be wired to vault', () => {
+    runtime = createAgentRuntime({
+      agentId: 'test-curator-wire',
+      vaultPath: ':memory:',
+    });
+
+    const status = runtime.curator.getStatus();
+    expect(status.initialized).toBe(true);
+  });
+});

package/src/brain/brain.ts

@@ -1,228 +1,34 @@
 import type { Vault } from '../vault/vault.js';
 import type { SearchResult } from '../vault/vault.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
+import {
+  tokenize,
+  calculateTf,
+  calculateTfIdf,
+  cosineSimilarity,
+  jaccardSimilarity,
+} from '../text/similarity.js';
 import type { CogneeClient } from '../cognee/client.js';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export interface ScoringWeights {
-  semantic: number;
-  vector: number;
-  severity: number;
-  recency: number;
-  tagOverlap: number;
-  domainMatch: number;
-}
-
-export interface ScoreBreakdown {
-  semantic: number;
-  vector: number;
-  severity: number;
-  recency: number;
-  tagOverlap: number;
-  domainMatch: number;
-  total: number;
-}
-
-export interface RankedResult {
-  entry: IntelligenceEntry;
-  score: number;
-  breakdown: ScoreBreakdown;
-}
-
-export interface SearchOptions {
-  domain?: string;
-  type?: string;
-  severity?: string;
-  limit?: number;
-  tags?: string[];
-}
-
-export interface CaptureResult {
-  captured: boolean;
-  id: string;
-  autoTags: string[];
-  duplicate?: { id: string; similarity: number };
-  blocked?: boolean;
-}
-
-export interface BrainStats {
-  vocabularySize: number;
-  feedbackCount: number;
-  weights: ScoringWeights;
-}
-
-export interface QueryContext {
-  query: string;
-  domain?: string;
-  tags?: string[];
-}
-
-type SparseVector = Map<string, number>;
-
-// ─── Stopwords ─────────────────────────────────────────────────────
-
-const STOPWORDS = new Set([
-  'a',
-  'an',
-  'the',
-  'and',
-  'or',
-  'but',
-  'in',
-  'on',
-  'at',
-  'to',
-  'for',
-  'of',
-  'with',
-  'by',
-  'from',
-  'as',
-  'is',
-  'was',
-  'are',
-  'were',
-  'been',
-  'be',
-  'have',
-  'has',
-  'had',
-  'do',
-  'does',
-  'did',
-  'will',
-  'would',
-  'could',
-  'should',
-  'may',
-  'might',
-  'shall',
-  'can',
-  'need',
-  'must',
-  'it',
-  'its',
-  'this',
-  'that',
-  'these',
-  'those',
-  'i',
-  'you',
-  'he',
-  'she',
-  'we',
-  'they',
-  'me',
-  'him',
-  'her',
-  'us',
-  'them',
-  'my',
-  'your',
-  'his',
-  'our',
-  'their',
-  'what',
-  'which',
-  'who',
-  'whom',
-  'when',
-  'where',
-  'why',
-  'how',
-  'all',
-  'each',
-  'every',
-  'both',
-  'few',
-  'more',
-  'most',
-  'other',
-  'some',
-  'such',
-  'no',
-  'not',
-  'only',
-  'same',
-  'so',
-  'than',
-  'too',
-  'very',
-  'just',
-  'because',
-  'if',
-  'then',
-  'else',
-  'about',
-  'up',
-  'out',
-  'into',
-]);
-
-// ─── Text Processing (pure functions) ────────────────────────────
-
-function tokenize(text: string): string[] {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9\s-]/g, ' ')
-    .split(/\s+/)
-    .filter((t) => t.length > 2 && !STOPWORDS.has(t));
-}
-
-function calculateTf(tokens: string[]): SparseVector {
-  const tf: SparseVector = new Map();
-  for (const token of tokens) {
-    tf.set(token, (tf.get(token) ?? 0) + 1);
-  }
-  const len = tokens.length || 1;
-  for (const [term, count] of tf) {
-    tf.set(term, count / len);
-  }
-  return tf;
-}
-
-function calculateTfIdf(tokens: string[], vocabulary: Map<string, number>): SparseVector {
-  const tf = calculateTf(tokens);
-  const tfidf: SparseVector = new Map();
-  for (const [term, tfValue] of tf) {
-    const idf = vocabulary.get(term) ?? 0;
-    if (idf > 0) {
-      tfidf.set(term, tfValue * idf);
-    }
-  }
-  return tfidf;
-}
-
-function cosineSimilarity(a: SparseVector, b: SparseVector): number {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (const [term, valA] of a) {
-    normA += valA * valA;
-    const valB = b.get(term);
-    if (valB !== undefined) {
-      dot += valA * valB;
-    }
-  }
-  for (const [, valB] of b) {
-    normB += valB * valB;
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-function jaccardSimilarity(a: string[], b: string[]): number {
-  if (a.length === 0 && b.length === 0) return 0;
-  const setA = new Set(a);
-  const setB = new Set(b);
-  let intersection = 0;
-  for (const item of setA) {
-    if (setB.has(item)) intersection++;
-  }
-  const union = new Set([...a, ...b]).size;
-  return union === 0 ? 0 : intersection / union;
-}
+import type {
+  ScoringWeights,
+  ScoreBreakdown,
+  RankedResult,
+  SearchOptions,
+  CaptureResult,
+  BrainStats,
+  QueryContext,
+} from './types.js';
+
+// Re-export types for backward compatibility
+export type {
+  ScoringWeights,
+  ScoreBreakdown,
+  RankedResult,
+  SearchOptions,
+  CaptureResult,
+  BrainStats,
+  QueryContext,
+} from './types.js';
 
 // ─── Severity scoring ──────────────────────────────────────────────