@soleri/core 2.1.0 → 2.5.0

package/src/__tests__/orchestrate-ops.test.ts

@@ -0,0 +1,289 @@
+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 { createOrchestrateOps } from '../runtime/orchestrate-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createOrchestrateOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let plannerDir: string;
+
+  beforeEach(() => {
+    plannerDir = join(tmpdir(), 'orchestrate-ops-test-' + Date.now());
+    mkdirSync(plannerDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'test-orchestrate',
+      vaultPath: ':memory:',
+      plansPath: join(plannerDir, 'plans.json'),
+    });
+    ops = createOrchestrateOps(runtime);
+  });
+
+  afterEach(() => {
+    runtime.close();
+    rmSync(plannerDir, { recursive: true, force: true });
+  });
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('should return 5 ops', () => {
+    expect(ops.length).toBe(5);
+  });
+
+  it('should have all expected op names', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('orchestrate_plan');
+    expect(names).toContain('orchestrate_execute');
+    expect(names).toContain('orchestrate_complete');
+    expect(names).toContain('orchestrate_status');
+    expect(names).toContain('orchestrate_quick_capture');
+  });
+
+  it('should assign correct auth levels', () => {
+    expect(findOp('orchestrate_plan').auth).toBe('write');
+    expect(findOp('orchestrate_execute').auth).toBe('write');
+    expect(findOp('orchestrate_complete').auth).toBe('write');
+    expect(findOp('orchestrate_status').auth).toBe('read');
+    expect(findOp('orchestrate_quick_capture').auth).toBe('write');
+  });
+
+  // ─── orchestrate_plan ───────────────────────────────────────────
+
+  describe('orchestrate_plan', () => {
+    it('should create a plan with empty recommendations when brain has no data', async () => {
+      const op = findOp('orchestrate_plan');
+      const result = (await op.handler({
+        objective: 'Build a new button component',
+        scope: 'src/components/Button',
+        domain: 'component',
+      })) as {
+        plan: { id: string; objective: string; decisions: string[] };
+        recommendations: unknown[];
+      };
+
+      expect(result.plan).toBeDefined();
+      expect(result.plan.objective).toBe('Build a new button component');
+      expect(result.recommendations).toEqual([]);
+      expect(result.plan.decisions).toEqual([]);
+    });
+
+    it('should create a plan with tasks when provided', async () => {
+      const op = findOp('orchestrate_plan');
+      const result = (await op.handler({
+        objective: 'Refactor auth module',
+        scope: 'src/auth',
+        tasks: [
+          { title: 'Extract interfaces', description: 'Pull out shared types' },
+          { title: 'Add tests', description: 'Cover edge cases' },
+        ],
+      })) as { plan: { tasks: Array<{ title: string }> } };
+
+      expect(result.plan.tasks).toHaveLength(2);
+      expect(result.plan.tasks[0].title).toBe('Extract interfaces');
+      expect(result.plan.tasks[1].title).toBe('Add tests');
+    });
+
+    it('should work without optional domain parameter', async () => {
+      const op = findOp('orchestrate_plan');
+      const result = (await op.handler({
+        objective: 'Quick fix',
+        scope: 'all',
+      })) as { plan: { id: string } };
+
+      expect(result.plan.id).toBeDefined();
+    });
+  });
+
+  // ─── orchestrate_execute ────────────────────────────────────────
+
+  describe('orchestrate_execute', () => {
+    it('should start plan execution and open a brain session', async () => {
+      // Create and approve a plan first
+      const plan = runtime.planner.create({
+        objective: 'Test execution',
+        scope: 'test',
+      });
+      runtime.planner.approve(plan.id);
+
+      const op = findOp('orchestrate_execute');
+      const result = (await op.handler({
+        planId: plan.id,
+        domain: 'testing',
+        context: 'Running orchestration test',
+      })) as { plan: { status: string }; session: { id: string; domain: string | null } };
+
+      expect(result.plan.status).toBe('executing');
+      expect(result.session).toBeDefined();
+      expect(result.session.id).toBeDefined();
+      expect(result.session.domain).toBe('testing');
+    });
+
+    it('should throw when plan is not approved', async () => {
+      const plan = runtime.planner.create({
+        objective: 'Not approved',
+        scope: 'test',
+      });
+
+      const op = findOp('orchestrate_execute');
+      await expect(op.handler({ planId: plan.id })).rejects.toThrow(/Invalid transition/);
+    });
+  });
+
+  // ─── orchestrate_complete ───────────────────────────────────────
+
+  describe('orchestrate_complete', () => {
+    it('should complete plan, end session, and extract knowledge', async () => {
+      // Full lifecycle: create -> approve -> execute -> reconciling -> complete
+      const plan = runtime.planner.create({
+        objective: 'Full lifecycle test',
+        scope: 'test',
+      });
+      runtime.planner.approve(plan.id);
+      runtime.planner.startExecution(plan.id);
+      runtime.planner.startReconciliation(plan.id);
+
+      // Start a brain session
+      const session = runtime.brainIntelligence.lifecycle({
+        action: 'start',
+        domain: 'testing',
+        planId: plan.id,
+      });
+
+      const op = findOp('orchestrate_complete');
+      const result = (await op.handler({
+        planId: plan.id,
+        sessionId: session.id,
+        outcome: 'completed',
+        toolsUsed: ['tool1', 'tool2', 'tool1', 'tool1'],
+        filesModified: ['a.ts', 'b.ts'],
+      })) as {
+        plan: { status: string };
+        session: { endedAt: string | null; planOutcome: string | null };
+        extraction: unknown;
+      };
+
+      expect(result.plan.status).toBe('completed');
+      expect(result.session.endedAt).toBeDefined();
+      expect(result.session.planOutcome).toBe('completed');
+      // extraction may or may not produce proposals depending on heuristics
+    });
+
+    it('should handle abandoned outcome', async () => {
+      const plan = runtime.planner.create({ objective: 'Abandoned test', scope: 'test' });
+      runtime.planner.approve(plan.id);
+      runtime.planner.startExecution(plan.id);
+      runtime.planner.startReconciliation(plan.id);
+
+      const session = runtime.brainIntelligence.lifecycle({
+        action: 'start',
+        domain: 'testing',
+      });
+
+      const op = findOp('orchestrate_complete');
+      const result = (await op.handler({
+        planId: plan.id,
+        sessionId: session.id,
+        outcome: 'abandoned',
+      })) as { plan: { status: string }; session: { planOutcome: string | null } };
+
+      expect(result.plan.status).toBe('completed');
+      expect(result.session.planOutcome).toBe('abandoned');
+    });
+  });
+
+  // ─── orchestrate_status ─────────────────────────────────────────
+
+  describe('orchestrate_status', () => {
+    it('should return combined status', async () => {
+      const op = findOp('orchestrate_status');
+      const result = (await op.handler({})) as {
+        activePlans: unknown[];
+        sessionContext: { recentSessions: unknown[] };
+        vaultStats: { totalEntries: number };
+        recommendations: unknown[];
+        brainStats: { sessions: number };
+      };
+
+      expect(result.activePlans).toBeDefined();
+      expect(Array.isArray(result.activePlans)).toBe(true);
+      expect(result.sessionContext).toBeDefined();
+      expect(result.vaultStats).toBeDefined();
+      expect(result.recommendations).toBeDefined();
+      expect(result.brainStats).toBeDefined();
+    });
+
+    it('should include active plans in status', async () => {
+      runtime.planner.create({ objective: 'Active plan 1', scope: 'test' });
+      runtime.planner.create({ objective: 'Active plan 2', scope: 'test' });
+
+      const op = findOp('orchestrate_status');
+      const result = (await op.handler({})) as {
+        activePlans: Array<{ objective: string }>;
+      };
+
+      expect(result.activePlans).toHaveLength(2);
+    });
+
+    it('should respect sessionLimit parameter', async () => {
+      const op = findOp('orchestrate_status');
+      const result = (await op.handler({ sessionLimit: 2 })) as {
+        sessionContext: { recentSessions: unknown[] };
+      };
+
+      // No sessions exist, but the limit should be respected
+      expect(result.sessionContext.recentSessions).toBeDefined();
+    });
+  });
+
+  // ─── orchestrate_quick_capture ──────────────────────────────────
+
+  describe('orchestrate_quick_capture', () => {
+    it('should create, end, and extract in one call', async () => {
+      const op = findOp('orchestrate_quick_capture');
+      const result = (await op.handler({
+        domain: 'component',
+        context: 'Built a new date picker with keyboard navigation',
+        toolsUsed: ['validate_component_code', 'check_contrast'],
+        filesModified: ['src/DatePicker.tsx', 'src/DatePicker.test.tsx'],
+        outcome: 'completed',
+      })) as {
+        session: { id: string; endedAt: string | null; domain: string | null };
+        extraction: unknown;
+      };
+
+      expect(result.session).toBeDefined();
+      expect(result.session.endedAt).toBeDefined();
+      expect(result.session.domain).toBe('component');
+    });
+
+    it('should work with minimal params', async () => {
+      const op = findOp('orchestrate_quick_capture');
+      const result = (await op.handler({
+        domain: 'misc',
+        context: 'Fixed a typo',
+      })) as { session: { id: string } };
+
+      expect(result.session).toBeDefined();
+      expect(result.session.id).toBeDefined();
+    });
+
+    it('should handle abandoned outcome', async () => {
+      const op = findOp('orchestrate_quick_capture');
+      const result = (await op.handler({
+        domain: 'refactor',
+        context: 'Started refactor but rolled back',
+        outcome: 'abandoned',
+      })) as { session: { planOutcome: string | null } };
+
+      expect(result.session.planOutcome).toBe('abandoned');
+    });
+  });
+});

package/src/__tests__/persistence.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect } from 'vitest';
+import { SQLitePersistenceProvider } from '../persistence/sqlite-provider.js';
+import { Vault } from '../vault/vault.js';
+
+// ─── SQLitePersistenceProvider ────────────────────────────────────────
+
+describe('SQLitePersistenceProvider', () => {
+  it('execSql creates tables', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE test (id TEXT PRIMARY KEY, val TEXT)');
+    p.run('INSERT INTO test (id, val) VALUES (?, ?)', ['a', 'hello']);
+    const row = p.get<{ id: string; val: string }>('SELECT * FROM test WHERE id = ?', ['a']);
+    expect(row).toEqual({ id: 'a', val: 'hello' });
+    p.close();
+  });
+
+  it('run with named params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY, name TEXT)');
+    const result = p.run('INSERT INTO t (id, name) VALUES (@id, @name)', {
+      id: '1',
+      name: 'test',
+    });
+    expect(result.changes).toBe(1);
+    p.close();
+  });
+
+  it('run with positional params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const result = p.run('INSERT INTO t (id) VALUES (?)', ['x']);
+    expect(result.changes).toBe(1);
+    p.close();
+  });
+
+  it('run with no params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT)');
+    const result = p.run('INSERT INTO t DEFAULT VALUES');
+    expect(result.changes).toBe(1);
+    expect(result.lastInsertRowid).toBe(1);
+    p.close();
+  });
+
+  it('get returns undefined for no match', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const row = p.get('SELECT * FROM t WHERE id = ?', ['nonexistent']);
+    expect(row).toBeUndefined();
+    p.close();
+  });
+
+  it('all returns empty for no matches', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toEqual([]);
+    p.close();
+  });
+
+  it('all returns multiple rows', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY, val INTEGER)');
+    p.run('INSERT INTO t VALUES (?, ?)', ['a', 1]);
+    p.run('INSERT INTO t VALUES (?, ?)', ['b', 2]);
+    p.run('INSERT INTO t VALUES (?, ?)', ['c', 3]);
+    const rows = p.all<{ id: string; val: number }>('SELECT * FROM t ORDER BY id');
+    expect(rows).toHaveLength(3);
+    expect(rows[0].id).toBe('a');
+    expect(rows[2].val).toBe(3);
+    p.close();
+  });
+
+  it('transaction commits on success', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    p.transaction(() => {
+      p.run('INSERT INTO t VALUES (?)', ['a']);
+      p.run('INSERT INTO t VALUES (?)', ['b']);
+    });
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toHaveLength(2);
+    p.close();
+  });
+
+  it('transaction rolls back on error', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    expect(() =>
+      p.transaction(() => {
+        p.run('INSERT INTO t VALUES (?)', ['a']);
+        throw new Error('rollback');
+      }),
+    ).toThrow('rollback');
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toHaveLength(0);
+    p.close();
+  });
+
+  it('transaction returns value', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const result = p.transaction(() => {
+      p.run('INSERT INTO t VALUES (?)', ['a']);
+      return 42;
+    });
+    expect(result).toBe(42);
+    p.close();
+  });
+
+  it('getDatabase returns raw db', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    const db = p.getDatabase();
+    expect(db).toBeDefined();
+    // Verify it's a real better-sqlite3 database
+    expect(typeof db.prepare).toBe('function');
+    p.close();
+  });
+
+  it('close prevents further operations', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.close();
+    expect(() => p.run('SELECT 1')).toThrow();
+  });
+});
+
+// ─── Vault with PersistenceProvider ───────────────────────────────────
+
+describe('Vault with PersistenceProvider', () => {
+  it('accepts string path (backward compat)', () => {
+    const vault = new Vault(':memory:');
+    expect(vault.stats().totalEntries).toBe(0);
+    vault.close();
+  });
+
+  it('accepts SQLitePersistenceProvider', () => {
+    const provider = new SQLitePersistenceProvider(':memory:');
+    provider.run('PRAGMA journal_mode = WAL');
+    provider.run('PRAGMA foreign_keys = ON');
+    const vault = new Vault(provider);
+    expect(vault.stats().totalEntries).toBe(0);
+    vault.close();
+  });
+
+  it('createWithSQLite factory works', () => {
+    const vault = Vault.createWithSQLite(':memory:');
+    vault.add({
+      id: 'test-1',
+      type: 'pattern',
+      domain: 'core',
+      title: 'Test Pattern',
+      severity: 'suggestion',
+      description: 'A test',
+      tags: ['test'],
+    });
+    expect(vault.stats().totalEntries).toBe(1);
+    vault.close();
+  });
+
+  it('getProvider returns the provider', () => {
+    const provider = new SQLitePersistenceProvider(':memory:');
+    provider.run('PRAGMA journal_mode = WAL');
+    provider.run('PRAGMA foreign_keys = ON');
+    const vault = new Vault(provider);
+    expect(vault.getProvider()).toBe(provider);
+    vault.close();
+  });
+
+  it('getDb works with SQLite provider', () => {
+    const vault = new Vault(':memory:');
+    const db = vault.getDb();
+    expect(typeof db.prepare).toBe('function');
+    vault.close();
+  });
+
+  it('all vault operations work through provider', () => {
+    const vault = new Vault(':memory:');
+
+    // seed + get
+    vault.seed([
+      {
+        id: 'e1',
+        type: 'pattern',
+        domain: 'test',
+        title: 'Pattern One',
+        severity: 'suggestion',
+        description: 'First pattern',
+        tags: ['a', 'b'],
+      },
+      {
+        id: 'e2',
+        type: 'anti-pattern',
+        domain: 'test',
+        title: 'Anti Pattern',
+        severity: 'warning',
+        description: 'Avoid this',
+        tags: ['c'],
+      },
+    ]);
+    expect(vault.get('e1')?.title).toBe('Pattern One');
+    expect(vault.stats().totalEntries).toBe(2);
+
+    // search
+    const results = vault.search('pattern');
+    expect(results.length).toBeGreaterThan(0);
+
+    // list
+    const all = vault.list({ domain: 'test' });
+    expect(all).toHaveLength(2);
+
+    // update
+    const updated = vault.update('e1', { title: 'Updated' });
+    expect(updated?.title).toBe('Updated');
+
+    // remove
+    expect(vault.remove('e2')).toBe(true);
+    expect(vault.stats().totalEntries).toBe(1);
+
+    // bulk remove
+    expect(vault.bulkRemove(['e1'])).toBe(1);
+    expect(vault.stats().totalEntries).toBe(0);
+
+    vault.close();
+  });
+});