@soleri/core 8.0.0 → 9.0.0

package/src/__tests__/cognee-sync-manager.test.ts

@@ -1,104 +0,0 @@
-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 { CogneeSyncManager } from '../cognee/sync-manager.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { IntelligenceEntry } from '../intelligence/types.js';
-
-const testEntry: IntelligenceEntry = {
-  id: 'test-1',
-  type: 'pattern' as const,
-  domain: 'test',
-  title: 'Test Pattern',
-  severity: 'suggestion' as const,
-  description: 'A test pattern',
-  tags: ['test'],
-};
-
-describe('CogneeSyncManager', () => {
-  let runtime: AgentRuntime;
-  let plannerDir: string;
-
-  beforeEach(() => {
-    plannerDir = join(tmpdir(), 'sync-mgr-test-' + Date.now());
-    mkdirSync(plannerDir, { recursive: true });
-    runtime = createAgentRuntime({
-      agentId: 'test-sync-mgr',
-      vaultPath: ':memory:',
-      plansPath: join(plannerDir, 'plans.json'),
-      cognee: true,
-    });
-  });
-
-  afterEach(() => {
-    runtime.close();
-    rmSync(plannerDir, { recursive: true, force: true });
-  });
-
-  it('should have syncManager on runtime', () => {
-    expect(runtime.syncManager).toBeDefined();
-    expect(runtime.syncManager).not.toBeNull();
-  });
-
-  it('should enqueue on vault seed', () => {
-    runtime.vault.seed([testEntry]);
-    const stats = runtime.syncManager.getStats();
-    expect(stats.pending).toBeGreaterThanOrEqual(1);
-  });
-
-  it('should enqueue delete on vault remove', () => {
-    runtime.vault.seed([testEntry]);
-    runtime.vault.remove(testEntry.id);
-    const stats = runtime.syncManager.getStats();
-    // At least 2 items: one ingest from seed + one delete from remove
-    expect(stats.pending).toBeGreaterThanOrEqual(2);
-  });
-
-  it('getStats should return valid structure', () => {
-    const stats = runtime.syncManager.getStats();
-    expect(stats).toHaveProperty('pending');
-    expect(stats).toHaveProperty('processing');
-    expect(stats).toHaveProperty('completed');
-    expect(stats).toHaveProperty('failed');
-    expect(stats).toHaveProperty('lastDrainAt');
-    expect(stats).toHaveProperty('queueSize');
-    expect(typeof stats.pending).toBe('number');
-    expect(typeof stats.processing).toBe('number');
-    expect(typeof stats.completed).toBe('number');
-    expect(typeof stats.failed).toBe('number');
-    expect(typeof stats.queueSize).toBe('number');
-  });
-
-  it('reconcile should enqueue unsynced entries', () => {
-    // Seed an entry (which auto-enqueues), then clear the queue manually
-    runtime.vault.seed([testEntry]);
-    runtime.vault.getProvider().run('DELETE FROM cognee_sync_queue');
-
-    // Verify queue is empty
-    const statsBefore = runtime.syncManager.getStats();
-    expect(statsBefore.pending).toBe(0);
-
-    // Reconcile should detect the unsynced entry and enqueue it
-    const enqueued = runtime.syncManager.reconcile();
-    expect(enqueued).toBeGreaterThanOrEqual(1);
-
-    const statsAfter = runtime.syncManager.getStats();
-    expect(statsAfter.pending).toBeGreaterThanOrEqual(1);
-  });
-
-  it('drain should return 0 when Cognee is unavailable', async () => {
-    runtime.vault.seed([testEntry]);
-    // In test env, Cognee is always unavailable (no server running)
-    const processed = await runtime.syncManager.drain();
-    expect(processed).toBe(0);
-  });
-
-  it('contentHash should be deterministic', () => {
-    const hash1 = CogneeSyncManager.contentHash(testEntry);
-    const hash2 = CogneeSyncManager.contentHash(testEntry);
-    expect(hash1).toBe(hash2);
-    expect(hash1).toHaveLength(16);
-  });
-});

package/src/__tests__/postgres-provider.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { translateSql, PostgresPersistenceProvider } from '../persistence/postgres-provider.js';
-
-describe('translateSql', () => {
-  it('converts positional ? to $N', () => {
-    const result = translateSql('SELECT * FROM t WHERE a = ? AND b = ?', ['x', 'y']);
-    expect(result.sql).toBe('SELECT * FROM t WHERE a = $1 AND b = $2');
-    expect(result.values).toEqual(['x', 'y']);
-  });
-
-  it('converts named @params to $N', () => {
-    const result = translateSql('INSERT INTO t (a, b) VALUES (@name, @age)', {
-      name: 'Alice',
-      age: 30,
-    });
-    expect(result.sql).toBe('INSERT INTO t (a, b) VALUES ($1, $2)');
-    expect(result.values).toEqual(['Alice', 30]);
-  });
-
-  it('deduplicates repeated named params', () => {
-    const result = translateSql('SELECT * FROM t WHERE a = @x OR b = @x', { x: 42 });
-    expect(result.sql).toBe('SELECT * FROM t WHERE a = $1 OR b = $1');
-    expect(result.values).toEqual([42]);
-  });
-
-  it('replaces unixepoch()', () => {
-    const result = translateSql('INSERT INTO t (ts) VALUES (unixepoch())');
-    expect(result.sql).toBe('INSERT INTO t (ts) VALUES (EXTRACT(EPOCH FROM NOW())::integer)');
-    expect(result.values).toEqual([]);
-  });
-
-  it('handles no params', () => {
-    const result = translateSql('SELECT 1');
-    expect(result.sql).toBe('SELECT 1');
-    expect(result.values).toEqual([]);
-  });
-
-  it('handles mixed: ? params + unixepoch()', () => {
-    const result = translateSql('UPDATE t SET name = ?, updated_at = unixepoch() WHERE id = ?', [
-      'Bob',
-      'id-1',
-    ]);
-    expect(result.sql).toBe(
-      'UPDATE t SET name = $1, updated_at = EXTRACT(EPOCH FROM NOW())::integer WHERE id = $2',
-    );
-    expect(result.values).toEqual(['Bob', 'id-1']);
-  });
-
-  it('replaces INTEGER PRIMARY KEY AUTOINCREMENT with SERIAL PRIMARY KEY', () => {
-    const result = translateSql('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)');
-    expect(result.sql).toBe('CREATE TABLE t (id SERIAL PRIMARY KEY, name TEXT)');
-  });
-
-  it('strips PRAGMA statements', () => {
-    const result = translateSql('PRAGMA journal_mode = WAL');
-    expect(result.sql).toBe('-- pragma removed');
-  });
-
-  it('replaces INSERT OR IGNORE with INSERT', () => {
-    const result = translateSql('INSERT OR IGNORE INTO t (a) VALUES (?)', ['x']);
-    expect(result.sql).toBe('INSERT INTO t (a) VALUES ($1)');
-    expect(result.values).toEqual(['x']);
-  });
-
-  it('replaces INSERT OR REPLACE with INSERT', () => {
-    const result = translateSql('INSERT OR REPLACE INTO t (a) VALUES (?)', ['x']);
-    expect(result.sql).toBe('INSERT INTO t (a) VALUES ($1)');
-    expect(result.values).toEqual(['x']);
-  });
-
-  it('handles complex vault-style query with multiple named params', () => {
-    const result = translateSql(
-      'SELECT e.* FROM entries e WHERE e.domain = @domain AND e.type = @type ORDER BY e.title LIMIT @limit OFFSET @offset',
-      { domain: 'design', type: 'pattern', limit: 10, offset: 0 },
-    );
-    expect(result.sql).toBe(
-      'SELECT e.* FROM entries e WHERE e.domain = $1 AND e.type = $2 ORDER BY e.title LIMIT $3 OFFSET $4',
-    );
-    expect(result.values).toEqual(['design', 'pattern', 10, 0]);
-  });
-
-  it('handles vault seed query with many named params', () => {
-    const result = translateSql(
-      'INSERT INTO entries (id, type, domain) VALUES (@id, @type, @domain) ON CONFLICT(id) DO UPDATE SET type=excluded.type',
-      { id: 'e1', type: 'pattern', domain: 'general' },
-    );
-    expect(result.sql).toContain('VALUES ($1, $2, $3)');
-    expect(result.values).toEqual(['e1', 'pattern', 'general']);
-  });
-});
-
-describe('PostgresPersistenceProvider', () => {
-  it('class exists with correct backend', () => {
-    expect(PostgresPersistenceProvider).toBeDefined();
-    expect(typeof PostgresPersistenceProvider.create).toBe('function');
-    expect(typeof PostgresPersistenceProvider.createSync).toBe('function');
-  });
-
-  it('createSync returns a provider instance', () => {
-    const provider = PostgresPersistenceProvider.createSync('postgresql://localhost/test');
-    expect(provider.backend).toBe('postgres');
-    expect(provider.getConnectionString()).toBe('postgresql://localhost/test');
-  });
-
-  it('ftsRebuild is a no-op (PostgreSQL GIN auto-maintains)', () => {
-    const provider = PostgresPersistenceProvider.createSync('postgresql://localhost/test');
-    // Should not throw
-    provider.ftsRebuild('entries');
-  });
-
-  it('close is safe to call multiple times', () => {
-    const provider = PostgresPersistenceProvider.createSync('postgresql://localhost/test');
-    provider.close();
-    provider.close(); // should not throw
-  });
-});

package/src/cognee/client.ts

@@ -1,370 +0,0 @@
-import type {
-  CogneeConfig,
-  CogneeSearchResult,
-  CogneeSearchType,
-  CogneeStatus,
-  CogneeAddResult,
-  CogneeCognifyResult,
-} from './types.js';
-import type { IntelligenceEntry } from '../intelligence/types.js';
-
-// ─── Defaults ──────────────────────────────────────────────────────
-// Aligned with Salvador MCP's battle-tested Cognee integration.
-
-const DEFAULT_SERVICE_EMAIL = 'soleri-agent@cognee.dev';
-const DEFAULT_SERVICE_PASSWORD = 'soleri-cognee-local';
-
-/** Only allow default service credentials for local endpoints. */
-function isLocalUrl(url: string): boolean {
-  try {
-    const { hostname } = new URL(url);
-    return (
-      hostname === 'localhost' ||
-      hostname === '127.0.0.1' ||
-      hostname === '::1' ||
-      hostname === '0.0.0.0'
-    );
-  } catch {
-    return false;
-  }
-}
-
-const DEFAULT_CONFIG: CogneeConfig = {
-  baseUrl: 'http://localhost:8000',
-  dataset: 'vault',
-  timeoutMs: 30_000,
-  searchTimeoutMs: 120_000, // Ollama cold start can take 90s
-  healthTimeoutMs: 5_000,
-  healthCacheTtlMs: 60_000,
-  cognifyDebounceMs: 30_000,
-};
-
-// ─── CogneeClient ──────────────────────────────────────────────────
-
-export class CogneeClient {
-  private config: CogneeConfig;
-  private healthCache: { status: CogneeStatus; cachedAt: number } | null = null;
-  private accessToken: string | null = null;
-  private cognifyTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
-  private pendingDatasets: Set<string> = new Set();
-
-  constructor(config?: Partial<CogneeConfig>) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    // Strip trailing slash
-    this.config.baseUrl = this.config.baseUrl.replace(/\/+$/, '');
-    // Pre-set token if provided
-    if (this.config.apiToken) {
-      this.accessToken = this.config.apiToken;
-    }
-  }
-
-  // ─── Health ────────────────────────────────────────────────────
-
-  get isAvailable(): boolean {
-    if (!this.healthCache) return false;
-    const age = Date.now() - this.healthCache.cachedAt;
-    if (age > this.config.healthCacheTtlMs) return false;
-    return this.healthCache.status.available;
-  }
-
-  async healthCheck(): Promise<CogneeStatus> {
-    const start = Date.now();
-    try {
-      // Cognee health endpoint is GET / (returns {"message":"Hello, World, I am alive!"})
-      const res = await globalThis.fetch(`${this.config.baseUrl}/`, {
-        signal: AbortSignal.timeout(this.config.healthTimeoutMs),
-      });
-      const latencyMs = Date.now() - start;
-      if (res.ok) {
-        const status: CogneeStatus = { available: true, url: this.config.baseUrl, latencyMs };
-        this.healthCache = { status, cachedAt: Date.now() };
-        return status;
-      }
-      const status: CogneeStatus = {
-        available: false,
-        url: this.config.baseUrl,
-        latencyMs,
-        error: `HTTP ${res.status}`,
-      };
-      this.healthCache = { status, cachedAt: Date.now() };
-      return status;
-    } catch (err) {
-      const latencyMs = Date.now() - start;
-      const status: CogneeStatus = {
-        available: false,
-        url: this.config.baseUrl,
-        latencyMs,
-        error: err instanceof Error ? err.message : String(err),
-      };
-      this.healthCache = { status, cachedAt: Date.now() };
-      return status;
-    }
-  }
-
-  // ─── Ingest ────────────────────────────────────────────────────
-
-  async addEntries(entries: IntelligenceEntry[]): Promise<CogneeAddResult> {
-    if (!this.isAvailable || entries.length === 0) return { added: 0 };
-
-    try {
-      const token = await this.ensureAuth().catch(() => null);
-
-      // Cognee /add expects multipart/form-data with files + datasetName
-      const formData = new FormData();
-      formData.append('datasetName', this.config.dataset);
-
-      for (const entry of entries) {
-        const text = this.serializeEntry(entry);
-        const blob = new Blob([text], { type: 'text/plain' });
-        formData.append('data', blob, `${entry.id}.txt`);
-      }
-
-      const headers: Record<string, string> = {};
-      if (token) headers.Authorization = `Bearer ${token}`;
-
-      const res = await globalThis.fetch(`${this.config.baseUrl}/api/v1/add`, {
-        method: 'POST',
-        headers,
-        body: formData,
-        signal: AbortSignal.timeout(this.config.timeoutMs),
-      });
-
-      if (!res.ok) return { added: 0 };
-
-      // Schedule debounced cognify (multiple rapid ingests coalesce)
-      this.scheduleCognify(this.config.dataset);
-
-      return { added: entries.length };
-    } catch {
-      return { added: 0 };
-    }
-  }
-
-  async cognify(dataset?: string): Promise<CogneeCognifyResult> {
-    if (!this.isAvailable) return { status: 'unavailable' };
-
-    try {
-      const res = await this.post('/api/v1/cognify', {
-        datasets: [dataset ?? this.config.dataset],
-      });
-
-      if (!res.ok) return { status: `error: HTTP ${res.status}` };
-      return { status: 'ok' };
-    } catch (err) {
-      return { status: `error: ${err instanceof Error ? err.message : String(err)}` };
-    }
-  }
-
-  // ─── Cognify debounce ───────────────────────────────────────────
-
-  /**
-   * Schedule a debounced cognify for a dataset.
-   * Sliding window: each call resets the timer. When it expires,
-   * cognify fires once. Prevents pipeline dedup on rapid ingests.
-   */
-  private scheduleCognify(dataset: string): void {
-    const existing = this.cognifyTimers.get(dataset);
-    if (existing) clearTimeout(existing);
-
-    this.pendingDatasets.add(dataset);
-
-    const timer = setTimeout(() => {
-      this.cognifyTimers.delete(dataset);
-      this.pendingDatasets.delete(dataset);
-      this.post('/api/v1/cognify', { datasets: [dataset] }).catch(() => {});
-    }, this.config.cognifyDebounceMs);
-
-    // Unref so the timer doesn't keep the process alive during shutdown
-    if (typeof timer === 'object' && 'unref' in timer) (timer as NodeJS.Timeout).unref();
-
-    this.cognifyTimers.set(dataset, timer);
-  }
-
-  /** Flush all pending debounced cognify calls immediately. */
-  async flushPendingCognify(): Promise<void> {
-    const datasets = [...this.pendingDatasets];
-    for (const timer of this.cognifyTimers.values()) clearTimeout(timer);
-    this.cognifyTimers.clear();
-    this.pendingDatasets.clear();
-
-    if (datasets.length === 0) return;
-
-    await Promise.allSettled(
-      datasets.map((ds) => this.post('/api/v1/cognify', { datasets: [ds] }).catch(() => {})),
-    );
-  }
-
-  /** Cancel all pending cognify calls without firing them. For test teardown. */
-  resetPendingCognify(): void {
-    for (const timer of this.cognifyTimers.values()) clearTimeout(timer);
-    this.cognifyTimers.clear();
-    this.pendingDatasets.clear();
-  }
-
-  // ─── Search ────────────────────────────────────────────────────
-
-  async search(
-    query: string,
-    opts?: { searchType?: CogneeSearchType; limit?: number },
-  ): Promise<CogneeSearchResult[]> {
-    if (!this.isAvailable) return [];
-
-    // Default to CHUNKS (pure vector similarity) — GRAPH_COMPLETION requires
-    // the LLM to produce instructor-compatible JSON which small local models
-    // (llama3.2) can't do reliably, causing infinite retries and timeouts.
-    const searchType = opts?.searchType ?? 'CHUNKS';
-    const topK = opts?.limit ?? 10;
-
-    try {
-      const res = await this.post(
-        '/api/v1/search',
-        { query, search_type: searchType, datasets: [this.config.dataset], topK },
-        this.config.searchTimeoutMs,
-      );
-
-      if (!res.ok) return [];
-
-      const data = (await res.json()) as Array<{
-        id?: string;
-        text?: string;
-        score?: number;
-        payload?: { id?: string };
-      }>;
-
-      // Position-based scoring when Cognee omits scores.
-      // Cognee returns results ordered by relevance but may not include numeric scores.
-      return data.slice(0, topK).map((item, idx) => ({
-        id: item.payload?.id ?? item.id ?? '',
-        score: item.score ?? positionScore(idx, data.length),
-        text: typeof item.text === 'string' ? item.text : String(item.text ?? ''),
-        searchType,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  // ─── Config access ─────────────────────────────────────────────
-
-  getConfig(): Readonly<CogneeConfig> {
-    return { ...this.config };
-  }
-
-  getStatus(): CogneeStatus | null {
-    return this.healthCache?.status ?? null;
-  }
-
-  // ─── Delete ──────────────────────────────────────────────────────
-
-  async deleteEntries(entryIds: string[]): Promise<{ deleted: number }> {
-    if (!this.isAvailable || entryIds.length === 0) return { deleted: 0 };
-
-    try {
-      const res = await this.post('/api/v1/delete', {
-        datasetName: this.config.dataset,
-        entryIds,
-      });
-
-      if (!res.ok) return { deleted: 0 };
-      return { deleted: entryIds.length };
-    } catch {
-      return { deleted: 0 };
-    }
-  }
-
-  // ─── Auth ──────────────────────────────────────────────────────
-  // Auto-register + login pattern from Salvador MCP.
-  // Tries login first (account may already exist), falls back to register.
-
-  private async ensureAuth(): Promise<string> {
-    if (this.accessToken) return this.accessToken;
-
-    const email = this.config.serviceEmail ?? DEFAULT_SERVICE_EMAIL;
-    const password = this.config.servicePassword ?? DEFAULT_SERVICE_PASSWORD;
-
-    // Refuse default credentials for non-local endpoints
-    if (
-      !isLocalUrl(this.config.baseUrl) &&
-      email === DEFAULT_SERVICE_EMAIL &&
-      password === DEFAULT_SERVICE_PASSWORD
-    ) {
-      throw new Error('Explicit Cognee credentials are required for non-local endpoints');
-    }
-
-    // Try login first
-    const loginResp = await globalThis.fetch(`${this.config.baseUrl}/api/v1/auth/login`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: `username=${encodeURIComponent(email)}&password=${encodeURIComponent(password)}`,
-      signal: AbortSignal.timeout(this.config.healthTimeoutMs),
-    });
-
-    if (loginResp.ok) {
-      const data = (await loginResp.json()) as { access_token: string };
-      this.accessToken = data.access_token;
-      return this.accessToken;
-    }
-
-    // Register, then retry login
-    await globalThis.fetch(`${this.config.baseUrl}/api/v1/auth/register`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ email, password }),
-      signal: AbortSignal.timeout(this.config.healthTimeoutMs),
-    });
-
-    const retryLogin = await globalThis.fetch(`${this.config.baseUrl}/api/v1/auth/login`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: `username=${encodeURIComponent(email)}&password=${encodeURIComponent(password)}`,
-      signal: AbortSignal.timeout(this.config.healthTimeoutMs),
-    });
-
-    if (!retryLogin.ok) {
-      throw new Error(`Cognee auth failed: HTTP ${retryLogin.status}`);
-    }
-
-    const retryData = (await retryLogin.json()) as { access_token: string };
-    this.accessToken = retryData.access_token;
-    return this.accessToken;
-  }
-
-  private async authHeaders(): Promise<Record<string, string>> {
-    try {
-      const token = await this.ensureAuth();
-      return { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` };
-    } catch {
-      // Fall back to no auth (works if AUTH_REQUIRED=false)
-      return { 'Content-Type': 'application/json' };
-    }
-  }
-
-  // ─── Private helpers ───────────────────────────────────────────
-
-  private serializeEntry(entry: IntelligenceEntry): string {
-    // Prefix with vault ID so we can cross-reference search results back to vault entries.
-    // Cognee assigns its own UUIDs to chunks — the vault ID would otherwise be lost.
-    const parts = [`[vault-id:${entry.id}]`, entry.title, entry.description];
-    if (entry.context) parts.push(entry.context);
-    if (entry.tags.length > 0) parts.push(`Tags: ${entry.tags.join(', ')}`);
-    return parts.join('\n');
-  }
-
-  private async post(path: string, body: unknown, timeoutMs?: number): Promise<Response> {
-    const headers = await this.authHeaders();
-    return globalThis.fetch(`${this.config.baseUrl}${path}`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(timeoutMs ?? this.config.timeoutMs),
-    });
-  }
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────
-
-/** Position-based score: first result gets ~1.0, last gets ~0.05. */
-function positionScore(index: number, total: number): number {
-  if (total <= 1) return 1.0;
-  return Math.max(0.05, 1.0 - (index / (total - 1)) * 0.95);
-}