@soleri/core 2.9.0 → 2.11.0

package/src/__tests__/git-vault-sync.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Git Vault Sync Tests — auto-commit vault changes to local git.
+ */
+
+import { describe, test, expect, afterEach } from 'vitest';
+import { mkdtempSync, existsSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { GitVaultSync } from '../vault/git-vault-sync.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],
+  };
+}
+
+function gitLog(repoDir: string): string[] {
+  try {
+    const out = execFileSync('git', ['log', '--oneline'], { cwd: repoDir, encoding: 'utf-8' });
+    return out
+      .trim()
+      .split('\n')
+      .filter((l) => l.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+describe('GitVaultSync', () => {
+  const dirs: string[] = [];
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'git-vault-sync-'));
+    dirs.push(dir);
+    return dir;
+  }
+
+  afterEach(() => {
+    for (const dir of dirs) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+    dirs.length = 0;
+  });
+
+  // ─── init ──────────────────────────────────────────────
+
+  test('init creates git repo', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+    expect(existsSync(join(repoDir, '.git'))).toBe(true);
+  });
+
+  test('init is idempotent', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+    await sync.init(); // should not throw
+    expect(existsSync(join(repoDir, '.git'))).toBe(true);
+  });
+
+  test('throws if not initialized', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await expect(sync.onAdd(makeEntry('e1', 'Test'))).rejects.toThrow('not initialized');
+  });
+
+  // ─── onAdd ─────────────────────────────────────────────
+
+  test('onAdd writes entry file and commits', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    const entry = makeEntry('pattern-1', 'Test Pattern', 'design');
+    await sync.onAdd(entry);
+
+    // File exists
+    const filePath = join(repoDir, 'design', 'pattern-1.json');
+    expect(existsSync(filePath)).toBe(true);
+
+    // Content is valid JSON
+    const content = JSON.parse(readFileSync(filePath, 'utf-8'));
+    expect(content.id).toBe('pattern-1');
+    expect(content.title).toBe('Test Pattern');
+
+    // Git commit exists
+    const log = gitLog(repoDir);
+    expect(log).toHaveLength(1);
+    expect(log[0]).toContain('vault: add pattern [design] pattern-1');
+  });
+
+  // ─── onUpdate ──────────────────────────────────────────
+
+  test('onUpdate overwrites file and commits', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    await sync.onAdd(makeEntry('e1', 'Original'));
+    await sync.onUpdate({ ...makeEntry('e1', 'Updated'), description: 'Updated description' });
+
+    const content = JSON.parse(readFileSync(join(repoDir, 'general', 'e1.json'), 'utf-8'));
+    expect(content.title).toBe('Updated');
+    expect(content.description).toBe('Updated description');
+
+    const log = gitLog(repoDir);
+    expect(log).toHaveLength(2);
+    expect(log[0]).toContain('vault: update');
+  });
+
+  // ─── onRemove ──────────────────────────────────────────
+
+  test('onRemove deletes file and commits', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    await sync.onAdd(makeEntry('doomed', 'Will Be Removed'));
+    expect(existsSync(join(repoDir, 'general', 'doomed.json'))).toBe(true);
+
+    await sync.onRemove('doomed', 'pattern', 'general');
+    expect(existsSync(join(repoDir, 'general', 'doomed.json'))).toBe(false);
+
+    const log = gitLog(repoDir);
+    expect(log).toHaveLength(2);
+    expect(log[0]).toContain('vault: remove');
+  });
+
+  test('onRemove is a no-op for non-existent file', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    // Should not throw
+    await sync.onRemove('nonexistent', 'pattern', 'general');
+  });
+
+  // ─── syncAll ───────────────────────────────────────────
+
+  test('syncAll writes all entries in a single commit', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    const entries = [
+      makeEntry('e1', 'Entry 1', 'design'),
+      makeEntry('e2', 'Entry 2', 'design'),
+      makeEntry('e3', 'Entry 3', 'a11y'),
+    ];
+
+    const result = await sync.syncAll(entries);
+    expect(result.synced).toBe(3);
+
+    // Files exist in domain subdirectories
+    expect(existsSync(join(repoDir, 'design', 'e1.json'))).toBe(true);
+    expect(existsSync(join(repoDir, 'design', 'e2.json'))).toBe(true);
+    expect(existsSync(join(repoDir, 'a11y', 'e3.json'))).toBe(true);
+
+    // Single commit
+    const log = gitLog(repoDir);
+    expect(log).toHaveLength(1);
+    expect(log[0]).toContain('bulk sync 3 entries');
+  });
+
+  // ─── log ───────────────────────────────────────────────
+
+  test('log returns commit history', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    await sync.onAdd(makeEntry('e1', 'First'));
+    await sync.onAdd(makeEntry('e2', 'Second'));
+
+    const log = await sync.log();
+    expect(log).toHaveLength(2);
+  });
+
+  test('log returns empty for fresh repo', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    const log = await sync.log();
+    expect(log).toEqual([]);
+  });
+
+  // ─── autoCommit: false ─────────────────────────────────
+
+  test('autoCommit false writes files without committing', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir, autoCommit: false });
+    await sync.init();
+
+    await sync.onAdd(makeEntry('e1', 'No Commit'));
+    expect(existsSync(join(repoDir, 'general', 'e1.json'))).toBe(true);
+
+    // No commits
+    const log = gitLog(repoDir);
+    expect(log).toEqual([]);
+  });
+
+  // ─── Multiple domains ─────────────────────────────────
+
+  test('organizes entries by domain subdirectories', async () => {
+    const repoDir = join(makeTempDir(), 'vault');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+
+    await sync.onAdd(makeEntry('p1', 'Design pattern', 'design'));
+    await sync.onAdd(makeEntry('p2', 'A11y rule', 'accessibility'));
+    await sync.onAdd(makeEntry('p3', 'General tip', 'general'));
+
+    expect(existsSync(join(repoDir, 'design', 'p1.json'))).toBe(true);
+    expect(existsSync(join(repoDir, 'accessibility', 'p2.json'))).toBe(true);
+    expect(existsSync(join(repoDir, 'general', 'p3.json'))).toBe(true);
+
+    const log = gitLog(repoDir);
+    expect(log).toHaveLength(3);
+  });
+});

package/src/__tests__/health-registry.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi } from 'vitest';
+import { HealthRegistry, withDegradation } from '../health/health-registry.js';
+
+describe('HealthRegistry', () => {
+  it('registers subsystems with default healthy status', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault');
+    const sub = reg.get('vault');
+    expect(sub).toBeDefined();
+    expect(sub!.status).toBe('healthy');
+    expect(sub!.failureCount).toBe(0);
+  });
+
+  it('ignores duplicate registration', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault', 'healthy');
+    reg.update('vault', 'degraded', 'test');
+    reg.register('vault'); // should NOT reset
+    expect(reg.get('vault')!.status).toBe('degraded');
+  });
+
+  it('tracks status transitions', () => {
+    const reg = new HealthRegistry();
+    reg.register('cognee');
+    reg.update('cognee', 'degraded', 'timeout');
+    expect(reg.get('cognee')!.status).toBe('degraded');
+    expect(reg.get('cognee')!.failureCount).toBe(1);
+    expect(reg.get('cognee')!.lastError).toBe('timeout');
+
+    reg.update('cognee', 'healthy');
+    expect(reg.get('cognee')!.failureCount).toBe(0);
+    expect(reg.get('cognee')!.lastError).toBeNull();
+    expect(reg.get('cognee')!.lastHealthyAt).toBeGreaterThan(0);
+  });
+
+  it('auto-registers on update if not registered', () => {
+    const reg = new HealthRegistry();
+    reg.update('new-sub', 'degraded', 'oops');
+    expect(reg.get('new-sub')!.status).toBe('degraded');
+  });
+
+  it('computes overall status', () => {
+    const reg = new HealthRegistry();
+    reg.register('a', 'healthy');
+    reg.register('b', 'healthy');
+    expect(reg.snapshot().overall).toBe('healthy');
+
+    reg.update('b', 'degraded');
+    expect(reg.snapshot().overall).toBe('degraded');
+
+    reg.update('a', 'down');
+    expect(reg.snapshot().overall).toBe('down');
+  });
+
+  it('fires status change listeners', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault');
+    const changes: Array<[string, string, string]> = [];
+    reg.onStatusChange((name, prev, next) => {
+      changes.push([name, prev, next]);
+    });
+
+    reg.update('vault', 'degraded');
+    reg.update('vault', 'degraded'); // same status — no listener
+    reg.update('vault', 'down');
+    reg.update('vault', 'healthy');
+
+    expect(changes).toEqual([
+      ['vault', 'healthy', 'degraded'],
+      ['vault', 'degraded', 'down'],
+      ['vault', 'down', 'healthy'],
+    ]);
+  });
+
+  it('does not fire listener for same status', () => {
+    const reg = new HealthRegistry();
+    reg.register('llm', 'healthy');
+    const listener = vi.fn();
+    reg.onStatusChange(listener);
+
+    reg.update('llm', 'healthy');
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('fires recovery hooks when transitioning to healthy', () => {
+    const reg = new HealthRegistry();
+    reg.register('cognee', 'down');
+    const hook = vi.fn();
+    reg.onRecovery('cognee', hook);
+
+    reg.update('cognee', 'healthy');
+    expect(hook).toHaveBeenCalledWith('cognee');
+  });
+
+  it('does not fire recovery hooks for non-recovery transitions', () => {
+    const reg = new HealthRegistry();
+    reg.register('cognee', 'healthy');
+    const hook = vi.fn();
+    reg.onRecovery('cognee', hook);
+
+    reg.update('cognee', 'degraded');
+    reg.update('cognee', 'down');
+    expect(hook).not.toHaveBeenCalled();
+  });
+
+  it('snapshot returns copies', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault', 'healthy');
+    const snap = reg.snapshot();
+    snap.subsystems['vault'].status = 'down'; // mutate copy
+    expect(reg.get('vault')!.status).toBe('healthy'); // original unchanged
+  });
+
+  it('listener errors do not crash the registry', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault');
+    reg.onStatusChange(() => {
+      throw new Error('bad listener');
+    });
+    // Should not throw
+    reg.update('vault', 'degraded');
+    expect(reg.get('vault')!.status).toBe('degraded');
+  });
+});
+
+describe('withDegradation', () => {
+  it('returns result on success and marks healthy', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test', 'degraded');
+
+    const result = await withDegradation(reg, 'test', async () => 42, 0);
+    expect(result).toBe(42);
+    expect(reg.get('test')!.status).toBe('healthy');
+  });
+
+  it('returns fallback on failure and marks degraded', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test');
+
+    const result = await withDegradation(
+      reg,
+      'test',
+      async () => {
+        throw new Error('boom');
+      },
+      'fallback',
+    );
+    expect(result).toBe('fallback');
+    expect(reg.get('test')!.status).toBe('degraded');
+    expect(reg.get('test')!.lastError).toBe('boom');
+  });
+
+  it('escalates to down on repeated failures', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test');
+
+    const fail = () =>
+      withDegradation(
+        reg,
+        'test',
+        async () => {
+          throw new Error('fail');
+        },
+        null,
+      );
+
+    await fail(); // healthy → degraded
+    expect(reg.get('test')!.status).toBe('degraded');
+
+    await fail(); // degraded → down
+    expect(reg.get('test')!.status).toBe('down');
+  });
+});

package/src/__tests__/knowledge-review.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Knowledge Review Tests — team review workflows.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import { Vault } from '../vault/vault.js';
+import { KnowledgeReview } from '../vault/knowledge-review.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+describe('KnowledgeReview', () => {
+  let vault: Vault;
+  let review: KnowledgeReview;
+
+  const entry: IntelligenceEntry = {
+    id: 'test-entry-1',
+    type: 'pattern',
+    domain: 'testing',
+    title: 'Test Pattern',
+    severity: 'suggestion',
+    description: 'A test pattern',
+    tags: ['test'],
+  };
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    vault.seed([entry]);
+    review = new KnowledgeReview(vault.getProvider());
+  });
+
+  afterEach(() => {
+    vault.close();
+  });
+
+  test('submit transitions to pending_review', () => {
+    const result = review.submit({ entryId: 'test-entry-1', submittedBy: 'alice' });
+    expect(result.status).toBe('pending_review');
+    expect(result.submittedBy).toBe('alice');
+    expect(result.submittedAt).toBeGreaterThan(0);
+  });
+
+  test('approve transitions from pending_review to approved', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    const result = review.approve({
+      entryId: 'test-entry-1',
+      reviewedBy: 'bob',
+      comment: 'Looks good',
+    });
+    expect(result.status).toBe('approved');
+    expect(result.reviewedBy).toBe('bob');
+    expect(result.reviewComment).toBe('Looks good');
+  });
+
+  test('reject transitions from pending_review to rejected', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    const result = review.reject({
+      entryId: 'test-entry-1',
+      reviewedBy: 'bob',
+      comment: 'Needs work',
+    });
+    expect(result.status).toBe('rejected');
+    expect(result.reviewComment).toBe('Needs work');
+  });
+
+  test('cannot approve non-pending entry', () => {
+    expect(() => review.approve({ entryId: 'test-entry-1' })).toThrow('not pending review');
+  });
+
+  test('cannot submit already pending entry', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    expect(() => review.submit({ entryId: 'test-entry-1' })).toThrow('cannot be submitted');
+  });
+
+  test('rejected entries can be resubmitted', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    review.reject({ entryId: 'test-entry-1' });
+    const result = review.submit({ entryId: 'test-entry-1', submittedBy: 'alice' });
+    expect(result.status).toBe('pending_review');
+  });
+
+  test('listPending returns pending entries', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    const pending = review.listPending();
+    expect(pending).toHaveLength(1);
+    expect(pending[0].entryId).toBe('test-entry-1');
+  });
+
+  test('stats returns counts by status', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    const stats = review.stats();
+    expect(stats.total).toBe(1);
+    expect(stats.byStatus.pending_review).toBe(1);
+  });
+
+  test('remove deletes review record', () => {
+    review.submit({ entryId: 'test-entry-1' });
+    const removed = review.remove('test-entry-1');
+    expect(removed).toBe(true);
+    expect(review.get('test-entry-1')).toBeNull();
+  });
+
+  test('get returns null for unknown entry', () => {
+    expect(review.get('nonexistent')).toBeNull();
+  });
+});