@soleri/core 2.0.0 → 2.0.2

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,93 @@
+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', () => {
+    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 = 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,13 +1,18 @@
 import type { Vault } from '../vault/vault.js';
 import type { SearchResult } from '../vault/vault.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
-import type { CogneeClient } from '../cognee/client.js';
+import {
+  tokenize,
+  calculateTf,
+  calculateTfIdf,
+  cosineSimilarity,
+  jaccardSimilarity,
+} from '../text/similarity.js';
 
 // ─── Types ───────────────────────────────────────────────────────────
 
 export interface ScoringWeights {
   semantic: number;
-  vector: number;
   severity: number;
   recency: number;
   tagOverlap: number;
@@ -16,7 +21,6 @@ export interface ScoringWeights {
 
 export interface ScoreBreakdown {
   semantic: number;
-  vector: number;
   severity: number;
   recency: number;
   tagOverlap: number;
@@ -58,172 +62,6 @@ export interface QueryContext {
   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;
-}
-
 // ─── Severity scoring ──────────────────────────────────────────────
 
 const SEVERITY_SCORES: Record<string, number> = {
@@ -236,22 +74,12 @@ const SEVERITY_SCORES: Record<string, number> = {
 
 const DEFAULT_WEIGHTS: ScoringWeights = {
   semantic: 0.4,
-  vector: 0.0,
   severity: 0.15,
   recency: 0.15,
   tagOverlap: 0.15,
   domainMatch: 0.15,
 };
 
-const COGNEE_WEIGHTS: ScoringWeights = {
-  semantic: 0.25,
-  vector: 0.35,
-  severity: 0.1,
-  recency: 0.1,
-  tagOverlap: 0.1,
-  domainMatch: 0.1,
-};
-
 const WEIGHT_BOUND = 0.15;
 const FEEDBACK_THRESHOLD = 30;
 const DUPLICATE_BLOCK_THRESHOLD = 0.8;
@@ -260,18 +88,16 @@ const RECENCY_HALF_LIFE_DAYS = 365;
 
 export class Brain {
   private vault: Vault;
-  private cognee: CogneeClient | undefined;
   private vocabulary: Map<string, number> = new Map();
   private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };
 
-  constructor(vault: Vault, cognee?: CogneeClient) {
+  constructor(vault: Vault) {
     this.vault = vault;
-    this.cognee = cognee;
     this.rebuildVocabulary();
     this.recomputeWeights();
   }
 
-  async intelligentSearch(query: string, options?: SearchOptions): Promise<RankedResult[]> {
+  intelligentSearch(query: string, options?: SearchOptions): RankedResult[] {
     const limit = options?.limit ?? 10;
     const rawResults = this.vault.search(query, {
       domain: options?.domain,
@@ -280,30 +106,6 @@ export class Brain {
       limit: Math.max(limit * 3, 30),
     });
 
-    // Cognee vector search (parallel, with timeout fallback)
-    let cogneeScoreMap: Map<string, number> = new Map();
-    const cogneeAvailable = this.cognee?.isAvailable ?? false;
-    if (cogneeAvailable && this.cognee) {
-      try {
-        const cogneeResults = await this.cognee.search(query, { limit: Math.max(limit * 2, 20) });
-        for (const cr of cogneeResults) {
-          if (cr.id) cogneeScoreMap.set(cr.id, cr.score);
-        }
-        // Merge cognee-only entries into candidate pool
-        for (const cr of cogneeResults) {
-          if (cr.id && !rawResults.some((r) => r.entry.id === cr.id)) {
-            const vaultEntry = this.vault.get(cr.id);
-            if (vaultEntry) {
-              rawResults.push({ entry: vaultEntry, score: cr.score });
-            }
-          }
-        }
-      } catch {
-        // Cognee failed — fall back to FTS5 only
-        cogneeScoreMap = new Map();
-      }
-    }
-
     if (rawResults.length === 0) return [];
 
     const queryTokens = tokenize(query);
@@ -311,22 +113,9 @@ export class Brain {
     const queryDomain = options?.domain;
     const now = Math.floor(Date.now() / 1000);
 
-    // Use cognee-aware weights only if at least one ranked candidate has a vector score
-    const hasVectorCandidate = rawResults.some((r) => cogneeScoreMap.has(r.entry.id));
-    const activeWeights = hasVectorCandidate ? this.getCogneeWeights() : this.weights;
-
     const ranked = rawResults.map((result) => {
       const entry = result.entry;
-      const vectorScore = cogneeScoreMap.get(entry.id) ?? 0;
-      const breakdown = this.scoreEntry(
-        entry,
-        queryTokens,
-        queryTags,
-        queryDomain,
-        now,
-        vectorScore,
-        activeWeights,
-      );
+      const breakdown = this.scoreEntry(entry, queryTokens, queryTags, queryDomain, now);
       return { entry, score: breakdown.total, breakdown };
     });
 
@@ -377,11 +166,6 @@ export class Brain {
     this.vault.add(fullEntry);
     this.updateVocabularyIncremental(fullEntry);
 
-    // Fire-and-forget Cognee sync
-    if (this.cognee?.isAvailable) {
-      this.cognee.addEntries([fullEntry]).catch(() => {});
-    }
-
     const result: CaptureResult = {
       captured: true,
       id: entry.id,
@@ -405,39 +189,13 @@ export class Brain {
     this.recomputeWeights();
   }
 
-  async getRelevantPatterns(context: QueryContext): Promise<RankedResult[]> {
+  getRelevantPatterns(context: QueryContext): RankedResult[] {
     return this.intelligentSearch(context.query, {
       domain: context.domain,
       tags: context.tags,
     });
   }
 
-  async syncToCognee(): Promise<{ synced: number; cognified: boolean }> {
-    if (!this.cognee?.isAvailable) return { synced: 0, cognified: false };
-
-    const batchSize = 1000;
-    let offset = 0;
-    let totalSynced = 0;
-
-    while (true) {
-      const batch = this.vault.list({ limit: batchSize, offset });
-      if (batch.length === 0) break;
-
-      const { added } = await this.cognee.addEntries(batch);
-      totalSynced += added;
-      offset += batch.length;
-
-      if (batch.length < batchSize) break;
-    }
-
-    if (totalSynced === 0) return { synced: 0, cognified: false };
-
-    let cognified = false;
-    const cognifyResult = await this.cognee.cognify();
-    cognified = cognifyResult.status === 'ok';
-    return { synced: totalSynced, cognified };
-  }
-
   rebuildVocabulary(): void {
     const entries = this.vault.list({ limit: 100000 });
     const docCount = entries.length;
@@ -491,11 +249,7 @@ export class Brain {
     queryTags: string[],
     queryDomain: string | undefined,
     now: number,
-    vectorScore: number = 0,
-    activeWeights?: ScoringWeights,
   ): ScoreBreakdown {
-    const w = activeWeights ?? this.weights;
-
     let semantic = 0;
     if (this.vocabulary.size > 0 && queryTokens.length > 0) {
       const entryText = [
@@ -520,17 +274,14 @@ export class Brain {
 
     const domainMatch = queryDomain && entry.domain === queryDomain ? 1.0 : 0;
 
-    const vector = vectorScore;
-
     const total =
-      w.semantic * semantic +
-      w.vector * vector +
-      w.severity * severity +
-      w.recency * recency +
-      w.tagOverlap * tagOverlap +
-      w.domainMatch * domainMatch;
-
-    return { semantic, vector, severity, recency, tagOverlap, domainMatch, total };
+      this.weights.semantic * semantic +
+      this.weights.severity * severity +
+      this.weights.recency * recency +
+      this.weights.tagOverlap * tagOverlap +
+      this.weights.domainMatch * domainMatch;
+
+    return { semantic, severity, recency, tagOverlap, domainMatch, total };
   }
 
   private generateTags(title: string, description: string, context?: string): string[] {
@@ -624,10 +375,6 @@ export class Brain {
     tx();
   }
 
-  private getCogneeWeights(): ScoringWeights {
-    return { ...COGNEE_WEIGHTS };
-  }
-
   private recomputeWeights(): void {
     const db = this.vault.getDb();
     const feedbackCount = (
@@ -654,10 +401,7 @@ export class Brain {
       DEFAULT_WEIGHTS.semantic + WEIGHT_BOUND,
     );
 
-    // vector stays 0 in base weights (only active during hybrid search)
-    newWeights.vector = 0;
-
-    const remaining = 1.0 - newWeights.semantic - newWeights.vector;
+    const remaining = 1.0 - newWeights.semantic;
     const otherSum =
       DEFAULT_WEIGHTS.severity +
       DEFAULT_WEIGHTS.recency +