@soleri/core 9.0.4 → 9.2.0

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

@@ -0,0 +1,268 @@
+/**
+ * Colocated unit tests for domain-ops.ts — mock-based, no real DB.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createDomainFacade, createDomainFacades } from './domain-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { DomainPack } from '../domain-packs/types.js';
+
+function mockRuntime() {
+  return {
+    vault: {
+      list: vi.fn().mockReturnValue([]),
+      search: vi.fn().mockReturnValue([]),
+      get: vi.fn().mockReturnValue(null),
+      remove: vi.fn().mockReturnValue(true),
+    },
+    brain: {
+      intelligentSearch: vi.fn().mockResolvedValue([]),
+      enrichAndCapture: vi.fn().mockReturnValue({ captured: true, id: 'cap-1', autoTags: [] }),
+    },
+    governance: {
+      evaluateCapture: vi.fn().mockReturnValue({ action: 'capture' }),
+      propose: vi.fn().mockReturnValue(1),
+    },
+  } as unknown as AgentRuntime;
+}
+
+describe('createDomainFacade', () => {
+  it('creates a facade with correct name for simple domain', () => {
+    const facade = createDomainFacade(mockRuntime(), 'agent1', 'security');
+    expect(facade.name).toBe('agent1_security');
+  });
+
+  it('replaces hyphens with underscores in facade name', () => {
+    const facade = createDomainFacade(mockRuntime(), 'agent1', 'api-design');
+    expect(facade.name).toBe('agent1_api_design');
+  });
+
+  it('capitalizes domain in description', () => {
+    const facade = createDomainFacade(mockRuntime(), 'agent1', 'security');
+    expect(facade.description).toContain('Security');
+  });
+
+  it('creates exactly 5 standard ops', () => {
+    const facade = createDomainFacade(mockRuntime(), 'agent1', 'testing');
+    expect(facade.ops).toHaveLength(5);
+    expect(facade.ops.map((o) => o.name)).toEqual([
+      'get_patterns',
+      'search',
+      'get_entry',
+      'capture',
+      'remove',
+    ]);
+  });
+
+  describe('get_patterns', () => {
+    it('scopes list call to domain', async () => {
+      const rt = mockRuntime();
+      const facade = createDomainFacade(rt, 'a', 'security');
+      const op = facade.ops.find((o) => o.name === 'get_patterns')!;
+      await op.handler({ tags: ['auth'], severity: 'critical', limit: 5 });
+      expect(rt.vault.list).toHaveBeenCalledWith({
+        domain: 'security',
+        severity: 'critical',
+        type: undefined,
+        tags: ['auth'],
+        limit: 5,
+      });
+    });
+
+    it('defaults limit to 20', async () => {
+      const rt = mockRuntime();
+      const facade = createDomainFacade(rt, 'a', 'testing');
+      await facade.ops.find((o) => o.name === 'get_patterns')!.handler({});
+      const args = (rt.vault.list as ReturnType<typeof vi.fn>).mock.calls[0][0];
+      expect(args.limit).toBe(20);
+    });
+  });
+
+  describe('search', () => {
+    it('uses brain.intelligentSearch scoped to domain', async () => {
+      const rt = mockRuntime();
+      (rt.brain.intelligentSearch as ReturnType<typeof vi.fn>).mockResolvedValue([{ entry: {} }]);
+      const facade = createDomainFacade(rt, 'a', 'security');
+      await facade.ops.find((o) => o.name === 'search')!.handler({ query: 'auth patterns' });
+      expect(rt.brain.intelligentSearch).toHaveBeenCalledWith('auth patterns', {
+        domain: 'security',
+        tags: undefined,
+        limit: 10,
+      });
+    });
+
+    it('falls back to vault FTS when brain returns empty', async () => {
+      const rt = mockRuntime();
+      (rt.brain.intelligentSearch as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+      (rt.vault.search as ReturnType<typeof vi.fn>).mockReturnValue([
+        { entry: { id: 'e1' } },
+      ]);
+      const facade = createDomainFacade(rt, 'a', 'security');
+      const results = (await facade.ops.find((o) => o.name === 'search')!.handler({
+        query: 'test',
+      })) as unknown[];
+      expect(rt.vault.search).toHaveBeenCalledWith('test', { domain: 'security', limit: 10 });
+      expect(results).toHaveLength(1);
+    });
+  });
+
+  describe('get_entry', () => {
+    it('returns entry from vault', async () => {
+      const rt = mockRuntime();
+      (rt.vault.get as ReturnType<typeof vi.fn>).mockReturnValue({ id: 'x', title: 'Found' });
+      const facade = createDomainFacade(rt, 'a', 'testing');
+      const result = await facade.ops.find((o) => o.name === 'get_entry')!.handler({ id: 'x' });
+      expect(result).toEqual({ id: 'x', title: 'Found' });
+    });
+
+    it('returns error object for missing entry', async () => {
+      const rt = mockRuntime();
+      const facade = createDomainFacade(rt, 'a', 'testing');
+      const result = (await facade.ops.find((o) => o.name === 'get_entry')!.handler({
+        id: 'missing',
+      })) as { error: string };
+      expect(result.error).toContain('missing');
+    });
+  });
+
+  describe('capture', () => {
+    it('calls brain.enrichAndCapture when governance allows', async () => {
+      const rt = mockRuntime();
+      const facade = createDomainFacade(rt, 'a', 'security');
+      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
+        id: 'new-1',
+        type: 'pattern',
+        title: 'Test',
+        severity: 'warning',
+        description: 'desc',
+        tags: ['x'],
+      })) as { captured: boolean; governance: { action: string } };
+      expect(rt.brain.enrichAndCapture).toHaveBeenCalledOnce();
+      expect(result.governance.action).toBe('capture');
+    });
+
+    it('creates proposal when governance says propose', async () => {
+      const rt = mockRuntime();
+      (rt.governance.evaluateCapture as ReturnType<typeof vi.fn>).mockReturnValue({
+        action: 'propose',
+        reason: 'needs review',
+      });
+      const facade = createDomainFacade(rt, 'a', 'security');
+      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
+        id: 'p1',
+        type: 'pattern',
+        title: 'Proposed',
+        severity: 'warning',
+        description: 'desc',
+        tags: [],
+      })) as { captured: boolean; governance: { action: string; proposalId: number } };
+      expect(result.captured).toBe(false);
+      expect(result.governance.action).toBe('propose');
+      expect(result.governance.proposalId).toBe(1);
+    });
+
+    it('returns reject for rejected captures', async () => {
+      const rt = mockRuntime();
+      (rt.governance.evaluateCapture as ReturnType<typeof vi.fn>).mockReturnValue({
+        action: 'reject',
+        reason: 'quota exceeded',
+      });
+      const facade = createDomainFacade(rt, 'a', 'security');
+      const result = (await facade.ops.find((o) => o.name === 'capture')!.handler({
+        id: 'r1',
+        type: 'rule',
+        title: 'Rejected',
+        severity: 'warning',
+        description: 'desc',
+        tags: [],
+      })) as { captured: boolean; governance: { action: string; reason: string } };
+      expect(result.captured).toBe(false);
+      expect(result.governance.action).toBe('reject');
+      expect(result.governance.reason).toBe('quota exceeded');
+    });
+  });
+
+  describe('remove', () => {
+    it('returns removed status', async () => {
+      const rt = mockRuntime();
+      const facade = createDomainFacade(rt, 'a', 'testing');
+      const result = (await facade.ops.find((o) => o.name === 'remove')!.handler({
+        id: 'del-1',
+      })) as { removed: boolean; id: string };
+      expect(result.removed).toBe(true);
+      expect(result.id).toBe('del-1');
+    });
+
+    it('has admin auth', () => {
+      const facade = createDomainFacade(mockRuntime(), 'a', 'testing');
+      expect(facade.ops.find((o) => o.name === 'remove')!.auth).toBe('admin');
+    });
+  });
+});
+
+describe('createDomainFacades', () => {
+  it('creates one facade per domain', () => {
+    const facades = createDomainFacades(mockRuntime(), 'ag', ['a', 'b', 'c']);
+    expect(facades).toHaveLength(3);
+    expect(facades.map((f) => f.name)).toEqual(['ag_a', 'ag_b', 'ag_c']);
+  });
+
+  it('returns empty array for empty domains', () => {
+    expect(createDomainFacades(mockRuntime(), 'ag', [])).toEqual([]);
+  });
+
+  describe('with domain packs', () => {
+    it('merges pack ops with standard ops (pack ops take priority)', () => {
+      const packOp = {
+        name: 'search',
+        description: 'Custom search',
+        auth: 'read' as const,
+        handler: vi.fn(),
+      };
+      const pack: DomainPack = {
+        name: 'test-pack',
+        version: '1.0.0',
+        domains: ['security'],
+        ops: [packOp],
+      };
+      const facades = createDomainFacades(mockRuntime(), 'ag', ['security'], [pack]);
+      const secFacade = facades.find((f) => f.name === 'ag_security')!;
+      const searchOp = secFacade.ops.find((o) => o.name === 'search')!;
+      expect(searchOp.handler).toBe(packOp.handler);
+      // Standard ops that aren't overridden should still be present
+      expect(secFacade.ops.some((o) => o.name === 'get_patterns')).toBe(true);
+    });
+
+    it('adds standalone facades with agentId prefix', () => {
+      const standaloneFacade = {
+        name: 'color_check',
+        description: 'Color tools',
+        ops: [{ name: 'check', description: 'Check', auth: 'read' as const, handler: vi.fn() }],
+      };
+      const pack: DomainPack = {
+        name: 'design-pack',
+        version: '1.0.0',
+        domains: ['design'],
+        ops: [],
+        facades: [standaloneFacade],
+      };
+      const facades = createDomainFacades(mockRuntime(), 'ag', ['design'], [pack]);
+      const standalone = facades.find((f) => f.name === 'ag_color_check');
+      expect(standalone).toBeDefined();
+    });
+
+    it('does not affect unclaimed domains', () => {
+      const pack: DomainPack = {
+        name: 'only-security',
+        version: '1.0.0',
+        domains: ['security'],
+        ops: [{ name: 'custom', description: 'X', auth: 'read' as const, handler: vi.fn() }],
+      };
+      const facades = createDomainFacades(mockRuntime(), 'ag', ['security', 'testing'], [pack]);
+      const testingFacade = facades.find((f) => f.name === 'ag_testing')!;
+      // Testing domain should have standard 5 ops only
+      expect(testingFacade.ops).toHaveLength(5);
+      expect(testingFacade.ops.some((o) => o.name === 'custom')).toBe(false);
+    });
+  });
+});

package/src/runtime/facades/admin-facade.test.ts

@@ -0,0 +1,333 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createAdminFacadeOps } from './admin-facade.js';
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+
+function mockRuntime(): AgentRuntime {
+  return {
+    config: {
+      agentId: 'test-agent',
+      vaultPath: ':memory:',
+      plansPath: '/tmp/plans.json',
+      logLevel: 'info',
+    },
+    llmClient: {
+      complete: vi.fn(),
+      isAvailable: vi.fn().mockReturnValue({ openai: true, anthropic: false }),
+    },
+    keyPool: {
+      openai: {
+        hasKeys: true,
+        rotateOnError: vi.fn().mockReturnValue('new-key'),
+        activeKeyIndex: 1,
+        poolSize: 3,
+        exhausted: false,
+      },
+      anthropic: {
+        hasKeys: false,
+        rotateOnError: vi.fn().mockReturnValue(null),
+        activeKeyIndex: 0,
+        poolSize: 0,
+        exhausted: true,
+      },
+    },
+    templateManager: {
+      render: vi.fn().mockReturnValue('rendered template'),
+      listTemplates: vi.fn().mockReturnValue(['greeting', 'summary']),
+      load: vi.fn(),
+    },
+    vault: {
+      stats: vi.fn().mockReturnValue({ totalEntries: 10, byDomain: { core: 5, design: 5 } }),
+      getDb: vi.fn(),
+      getDomains: vi.fn().mockReturnValue([]),
+      list: vi.fn().mockReturnValue([]),
+      add: vi.fn(),
+      remove: vi.fn(),
+      get: vi.fn(),
+      rebuildFtsIndex: vi.fn(),
+      getProvider: vi.fn().mockReturnValue({ backend: 'sqlite', get: vi.fn() }),
+    },
+    brain: {
+      getStats: vi.fn().mockReturnValue({ vocabularySize: 100, feedbackCount: 50 }),
+      rebuildVocabulary: vi.fn(),
+      getFeedbackStats: vi.fn().mockReturnValue({
+        total: 10,
+        byAction: { dismissed: 2, failed: 1 },
+      }),
+    },
+    brainIntelligence: {
+      getStats: vi.fn().mockReturnValue({ strengths: 5, sessions: 10 }),
+    },
+    curator: {
+      getStatus: vi.fn().mockReturnValue({ initialized: true }),
+    },
+    telemetry: {
+      getStats: vi.fn().mockReturnValue({ totalCalls: 100 }),
+      getRecent: vi.fn().mockReturnValue([]),
+      reset: vi.fn(),
+    },
+    loop: {
+      getStatus: vi.fn().mockReturnValue(null),
+    },
+    contextHealth: {
+      check: vi.fn().mockReturnValue({ level: 'green', estimatedFill: 0 }),
+    },
+    authPolicy: { mode: 'permissive', callerLevel: 'admin' },
+    flags: {
+      getAll: vi.fn().mockReturnValue({}),
+      set: vi.fn(),
+    },
+    health: {
+      snapshot: vi.fn().mockReturnValue({ overall: 'healthy', subsystems: {} }),
+      get: vi.fn(),
+    },
+    pluginRegistry: {
+      get: vi.fn(),
+    },
+    packInstaller: {},
+    createdAt: Date.now() - 60000,
+    persona: { name: 'TestAgent' },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op "${name}" not found among: ${ops.map((o) => o.name).join(', ')}`);
+  return op;
+}
+
+describe('createAdminFacadeOps', () => {
+  let runtime: ReturnType<typeof mockRuntime>;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    runtime = mockRuntime();
+    ops = createAdminFacadeOps(runtime);
+  });
+
+  it('returns inline ops (llm_rotate, llm_call, render_prompt, list_templates)', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('llm_rotate');
+    expect(names).toContain('llm_call');
+    expect(names).toContain('render_prompt');
+    expect(names).toContain('list_templates');
+  });
+
+  it('includes satellite ops from admin-ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('admin_health');
+    expect(names).toContain('admin_diagnostic');
+    expect(names).toContain('admin_config');
+  });
+
+  it('includes satellite ops from admin-extra-ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('admin_telemetry');
+    expect(names).toContain('admin_permissions');
+    expect(names).toContain('admin_vault_analytics');
+  });
+
+  it('includes satellite ops from admin-setup-ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('admin_inject_claude_md');
+    expect(names).toContain('admin_setup_global');
+    expect(names).toContain('admin_check_persistence');
+  });
+
+  it('includes session briefing ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toContain('session_briefing');
+  });
+
+  describe('llm_rotate', () => {
+    it('rotates openai key pool', async () => {
+      const result = (await findOp(ops, 'llm_rotate').handler({
+        provider: 'openai',
+      })) as Record<string, unknown>;
+      expect(result.rotated).toBe(true);
+      expect(result.activeKeyIndex).toBe(1);
+      expect(result.poolSize).toBe(3);
+    });
+
+    it('returns error when provider has no keys', async () => {
+      const result = (await findOp(ops, 'llm_rotate').handler({
+        provider: 'anthropic',
+      })) as Record<string, unknown>;
+      expect(result.rotated).toBe(false);
+      expect(result.error).toContain('No anthropic keys');
+    });
+  });
+
+  describe('llm_call', () => {
+    it('calls LLM with provided params', async () => {
+      vi.mocked(runtime.llmClient.complete).mockResolvedValue({ text: 'Hello' } as never);
+
+      const result = await findOp(ops, 'llm_call').handler({
+        systemPrompt: 'You are helpful',
+        userPrompt: 'Say hello',
+        temperature: 0.5,
+        maxTokens: 100,
+      });
+      expect(result).toEqual({ text: 'Hello' });
+      expect(runtime.llmClient.complete).toHaveBeenCalledWith(
+        expect.objectContaining({
+          systemPrompt: 'You are helpful',
+          userPrompt: 'Say hello',
+          temperature: 0.5,
+          maxTokens: 100,
+          caller: 'core-ops',
+        }),
+      );
+    });
+
+    it('defaults caller to core-ops', async () => {
+      vi.mocked(runtime.llmClient.complete).mockResolvedValue({} as never);
+
+      await findOp(ops, 'llm_call').handler({
+        systemPrompt: 'sys',
+        userPrompt: 'usr',
+      });
+      expect(runtime.llmClient.complete).toHaveBeenCalledWith(
+        expect.objectContaining({ caller: 'core-ops' }),
+      );
+    });
+  });
+
+  describe('render_prompt', () => {
+    it('renders template with variables', async () => {
+      const result = (await findOp(ops, 'render_prompt').handler({
+        template: 'greeting',
+        variables: { name: 'World' },
+        strict: true,
+      })) as Record<string, unknown>;
+      expect(result.rendered).toBe('rendered template');
+      expect(runtime.templateManager.render).toHaveBeenCalledWith(
+        'greeting',
+        { name: 'World' },
+        { strict: true },
+      );
+    });
+
+    it('defaults to empty variables', async () => {
+      await findOp(ops, 'render_prompt').handler({ template: 'summary' });
+      expect(runtime.templateManager.render).toHaveBeenCalledWith(
+        'summary',
+        expect.any(Object),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe('list_templates', () => {
+    it('returns template list', async () => {
+      const result = (await findOp(ops, 'list_templates').handler({})) as Record<string, unknown>;
+      expect(result.templates).toEqual(['greeting', 'summary']);
+    });
+  });
+
+  describe('admin_health (from satellite)', () => {
+    it('returns health status', async () => {
+      const result = (await findOp(ops, 'admin_health').handler({})) as Record<string, unknown>;
+      expect(result.status).toBe('ok');
+      expect(result.vault).toBeDefined();
+      expect(result.brain).toBeDefined();
+    });
+  });
+
+  describe('admin_config (from satellite)', () => {
+    it('returns runtime config', async () => {
+      const result = (await findOp(ops, 'admin_config').handler({})) as Record<string, unknown>;
+      expect(result.agentId).toBe('test-agent');
+      expect(result.logLevel).toBe('info');
+    });
+  });
+
+  describe('admin_vault_size (from satellite)', () => {
+    it('returns in-memory for :memory: vault', async () => {
+      const result = (await findOp(ops, 'admin_vault_size').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.path).toBe(':memory:');
+      expect(result.sizeHuman).toBe('in-memory');
+    });
+  });
+
+  describe('admin_uptime (from satellite)', () => {
+    it('returns uptime info', async () => {
+      const result = (await findOp(ops, 'admin_uptime').handler({})) as Record<string, unknown>;
+      expect(result.uptimeMs).toBeGreaterThan(0);
+      expect(result.createdAt).toBeDefined();
+    });
+  });
+
+  describe('admin_version (from satellite)', () => {
+    it('returns version info', async () => {
+      const result = (await findOp(ops, 'admin_version').handler({})) as Record<string, unknown>;
+      expect(result.node).toBe(process.version);
+      expect(result.platform).toBe(process.platform);
+    });
+  });
+
+  describe('context_health (from satellite)', () => {
+    it('returns context health', async () => {
+      const result = (await findOp(ops, 'context_health').handler({})) as Record<string, unknown>;
+      expect(result.level).toBe('green');
+    });
+  });
+
+  describe('admin_reset_cache (from satellite)', () => {
+    it('clears brain vocabulary', async () => {
+      const result = (await findOp(ops, 'admin_reset_cache').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.cleared).toContain('brain_vocabulary');
+      expect(runtime.brain.rebuildVocabulary).toHaveBeenCalled();
+    });
+  });
+
+  describe('admin_telemetry (from admin-extra)', () => {
+    it('returns telemetry stats', async () => {
+      const result = (await findOp(ops, 'admin_telemetry').handler({})) as Record<string, unknown>;
+      expect(result.totalCalls).toBe(100);
+    });
+  });
+
+  describe('admin_permissions (from admin-extra)', () => {
+    it('gets current permissions', async () => {
+      const result = (await findOp(ops, 'admin_permissions').handler({
+        action: 'get',
+      })) as Record<string, unknown>;
+      expect(result.authPolicy).toBeDefined();
+    });
+
+    it('sets permissions', async () => {
+      const result = (await findOp(ops, 'admin_permissions').handler({
+        action: 'set',
+        mode: 'enforce',
+        callerLevel: 'write',
+      })) as Record<string, unknown>;
+      expect(runtime.authPolicy.mode).toBe('enforce');
+      expect(runtime.authPolicy.callerLevel).toBe('write');
+      expect(result.level).toBe('strict');
+    });
+  });
+
+  describe('admin_health_snapshot (from admin-extra)', () => {
+    it('returns health snapshot', async () => {
+      const result = (await findOp(ops, 'admin_health_snapshot').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.overall).toBe('healthy');
+    });
+  });
+
+  describe('admin_list_flags (from admin-extra)', () => {
+    it('returns feature flags', async () => {
+      const result = await findOp(ops, 'admin_list_flags').handler({});
+      expect(result).toEqual({});
+    });
+  });
+});