@soleri/core 9.0.4 → 9.2.0

package/src/{__tests__ → runtime}/playbook-ops-execution.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createPlaybookOps } from '../runtime/playbook-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
+import { createAgentRuntime } from './runtime.js';
+import { createPlaybookOps } from './playbook-ops.js';
+import type { AgentRuntime } from './types.js';
 import type { OpDefinition } from '../facades/types.js';
 
 describe('playbook execution ops', () => {

package/src/runtime/playbook-ops.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Unit tests for playbook-ops — 8 ops for playbook management and execution.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createPlaybookOps } from './playbook-ops.js';
+import type { AgentRuntime } from './types.js';
+
+/** Minimal vault stub that stores entries in memory. */
+function makeVaultStub() {
+  const entries = new Map<string, { id: string; type: string; domain?: string; title: string; description: string; context?: string; tags?: string[]; severity?: string }>();
+  return {
+    list: (opts: { type?: string; domain?: string; limit?: number }) => {
+      let arr = [...entries.values()];
+      if (opts.type) arr = arr.filter((e) => e.type === opts.type);
+      if (opts.domain) arr = arr.filter((e) => e.domain === opts.domain);
+      return arr.slice(0, opts.limit ?? 50);
+    },
+    get: (id: string) => entries.get(id) ?? null,
+    add: (entry: { id: string; type: string; title: string; description: string; domain?: string; context?: string; tags?: string[]; severity?: string }) => {
+      entries.set(entry.id, entry);
+    },
+    _entries: entries,
+  };
+}
+
+/** Minimal playbook executor stub. */
+function makePlaybookExecutorStub() {
+  const sessions = new Map<string, { id: string; step: number; completed: boolean }>();
+  return {
+    start: vi.fn((def: { id: string; title: string }) => {
+      const sessionId = `session-${def.id}`;
+      sessions.set(sessionId, { id: sessionId, step: 0, completed: false });
+      return { sessionId, currentStep: 0, playbook: def };
+    }),
+    step: vi.fn((sessionId: string, opts: { output?: string; skip?: boolean }) => {
+      const session = sessions.get(sessionId);
+      if (!session) return { error: `Session not found: ${sessionId}` };
+      session.step++;
+      return { sessionId, currentStep: session.step, skipped: opts.skip ?? false };
+    }),
+    complete: vi.fn((sessionId: string, opts: { abort?: boolean }) => {
+      const session = sessions.get(sessionId);
+      if (!session) return { error: `Session not found: ${sessionId}` };
+      session.completed = true;
+      return { sessionId, status: opts.abort ? 'aborted' : 'completed' };
+    }),
+  };
+}
+
+describe('playbook-ops', () => {
+  function setup() {
+    const vault = makeVaultStub();
+    const playbookExecutor = makePlaybookExecutorStub();
+    const ops = captureOps(
+      createPlaybookOps({ vault, playbookExecutor } as unknown as AgentRuntime),
+    );
+    return { vault, playbookExecutor, ops };
+  }
+
+  describe('playbook_list', () => {
+    it('returns empty list when no playbooks exist', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_list', {});
+      expect(res.success).toBe(true);
+      const data = res.data as { playbooks: unknown[]; count: number };
+      expect(data.count).toBe(0);
+      expect(data.playbooks).toEqual([]);
+    });
+
+    it('lists playbook entries from vault', async () => {
+      const { ops, vault } = setup();
+      vault.add({
+        id: 'playbook-test-1',
+        type: 'playbook',
+        domain: 'testing',
+        title: 'TDD Workflow',
+        description: 'Test-driven development playbook',
+        context: JSON.stringify({ steps: [{ order: 1, title: 'Write test', description: 'Write failing test' }] }),
+        tags: ['tdd'],
+      });
+
+      const res = await executeOp(ops, 'playbook_list', {});
+      expect(res.success).toBe(true);
+      // parsePlaybookFromEntry may return null if format doesn't match exactly,
+      // but we verify the op runs without error
+    });
+  });
+
+  describe('playbook_get', () => {
+    it('returns error for missing playbook', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_get', { id: 'nonexistent' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('returns error for non-playbook entry', async () => {
+      const { ops, vault } = setup();
+      vault.add({ id: 'entry-1', type: 'pattern', title: 'Not a playbook', description: 'nope' });
+
+      const res = await executeOp(ops, 'playbook_get', { id: 'entry-1' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not a playbook');
+    });
+  });
+
+  describe('playbook_create', () => {
+    it('creates a playbook with valid steps', async () => {
+      const { ops, vault } = setup();
+      const res = await executeOp(ops, 'playbook_create', {
+        title: 'My Playbook',
+        domain: 'testing',
+        description: 'A test playbook',
+        steps: [
+          { title: 'Step 1', description: 'Do first thing' },
+          { title: 'Step 2', description: 'Do second thing' },
+        ],
+        tags: ['test'],
+      });
+
+      expect(res.success).toBe(true);
+      const data = res.data as { created: boolean; id: string; steps: number };
+      expect(data.created).toBe(true);
+      expect(data.steps).toBe(2);
+      expect(data.id).toMatch(/^playbook-testing-/);
+      // Verify stored in vault
+      expect(vault._entries.has(data.id)).toBe(true);
+    });
+
+    it('uses provided id when given', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_create', {
+        id: 'custom-id',
+        title: 'Custom',
+        domain: 'dev',
+        description: 'Custom ID playbook',
+        steps: [{ title: 'Step', description: 'Do it' }],
+      });
+      expect((res.data as { id: string }).id).toBe('custom-id');
+    });
+  });
+
+  describe('playbook_match', () => {
+    it('returns match result for text query', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_match', {
+        text: 'I need to debug a performance issue',
+        intent: 'FIX',
+      });
+      // Even with no vault playbooks, matchPlaybooks should return built-in matches
+      expect(res.success).toBe(true);
+    });
+
+    it('handles text-only match without intent', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_match', { text: 'build a component' });
+      expect(res.success).toBe(true);
+    });
+  });
+
+  describe('playbook_seed', () => {
+    it('seeds default playbooks', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_seed');
+      expect(res.success).toBe(true);
+      // seedDefaultPlaybooks returns { seeded, skipped, errors }
+      const data = res.data as { seeded: number; skipped: number };
+      expect(typeof data.seeded).toBe('number');
+    });
+  });
+
+  describe('playbook_start', () => {
+    it('returns error when neither playbookId nor intent provided', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', {});
+      expect(res.success).toBe(true);
+      const data = res.data as { error: string; available: unknown[] };
+      expect(data.error).toContain('Provide playbookId or intent');
+      expect(data.available).toBeDefined();
+    });
+
+    it('returns error for unknown playbookId', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', { playbookId: 'nonexistent' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('starts a built-in playbook by id', async () => {
+      const { ops, playbookExecutor } = setup();
+      // Built-in playbooks: tdd, brainstorming, code-review, subagent-execution, debugging, verification
+      const res = await executeOp(ops, 'playbook_start', { playbookId: 'tdd' });
+      expect(res.success).toBe(true);
+      if (!(res.data as { error?: string }).error) {
+        expect(playbookExecutor.start).toHaveBeenCalled();
+      }
+    });
+
+    it('auto-matches by intent and text', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', { intent: 'FIX', text: 'debug crash' });
+      expect(res.success).toBe(true);
+      // Either starts a matched playbook or returns "no matching playbook"
+    });
+  });
+
+  describe('playbook_step', () => {
+    it('delegates to executor step', async () => {
+      const { ops, playbookExecutor } = setup();
+      const res = await executeOp(ops, 'playbook_step', {
+        sessionId: 'test-session',
+        output: 'Did the thing',
+      });
+      expect(res.success).toBe(true);
+      expect(playbookExecutor.step).toHaveBeenCalledWith('test-session', {
+        output: 'Did the thing',
+        skip: undefined,
+      });
+    });
+
+    it('supports skip option', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_step', { sessionId: 's1', skip: true });
+      expect(playbookExecutor.step).toHaveBeenCalledWith('s1', { output: undefined, skip: true });
+    });
+  });
+
+  describe('playbook_complete', () => {
+    it('delegates to executor complete', async () => {
+      const { ops, playbookExecutor } = setup();
+      const res = await executeOp(ops, 'playbook_complete', { sessionId: 's1' });
+      expect(res.success).toBe(true);
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: undefined,
+        gateResults: undefined,
+      });
+    });
+
+    it('supports abort option', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_complete', { sessionId: 's1', abort: true });
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: true,
+        gateResults: undefined,
+      });
+    });
+
+    it('passes gate results', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_complete', {
+        sessionId: 's1',
+        gateResults: { 'tests-pass': true, 'lint-clean': false },
+      });
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: undefined,
+        gateResults: { 'tests-pass': true, 'lint-clean': false },
+      });
+    });
+  });
+});

package/src/runtime/plugin-ops.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Unit tests for plugin-ops — 5 ops for runtime plugin management.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createPluginOps } from './plugin-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+/** Minimal plugin registry stub. */
+function makePluginRegistryStub() {
+  const plugins = new Map<string, {
+    id: string;
+    manifest: { id: string; name: string; version: string; domain: string; description: string; dependencies: string[]; intelligence: unknown[] };
+    status: string;
+    provenance: string;
+    directory: string;
+    error?: string;
+    facades: Array<{ name: string; description: string; ops: OpDefinition[] }>;
+    registeredAt: number;
+    activatedAt?: number;
+  }>();
+
+  return {
+    get: (id: string) => plugins.get(id) ?? null,
+    list: () => [...plugins.values()],
+    register: vi.fn((plugin: { manifest: { id: string } }) => {
+      const existing = plugins.get(plugin.manifest.id);
+      if (existing) throw new Error(`Already registered: ${plugin.manifest.id}`);
+      plugins.set(plugin.manifest.id, plugin as never);
+    }),
+    activate: vi.fn(async (pluginId: string, _ctx: unknown) => {
+      const plugin = plugins.get(pluginId);
+      if (!plugin) return { id: pluginId, status: 'error', error: 'Not found', facades: [] };
+      plugin.status = 'active';
+      plugin.activatedAt = Date.now();
+      return { id: pluginId, status: 'active', facades: plugin.facades, error: undefined };
+    }),
+    deactivate: vi.fn((pluginId: string) => {
+      const plugin = plugins.get(pluginId);
+      if (!plugin) return false;
+      plugin.status = 'registered';
+      return true;
+    }),
+    _seed: (id: string, overrides?: Partial<{ status: string; facades: Array<{ name: string; description: string; ops: OpDefinition[] }> }>) => {
+      plugins.set(id, {
+        id,
+        manifest: { id, name: `Plugin ${id}`, version: '1.0.0', domain: 'test', description: 'Test plugin', dependencies: [], intelligence: [] },
+        status: overrides?.status ?? 'registered',
+        provenance: 'local',
+        directory: `/plugins/${id}`,
+        facades: overrides?.facades ?? [],
+        registeredAt: Date.now(),
+      });
+    },
+  };
+}
+
+describe('plugin-ops', () => {
+  function setup(opts?: { opSink?: OpDefinition[] }) {
+    const pluginRegistry = makePluginRegistryStub();
+    const config = { agentId: 'test-agent' };
+    const opSink = opts?.opSink;
+    const ops = captureOps(
+      createPluginOps(
+        { pluginRegistry, config } as unknown as AgentRuntime,
+        opSink,
+      ),
+    );
+    return { pluginRegistry, ops, opSink };
+  }
+
+  describe('plugin_list', () => {
+    it('returns empty when no plugins registered', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_list');
+      expect(res.success).toBe(true);
+      const data = res.data as { plugins: unknown[]; count: number; active: number };
+      expect(data.count).toBe(0);
+      expect(data.active).toBe(0);
+    });
+
+    it('lists registered plugins with status', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('plug-a', { status: 'active', facades: [{ name: 'f1', description: 'F1', ops: [{ name: 'op1', handler: async () => ({}), auth: 'read', description: '' }] }] });
+      pluginRegistry._seed('plug-b', { status: 'registered' });
+
+      const res = await executeOp(ops, 'plugin_list');
+      const data = res.data as { count: number; active: number; plugins: Array<{ id: string; status: string; facades: number; ops: number }> };
+      expect(data.count).toBe(2);
+      expect(data.active).toBe(1);
+      expect(data.plugins[0].facades).toBe(1);
+      expect(data.plugins[0].ops).toBe(1);
+    });
+  });
+
+  describe('plugin_status', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_status', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('returns detailed status for existing plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('my-plug');
+
+      const res = await executeOp(ops, 'plugin_status', { pluginId: 'my-plug' });
+      const data = res.data as { id: string; name: string; version: string; status: string; directory: string };
+      expect(data.id).toBe('my-plug');
+      expect(data.version).toBe('1.0.0');
+      expect(data.directory).toBe('/plugins/my-plug');
+    });
+  });
+
+  describe('plugin_activate', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_activate', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('activates a specific plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('plug-a', { facades: [] });
+
+      const res = await executeOp(ops, 'plugin_activate', { pluginId: 'plug-a' });
+      expect(res.success).toBe(true);
+      const data = res.data as { id: string; status: string };
+      expect(data.status).toBe('active');
+      expect(pluginRegistry.activate).toHaveBeenCalled();
+    });
+
+    it('activates all registered (non-active) plugins when no pluginId', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('p1', { status: 'registered', facades: [] });
+      pluginRegistry._seed('p2', { status: 'registered', facades: [] });
+
+      const res = await executeOp(ops, 'plugin_activate', {});
+      const data = res.data as { activated: number; results: Array<{ id: string; status: string }> };
+      expect(data.activated).toBe(2);
+      expect(data.results).toHaveLength(2);
+    });
+
+    it('injects plugin ops into opSink on activation', async () => {
+      const opSink: OpDefinition[] = [];
+      const { ops, pluginRegistry } = setup({ opSink });
+      const testOp: OpDefinition = { name: 'injected_op', handler: async () => 'hi', auth: 'read', description: 'test' };
+      pluginRegistry._seed('plug-inject', { facades: [{ name: 'test-facade', description: 'TF', ops: [testOp] }] });
+
+      await executeOp(ops, 'plugin_activate', { pluginId: 'plug-inject' });
+      expect(opSink.some((o) => o.name === 'injected_op')).toBe(true);
+    });
+  });
+
+  describe('plugin_deactivate', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_deactivate', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('deactivates an active plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('d-plug', { status: 'active' });
+
+      const res = await executeOp(ops, 'plugin_deactivate', { pluginId: 'd-plug' });
+      const data = res.data as { deactivated: boolean; removedOps: number };
+      expect(data.deactivated).toBe(true);
+      expect(pluginRegistry.deactivate).toHaveBeenCalledWith('d-plug');
+    });
+
+    it('removes injected ops from opSink on deactivation', async () => {
+      const opSink: OpDefinition[] = [];
+      const { ops, pluginRegistry } = setup({ opSink });
+      const testOp: OpDefinition = { name: 'to_remove', handler: async () => 'hi', auth: 'read', description: 'test' };
+      pluginRegistry._seed('plug-rm', { facades: [{ name: 'f', description: 'F', ops: [testOp] }] });
+
+      await executeOp(ops, 'plugin_activate', { pluginId: 'plug-rm' });
+      expect(opSink.some((o) => o.name === 'to_remove')).toBe(true);
+
+      await executeOp(ops, 'plugin_deactivate', { pluginId: 'plug-rm' });
+      expect(opSink.some((o) => o.name === 'to_remove')).toBe(false);
+    });
+  });
+
+  describe('plugin_load', () => {
+    it('runs without crashing (loadPlugins scans filesystem)', async () => {
+      const { ops } = setup();
+      // loadPlugins scans directories — with non-existent paths it returns empty
+      const res = await executeOp(ops, 'plugin_load', { projectPath: '/nonexistent' });
+      expect(res.success).toBe(true);
+      const data = res.data as { registered: string[]; registeredCount: number };
+      expect(data.registeredCount).toBe(0);
+    });
+  });
+});