@soleri/core 2.10.0 → 2.11.0

package/src/__tests__/vault-branching.test.ts

@@ -0,0 +1,274 @@
+/**
+ * Vault Branching Tests — branch, merge, list, delete operations.
+ */
+
+import { describe, test, expect, afterEach } from 'vitest';
+import { Vault } from '../vault/vault.js';
+import { VaultBranching } from '../vault/vault-branching.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+function makeEntry(id: string, title: string, domain = 'general'): IntelligenceEntry {
+  return {
+    id,
+    type: 'pattern',
+    domain,
+    title,
+    severity: 'suggestion',
+    description: `Description for ${title}`,
+    tags: [domain],
+  };
+}
+
+describe('VaultBranching', () => {
+  let vault: Vault;
+  let branching: VaultBranching;
+
+  afterEach(() => {
+    vault?.close();
+  });
+
+  function setup() {
+    vault = new Vault(':memory:');
+    branching = new VaultBranching(vault);
+    return { vault, branching };
+  }
+
+  // ─── branch() ──────────────────────────────────────────────
+
+  test('creates a branch', () => {
+    setup();
+    expect(branching.branch('experiment')).toBe(true);
+    const branches = branching.listBranches();
+    expect(branches).toHaveLength(1);
+    expect(branches[0].name).toBe('experiment');
+    expect(branches[0].merged).toBe(false);
+  });
+
+  test('throws on duplicate active branch name', () => {
+    setup();
+    branching.branch('dup');
+    expect(() => branching.branch('dup')).toThrow("Branch 'dup' already exists");
+  });
+
+  test('allows reusing a merged branch name', () => {
+    setup();
+    branching.branch('reuse');
+    branching.merge('reuse');
+    // Should not throw — old merged branch gets cleaned up
+    expect(branching.branch('reuse')).toBe(true);
+  });
+
+  // ─── addOperation() ───────────────────────────────────────
+
+  test('adds operations to a branch', () => {
+    setup();
+    branching.branch('ops-test');
+    const entry = makeEntry('e1', 'Test Entry');
+    branching.addOperation('ops-test', 'e1', 'add', entry);
+    branching.addOperation('ops-test', 'e2', 'remove');
+
+    const entries = branching.listEntries('ops-test');
+    expect(entries).toHaveLength(2);
+    expect(entries[0].action).toBe('add');
+    expect(entries[0].entryData?.id).toBe('e1');
+    expect(entries[1].action).toBe('remove');
+    expect(entries[1].entryData).toBeNull();
+  });
+
+  test('throws when adding to non-existent branch', () => {
+    setup();
+    expect(() => branching.addOperation('ghost', 'e1', 'add', makeEntry('e1', 'x'))).toThrow(
+      "Branch 'ghost' does not exist",
+    );
+  });
+
+  test('throws when adding to merged branch', () => {
+    setup();
+    branching.branch('sealed');
+    branching.merge('sealed');
+    expect(() => branching.addOperation('sealed', 'e1', 'add', makeEntry('e1', 'x'))).toThrow(
+      "Branch 'sealed' is already merged",
+    );
+  });
+
+  test('requires entry data for add action', () => {
+    setup();
+    branching.branch('data-check');
+    expect(() => branching.addOperation('data-check', 'e1', 'add')).toThrow(
+      "Entry data required for 'add' action",
+    );
+  });
+
+  test('requires entry data for modify action', () => {
+    setup();
+    branching.branch('data-check');
+    expect(() => branching.addOperation('data-check', 'e1', 'modify')).toThrow(
+      "Entry data required for 'modify' action",
+    );
+  });
+
+  // ─── listBranches() ───────────────────────────────────────
+
+  test('lists multiple branches', () => {
+    setup();
+    branching.branch('alpha');
+    branching.branch('beta');
+    branching.addOperation('alpha', 'e1', 'add', makeEntry('e1', 'Entry'));
+    branching.addOperation('alpha', 'e2', 'add', makeEntry('e2', 'Entry 2'));
+
+    const branches = branching.listBranches();
+    expect(branches).toHaveLength(2);
+    const alpha = branches.find((b) => b.name === 'alpha')!;
+    const beta = branches.find((b) => b.name === 'beta')!;
+    expect(alpha.entryCount).toBe(2);
+    expect(beta.entryCount).toBe(0);
+  });
+
+  test('empty list when no branches', () => {
+    setup();
+    expect(branching.listBranches()).toEqual([]);
+  });
+
+  // ─── merge() ──────────────────────────────────────────────
+
+  test('merge adds new entries to vault', () => {
+    setup();
+    branching.branch('add-test');
+    branching.addOperation('add-test', 'new1', 'add', makeEntry('new1', 'New Entry'));
+    branching.addOperation('add-test', 'new2', 'add', makeEntry('new2', 'New Entry 2'));
+
+    const result = branching.merge('add-test');
+    expect(result.merged).toBe(true);
+    expect(result.added).toBe(2);
+    expect(result.total).toBe(2);
+
+    // Verify entries exist in vault
+    expect(vault.get('new1')?.title).toBe('New Entry');
+    expect(vault.get('new2')?.title).toBe('New Entry 2');
+  });
+
+  test('merge modifies existing entries (branch wins)', () => {
+    setup();
+    vault.add(makeEntry('existing', 'Original Title'));
+
+    branching.branch('modify-test');
+    const modified = makeEntry('existing', 'Updated Title');
+    branching.addOperation('modify-test', 'existing', 'modify', modified);
+
+    const result = branching.merge('modify-test');
+    expect(result.modified).toBe(1);
+
+    // Branch entry wins
+    expect(vault.get('existing')?.title).toBe('Updated Title');
+  });
+
+  test('merge removes entries from vault', () => {
+    setup();
+    vault.add(makeEntry('doomed', 'About to be removed'));
+
+    branching.branch('remove-test');
+    branching.addOperation('remove-test', 'doomed', 'remove');
+
+    const result = branching.merge('remove-test');
+    expect(result.removed).toBe(1);
+    expect(vault.get('doomed')).toBeNull();
+  });
+
+  test('merge collapses multiple ops on same entry', () => {
+    setup();
+    branching.branch('collapse-test');
+    branching.addOperation('collapse-test', 'e1', 'add', makeEntry('e1', 'First'));
+    branching.addOperation('collapse-test', 'e1', 'modify', makeEntry('e1', 'Second'));
+    branching.addOperation('collapse-test', 'e1', 'remove');
+
+    const result = branching.merge('collapse-test');
+    // Last op wins: remove
+    expect(result.removed).toBe(1);
+    expect(result.added).toBe(0);
+    expect(vault.get('e1')).toBeNull();
+  });
+
+  test('merge marks branch as merged', () => {
+    setup();
+    branching.branch('merge-mark');
+    branching.merge('merge-mark');
+
+    const branches = branching.listBranches();
+    const merged = branches.find((b) => b.name === 'merge-mark')!;
+    expect(merged.merged).toBe(true);
+  });
+
+  test('merge throws on non-existent branch', () => {
+    setup();
+    expect(() => branching.merge('ghost')).toThrow("Branch 'ghost' does not exist");
+  });
+
+  test('merge throws on already-merged branch', () => {
+    setup();
+    branching.branch('double-merge');
+    branching.merge('double-merge');
+    expect(() => branching.merge('double-merge')).toThrow(
+      "Branch 'double-merge' is already merged",
+    );
+  });
+
+  // ─── deleteBranch() ───────────────────────────────────────
+
+  test('deletes a branch', () => {
+    setup();
+    branching.branch('temp');
+    branching.addOperation('temp', 'e1', 'add', makeEntry('e1', 'Temp'));
+    expect(branching.deleteBranch('temp')).toBe(true);
+    expect(branching.listBranches()).toEqual([]);
+  });
+
+  test('returns false for non-existent branch', () => {
+    setup();
+    expect(branching.deleteBranch('nonexistent')).toBe(false);
+  });
+
+  test('deletes a merged branch', () => {
+    setup();
+    branching.branch('merged-del');
+    branching.merge('merged-del');
+    expect(branching.deleteBranch('merged-del')).toBe(true);
+  });
+
+  // ─── Mixed workflow ───────────────────────────────────────
+
+  test('full workflow: branch, add entries, merge, verify vault', () => {
+    setup();
+    // Seed vault with existing entries
+    vault.add(makeEntry('existing-1', 'Existing Pattern'));
+    vault.add(makeEntry('to-update', 'Old Title'));
+    vault.add(makeEntry('to-remove', 'Will Be Removed'));
+
+    // Create branch and make changes
+    branching.branch('feature-x');
+    branching.addOperation(
+      'feature-x',
+      'new-entry',
+      'add',
+      makeEntry('new-entry', 'New from branch'),
+    );
+    branching.addOperation('feature-x', 'to-update', 'modify', makeEntry('to-update', 'New Title'));
+    branching.addOperation('feature-x', 'to-remove', 'remove');
+
+    // Verify vault is unchanged before merge
+    expect(vault.get('to-update')?.title).toBe('Old Title');
+    expect(vault.get('to-remove')).not.toBeNull();
+    expect(vault.get('new-entry')).toBeNull();
+
+    // Merge
+    const result = branching.merge('feature-x');
+    expect(result.added).toBe(1);
+    expect(result.modified).toBe(1);
+    expect(result.removed).toBe(1);
+
+    // Verify vault state after merge
+    expect(vault.get('existing-1')?.title).toBe('Existing Pattern'); // untouched
+    expect(vault.get('new-entry')?.title).toBe('New from branch');
+    expect(vault.get('to-update')?.title).toBe('New Title');
+    expect(vault.get('to-remove')).toBeNull();
+  });
+});

package/src/__tests__/vault-connect.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Vault Connect/Disconnect Tests — dynamic named vault connections.
+ */
+
+import { describe, test, expect, afterEach } from 'vitest';
+import { VaultManager } from '../vault/vault-manager.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+function makeEntry(id: string, title: string, domain = 'general'): IntelligenceEntry {
+  return {
+    id,
+    type: 'pattern',
+    domain,
+    title,
+    severity: 'suggestion',
+    description: `Description for ${title}`,
+    tags: [domain],
+  };
+}
+
+describe('VaultManager — named connections', () => {
+  let mgr: VaultManager;
+
+  afterEach(() => {
+    mgr?.close();
+  });
+
+  test('connect adds a named vault', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const conn = mgr.connect('shared-kb', ':memory:', 0.7);
+    expect(conn.name).toBe('shared-kb');
+    expect(conn.priority).toBe(0.7);
+    expect(conn.vault).toBeDefined();
+  });
+
+  test('connect default priority is 0.5', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const conn = mgr.connect('default-priority', ':memory:');
+    expect(conn.priority).toBe(0.5);
+  });
+
+  test('connect duplicate name throws', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    mgr.connect('dup', ':memory:');
+    expect(() => mgr.connect('dup', ':memory:')).toThrow("Vault 'dup' is already connected");
+  });
+
+  test('disconnectNamed removes vault', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    mgr.connect('temp', ':memory:');
+    expect(mgr.disconnectNamed('temp')).toBe(true);
+    expect(mgr.getConnected('temp')).toBeUndefined();
+  });
+
+  test('disconnectNamed returns false for unknown', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    expect(mgr.disconnectNamed('nonexistent')).toBe(false);
+  });
+
+  test('listConnected returns sorted by priority', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    mgr.connect('low', ':memory:', 0.3);
+    mgr.connect('high', ':memory:', 0.9);
+    mgr.connect('mid', ':memory:', 0.5);
+
+    const list = mgr.listConnected();
+    expect(list).toHaveLength(3);
+    expect(list[0].name).toBe('high');
+    expect(list[1].name).toBe('mid');
+    expect(list[2].name).toBe('low');
+  });
+
+  test('listConnected empty when none connected', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    expect(mgr.listConnected()).toEqual([]);
+  });
+
+  test('getConnected returns entry', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    mgr.connect('kb', ':memory:', 0.6);
+    const entry = mgr.getConnected('kb');
+    expect(entry?.name).toBe('kb');
+    expect(entry?.priority).toBe(0.6);
+  });
+
+  test('search includes named vaults', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const agentVault = mgr.open('agent', ':memory:');
+    agentVault.add(makeEntry('a1', 'Agent design tokens'));
+
+    const conn = mgr.connect('shared', ':memory:', 0.7);
+    conn.vault.add(makeEntry('s1', 'Shared design tokens'));
+
+    const results = mgr.search('design tokens');
+    expect(results.length).toBe(2);
+    const ids = results.map((r) => r.entry.id);
+    expect(ids).toContain('a1');
+    expect(ids).toContain('s1');
+  });
+
+  test('search weights named vault by priority', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+
+    // Named vault with very low priority
+    const conn = mgr.connect('low-pri', ':memory:', 0.1);
+    conn.vault.add(makeEntry('lp1', 'Low priority pattern'));
+
+    // Agent tier (weight 1.0)
+    const agentVault = mgr.open('agent', ':memory:');
+    agentVault.add(makeEntry('hp1', 'High priority pattern'));
+
+    const results = mgr.search('priority pattern');
+    expect(results.length).toBe(2);
+    // Agent should be first (1.0 weight vs 0.1)
+    expect(results[0].entry.id).toBe('hp1');
+    expect(results[1].entry.id).toBe('lp1');
+  });
+
+  test('dedup: agent tier wins over named vault for same entry', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const agentVault = mgr.open('agent', ':memory:');
+    agentVault.add(makeEntry('same-id', 'Shared entry'));
+
+    const conn = mgr.connect('external', ':memory:', 0.7);
+    conn.vault.add(makeEntry('same-id', 'Shared entry'));
+
+    const results = mgr.search('shared entry');
+    const sameResults = results.filter((r) => r.entry.id === 'same-id');
+    expect(sameResults.length).toBe(1);
+    // Score should reflect agent weight (1.0) not external (0.7)
+    expect(sameResults[0].score).toBeGreaterThan(0);
+  });
+
+  test('disconnected vault excluded from search', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const conn = mgr.connect('removable', ':memory:', 0.5);
+    conn.vault.add(makeEntry('r1', 'Removable content'));
+
+    // Search before disconnect
+    let results = mgr.search('removable content');
+    expect(results.length).toBe(1);
+
+    // Disconnect
+    mgr.disconnectNamed('removable');
+
+    // Search after disconnect
+    results = mgr.search('removable content');
+    expect(results.length).toBe(0);
+  });
+
+  test('close clears both tiers and named connections', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    mgr.open('agent', ':memory:');
+    mgr.connect('extra1', ':memory:');
+    mgr.connect('extra2', ':memory:');
+
+    mgr.close();
+    expect(mgr.size).toBe(0);
+    expect(mgr.listConnected()).toEqual([]);
+  });
+
+  test('mixed search: tiers + named vaults all contribute', () => {
+    mgr = new VaultManager({ agentId: 'test' });
+    const agentVault = mgr.open('agent', ':memory:');
+    const projectVault = mgr.open('project', ':memory:');
+    const conn = mgr.connect('library', ':memory:', 0.4);
+
+    agentVault.add(makeEntry('a1', 'Agent widget pattern'));
+    projectVault.add(makeEntry('p1', 'Project widget convention'));
+    conn.vault.add(makeEntry('l1', 'Library widget standard'));
+
+    const results = mgr.search('widget');
+    expect(results.length).toBe(3);
+    // Ordering: agent (1.0) > project (0.8) > library (0.4)
+    expect(results[0].entry.id).toBe('a1');
+    expect(results[1].entry.id).toBe('p1');
+    expect(results[2].entry.id).toBe('l1');
+  });
+});

package/src/__tests__/vault-integrity.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { checkVaultIntegrity } from '../health/vault-integrity.js';
+import { Vault } from '../vault/vault.js';
+
+describe('checkVaultIntegrity', () => {
+  let vault: Vault;
+
+  afterEach(() => {
+    vault?.close();
+  });
+
+  it('reports healthy for a fresh vault', () => {
+    vault = new Vault(':memory:');
+    const result = checkVaultIntegrity(vault.getProvider());
+    expect(result.schemaValid).toBe(true);
+    expect(result.ftsValid).toBe(true);
+    expect(result.ftsRebuilt).toBe(false);
+    expect(result.missingTables).toEqual([]);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('detects FTS row count mismatch and auto-rebuilds', () => {
+    vault = new Vault(':memory:');
+    vault.seed([
+      {
+        id: 'test-1',
+        type: 'pattern',
+        domain: 'test',
+        title: 'Test entry',
+        severity: 'suggestion',
+        description: 'A test',
+        tags: ['test'],
+      },
+    ]);
+
+    // Corrupt FTS by deleting directly from FTS table
+    const provider = vault.getProvider();
+    try {
+      provider.run(
+        'DELETE FROM entries_fts WHERE rowid IN (SELECT rowid FROM entries_fts LIMIT 1)',
+      );
+    } catch {
+      // Some FTS implementations don't allow direct delete — skip test
+      return;
+    }
+
+    const result = checkVaultIntegrity(provider);
+    // Either detects mismatch or FTS doesn't allow direct manipulation
+    if (!result.ftsValid) {
+      expect(result.ftsRebuilt).toBe(true);
+      expect(result.errors.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('detects missing tables', () => {
+    vault = new Vault(':memory:');
+    const provider = vault.getProvider();
+
+    // Drop a non-FTS table to simulate corruption
+    try {
+      provider.run('DROP TABLE IF EXISTS brain_vocabulary');
+    } catch {
+      return; // Table may not exist
+    }
+
+    const result = checkVaultIntegrity(provider);
+    if (result.missingTables.includes('brain_vocabulary')) {
+      expect(result.schemaValid).toBe(false);
+    }
+  });
+});