@soleri/core 9.0.4 → 9.3.0

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

@@ -0,0 +1,234 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { GitVaultSync } from './git-vault-sync.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
+  return {
+    id: `test-${randomUUID().slice(0, 8)}`,
+    type: 'pattern',
+    domain: 'architecture',
+    title: 'Test Pattern',
+    severity: 'suggestion',
+    description: 'A test pattern.',
+    tags: ['testing'],
+    ...overrides,
+  };
+}
+
+describe('GitVaultSync', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `git-vault-sync-${randomUUID().slice(0, 8)}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── constructor defaults ────────────────────────────────────────────
+
+  it('stores repoDir from config', () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    expect(sync.getRepoDir()).toBe(tmpDir);
+  });
+
+  // ── init ────────────────────────────────────────────────────────────
+
+  it('creates directory and initializes git repo', async () => {
+    const repoDir = join(tmpDir, 'new-repo');
+    const sync = new GitVaultSync({ repoDir });
+    await sync.init();
+    expect(existsSync(join(repoDir, '.git'))).toBe(true);
+  });
+
+  it('is idempotent — init twice does not fail', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    await sync.init();
+    await sync.init(); // should not throw
+    expect(existsSync(join(tmpDir, '.git'))).toBe(true);
+  });
+
+  // ── ensureInitialized guard ─────────────────────────────────────────
+
+  it('throws if onAdd called before init', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    await expect(sync.onAdd(makeEntry())).rejects.toThrow('not initialized');
+  });
+
+  it('throws if onUpdate called before init', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    await expect(sync.onUpdate(makeEntry())).rejects.toThrow('not initialized');
+  });
+
+  it('throws if onRemove called before init', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    await expect(sync.onRemove('id', 'pattern', 'domain')).rejects.toThrow('not initialized');
+  });
+
+  // ── onAdd ───────────────────────────────────────────────────────────
+
+  it('writes entry as JSON file on add', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entry = makeEntry({ domain: 'testing', id: 'e1' });
+    await sync.onAdd(entry);
+
+    const filePath = join(tmpDir, 'testing', 'e1.json');
+    expect(existsSync(filePath)).toBe(true);
+    const content = JSON.parse(readFileSync(filePath, 'utf-8'));
+    expect(content.id).toBe('e1');
+    expect(content.title).toBe('Test Pattern');
+  });
+
+  it('creates domain subdirectory on add', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    await sync.onAdd(makeEntry({ domain: 'new-domain' }));
+    expect(existsSync(join(tmpDir, 'new-domain'))).toBe(true);
+  });
+
+  it('commits on add when autoCommit is true', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: true });
+    await sync.init();
+    await sync.onAdd(makeEntry({ id: 'committed-entry' }));
+    const log = await sync.log(5);
+    expect(log.length).toBeGreaterThanOrEqual(1);
+    expect(log[0]).toContain('vault: add');
+  });
+
+  // ── onUpdate ────────────────────────────────────────────────────────
+
+  it('overwrites entry file on update', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entry = makeEntry({ id: 'e1', domain: 'arch', title: 'Original' });
+    await sync.onAdd(entry);
+    await sync.onUpdate({ ...entry, title: 'Updated' });
+
+    const content = JSON.parse(readFileSync(join(tmpDir, 'arch', 'e1.json'), 'utf-8'));
+    expect(content.title).toBe('Updated');
+  });
+
+  // ── onRemove ────────────────────────────────────────────────────────
+
+  it('deletes the entry file on remove', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entry = makeEntry({ id: 'e1', domain: 'arch' });
+    await sync.onAdd(entry);
+    await sync.onRemove('e1', 'pattern', 'arch');
+    expect(existsSync(join(tmpDir, 'arch', 'e1.json'))).toBe(false);
+  });
+
+  it('does not throw when removing non-existent file', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    await sync.onRemove('nonexistent', 'pattern', 'arch'); // should not throw
+  });
+
+  // ── syncAll ─────────────────────────────────────────────────────────
+
+  it('writes all entries and returns count', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entries = [makeEntry({ id: 'e1', domain: 'd' }), makeEntry({ id: 'e2', domain: 'd' })];
+    const result = await sync.syncAll(entries);
+    expect(result.synced).toBe(2);
+    expect(existsSync(join(tmpDir, 'd', 'e1.json'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'd', 'e2.json'))).toBe(true);
+  });
+
+  it('returns zero for empty array', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const result = await sync.syncAll([]);
+    expect(result.synced).toBe(0);
+  });
+
+  // ── log ─────────────────────────────────────────────────────────────
+
+  it('returns empty array when no commits exist', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir });
+    await sync.init();
+    const log = await sync.log();
+    expect(log).toEqual([]);
+  });
+
+  // ── pull ────────────────────────────────────────────────────────────
+
+  it('imports entries from git directory into vault', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    // Write entry files manually
+    const entry = makeEntry({ id: 'imported', domain: 'test-domain' });
+    mkdirSync(join(tmpDir, 'test-domain'), { recursive: true });
+    writeFileSync(join(tmpDir, 'test-domain', 'imported.json'), JSON.stringify(entry), 'utf-8');
+
+    const mockVault = {
+      get: vi.fn().mockReturnValue(null),
+      seed: vi.fn().mockReturnValue(1),
+    };
+    const result = await sync.pull(mockVault);
+    expect(result.imported).toBe(1);
+    expect(result.skipped).toBe(0);
+    expect(mockVault.seed).toHaveBeenCalled();
+  });
+
+  it('skips conflicting entries when onConflict is vault', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entry = makeEntry({ id: 'conflict', domain: 'test' });
+    mkdirSync(join(tmpDir, 'test'), { recursive: true });
+    writeFileSync(join(tmpDir, 'test', 'conflict.json'), JSON.stringify(entry), 'utf-8');
+
+    const mockVault = {
+      get: vi.fn().mockReturnValue(entry), // exists in vault
+      seed: vi.fn().mockReturnValue(1),
+    };
+    const result = await sync.pull(mockVault, { onConflict: 'vault' });
+    expect(result.skipped).toBe(1);
+    expect(result.conflicts).toBe(1);
+    expect(mockVault.seed).not.toHaveBeenCalled();
+  });
+
+  it('overwrites conflicting entries when onConflict is git (default)', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+    const entry = makeEntry({ id: 'conflict', domain: 'test' });
+    mkdirSync(join(tmpDir, 'test'), { recursive: true });
+    writeFileSync(join(tmpDir, 'test', 'conflict.json'), JSON.stringify(entry), 'utf-8');
+
+    const mockVault = {
+      get: vi.fn().mockReturnValue(entry),
+      seed: vi.fn().mockReturnValue(1),
+    };
+    const result = await sync.pull(mockVault);
+    expect(result.imported).toBe(1);
+    expect(result.conflicts).toBe(1);
+  });
+
+  // ── sync (bidirectional) ────────────────────────────────────────────
+
+  it('pushes and pulls during bidirectional sync', async () => {
+    const sync = new GitVaultSync({ repoDir: tmpDir, autoCommit: false });
+    await sync.init();
+
+    const vaultEntry = makeEntry({ id: 'vault-e', domain: 'dom' });
+    const mockVault = {
+      get: vi.fn().mockReturnValue(null),
+      seed: vi.fn().mockReturnValue(1),
+      exportAll: vi.fn().mockReturnValue({ entries: [vaultEntry] }),
+    };
+
+    const result = await sync.sync(mockVault);
+    expect(result.pushed).toBe(1);
+    // The pushed entry will also be found during pull, but filtered by vaultIds
+    expect(result.pulled).toBe(0);
+  });
+});

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

@@ -0,0 +1,269 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { KnowledgeReview } from './knowledge-review.js';
+import type { PersistenceProvider, RunResult } from '../persistence/types.js';
+
+// ─── In-memory mock persistence ──────────────────────────────────────
+
+class MockPersistence implements PersistenceProvider {
+  readonly backend = 'sqlite' as const;
+  private tables = new Map<string, Array<Record<string, unknown>>>();
+  private schemas: string[] = [];
+
+  execSql(sql: string): void {
+    this.schemas.push(sql);
+    // Auto-create table name from CREATE TABLE statement
+    const match = sql.match(/CREATE TABLE IF NOT EXISTS (\w+)/);
+    if (match && !this.tables.has(match[1])) {
+      this.tables.set(match[1], []);
+    }
+  }
+
+  run(sql: string, params?: Record<string, unknown> | unknown[]): RunResult {
+    const table = this.getTable();
+    const normalizedParams = this.normalizeParams(sql, params);
+
+    if (sql.includes('INSERT')) {
+      return this.handleInsert(sql, normalizedParams, table);
+    }
+    if (sql.includes('UPDATE')) {
+      return this.handleUpdate(sql, normalizedParams, table);
+    }
+    if (sql.includes('DELETE')) {
+      return this.handleDelete(normalizedParams, table);
+    }
+    return { changes: 0, lastInsertRowid: 0 };
+  }
+
+  get<T>(sql: string, params?: Record<string, unknown> | unknown[]): T | undefined {
+    const table = this.getTable();
+    const normalizedParams = this.normalizeParams(sql, params);
+
+    if (sql.includes('COUNT(*)')) {
+      return { c: table.length } as T;
+    }
+    if (sql.includes('GROUP BY')) {
+      return undefined;
+    }
+
+    const entryId = normalizedParams.entryId ?? normalizedParams.entry_id;
+    if (entryId) {
+      const row = table.find((r) => r.entry_id === entryId);
+      return row as T | undefined;
+    }
+    return table[0] as T | undefined;
+  }
+
+  all<T>(sql: string, params?: Record<string, unknown> | unknown[]): T[] {
+    const table = this.getTable();
+    const normalizedParams = this.normalizeParams(sql, params);
+
+    if (sql.includes('GROUP BY')) {
+      const groups = new Map<string, number>();
+      for (const row of table) {
+        const status = row.status as string;
+        groups.set(status, (groups.get(status) ?? 0) + 1);
+      }
+      return Array.from(groups.entries()).map(([status, count]) => ({
+        status,
+        count,
+      })) as T[];
+    }
+
+    if (normalizedParams.status) {
+      return table.filter((r) => r.status === normalizedParams.status) as T[];
+    }
+    return table as T[];
+  }
+
+  transaction<T>(fn: () => T): T {
+    return fn();
+  }
+
+  ftsSearch<T>(): T[] {
+    return [];
+  }
+  ftsRebuild(): void {}
+  close(): void {}
+
+  // ── Internal helpers ───────────────────────────────────────────────
+
+  private getTable(): Array<Record<string, unknown>> {
+    if (!this.tables.has('entry_reviews')) {
+      this.tables.set('entry_reviews', []);
+    }
+    return this.tables.get('entry_reviews')!;
+  }
+
+  private normalizeParams(
+    sql: string,
+    params?: Record<string, unknown> | unknown[],
+  ): Record<string, unknown> {
+    if (!params) return {};
+    if (Array.isArray(params)) return {};
+    return params;
+  }
+
+  private handleInsert(
+    sql: string,
+    params: Record<string, unknown>,
+    table: Array<Record<string, unknown>>,
+  ): RunResult {
+    const existing = table.findIndex((r) => r.entry_id === params.entryId);
+    const row: Record<string, unknown> = {
+      entry_id: params.entryId,
+      status: 'pending_review',
+      submitted_by: params.submittedBy ?? null,
+      reviewed_by: null,
+      review_comment: null,
+      submitted_at: params.now ?? null,
+      reviewed_at: null,
+    };
+    if (existing >= 0 && sql.includes('ON CONFLICT')) {
+      table[existing] = row;
+    } else {
+      table.push(row);
+    }
+    return { changes: 1, lastInsertRowid: table.length };
+  }
+
+  private handleUpdate(
+    _sql: string,
+    params: Record<string, unknown>,
+    table: Array<Record<string, unknown>>,
+  ): RunResult {
+    const idx = table.findIndex((r) => r.entry_id === params.entryId);
+    if (idx < 0) return { changes: 0, lastInsertRowid: 0 };
+    table[idx] = {
+      ...table[idx],
+      status: params.status,
+      reviewed_by: params.reviewedBy ?? null,
+      review_comment: params.comment ?? null,
+      reviewed_at: params.now ?? null,
+    };
+    return { changes: 1, lastInsertRowid: 0 };
+  }
+
+  private handleDelete(
+    params: Record<string, unknown>,
+    table: Array<Record<string, unknown>>,
+  ): RunResult {
+    const idx = table.findIndex((r) => r.entry_id === params.entryId);
+    if (idx < 0) return { changes: 0, lastInsertRowid: 0 };
+    table.splice(idx, 1);
+    return { changes: 1, lastInsertRowid: 0 };
+  }
+}
+
+describe('KnowledgeReview', () => {
+  let review: KnowledgeReview;
+
+  beforeEach(() => {
+    const provider = new MockPersistence();
+    review = new KnowledgeReview(provider);
+  });
+
+  // ── submit ──────────────────────────────────────────────────────────
+
+  it('submits a new entry for review', () => {
+    const result = review.submit({ entryId: 'e1' });
+    expect(result.entryId).toBe('e1');
+    expect(result.status).toBe('pending_review');
+  });
+
+  it('submits with submittedBy field', () => {
+    const result = review.submit({ entryId: 'e1', submittedBy: 'alice' });
+    expect(result.submittedBy).toBe('alice');
+  });
+
+  it('allows resubmission of rejected entries', () => {
+    review.submit({ entryId: 'e1' });
+    review.reject({ entryId: 'e1' });
+    const result = review.submit({ entryId: 'e1' });
+    expect(result.status).toBe('pending_review');
+  });
+
+  it('throws when submitting an already-pending entry', () => {
+    review.submit({ entryId: 'e1' });
+    expect(() => review.submit({ entryId: 'e1' })).toThrow('cannot be submitted');
+  });
+
+  it('throws when submitting an approved entry', () => {
+    review.submit({ entryId: 'e1' });
+    review.approve({ entryId: 'e1' });
+    expect(() => review.submit({ entryId: 'e1' })).toThrow('cannot be submitted');
+  });
+
+  // ── approve ─────────────────────────────────────────────────────────
+
+  it('approves a pending entry', () => {
+    review.submit({ entryId: 'e1' });
+    const result = review.approve({ entryId: 'e1', reviewedBy: 'bob', comment: 'Looks good' });
+    expect(result.status).toBe('approved');
+    expect(result.reviewedBy).toBe('bob');
+    expect(result.reviewComment).toBe('Looks good');
+  });
+
+  it('throws when approving non-pending entry', () => {
+    expect(() => review.approve({ entryId: 'nonexistent' })).toThrow('not pending review');
+  });
+
+  // ── reject ──────────────────────────────────────────────────────────
+
+  it('rejects a pending entry', () => {
+    review.submit({ entryId: 'e1' });
+    const result = review.reject({ entryId: 'e1', comment: 'Needs work' });
+    expect(result.status).toBe('rejected');
+    expect(result.reviewComment).toBe('Needs work');
+  });
+
+  it('throws when rejecting non-pending entry', () => {
+    expect(() => review.reject({ entryId: 'missing' })).toThrow('not pending review');
+  });
+
+  // ── get ─────────────────────────────────────────────────────────────
+
+  it('returns null for unknown entry', () => {
+    expect(review.get('unknown')).toBeNull();
+  });
+
+  it('returns review entry for known entry', () => {
+    review.submit({ entryId: 'e1' });
+    const entry = review.get('e1');
+    expect(entry).not.toBeNull();
+    expect(entry!.entryId).toBe('e1');
+  });
+
+  // ── listPending ─────────────────────────────────────────────────────
+
+  it('lists pending entries', () => {
+    review.submit({ entryId: 'e1' });
+    review.submit({ entryId: 'e2' });
+    const pending = review.listPending();
+    expect(pending).toHaveLength(2);
+    expect(pending.every((e) => e.status === 'pending_review')).toBe(true);
+  });
+
+  // ── stats ───────────────────────────────────────────────────────────
+
+  it('returns stats with totals and breakdown', () => {
+    review.submit({ entryId: 'e1' });
+    review.submit({ entryId: 'e2' });
+    review.approve({ entryId: 'e1' });
+    const s = review.stats();
+    expect(s.total).toBe(2);
+    expect(s.byStatus.approved).toBe(1);
+    expect(s.byStatus.pending_review).toBe(1);
+  });
+
+  // ── remove ──────────────────────────────────────────────────────────
+
+  it('removes a review entry', () => {
+    review.submit({ entryId: 'e1' });
+    expect(review.remove('e1')).toBe(true);
+    expect(review.get('e1')).toBeNull();
+  });
+
+  it('returns false when removing nonexistent entry', () => {
+    expect(review.remove('nonexistent')).toBe(false);
+  });
+});