@soleri/core 9.0.4 → 9.2.0

package/src/__tests__/domain-packs.test.ts

@@ -1,421 +0,0 @@
-/**
- * Domain Packs — failing tests for the DomainPack primitive.
- *
- * These tests define the contract for domain packs:
- * - DomainPack types and validation
- * - Pack loading and dependency resolution
- * - Extended createDomainFacades() with pack support
- * - OCP: standard domains unchanged when packs are absent
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createDomainFacade, createDomainFacades } from '../runtime/domain-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import { z } from 'zod';
-
-import type { DomainPack } from '../domain-packs/types.js';
-import { validateDomainPack, SEMANTIC_FACADE_NAMES } from '../domain-packs/types.js';
-import { resolveDependencies } from '../domain-packs/loader.js';
-
-// ---------------------------------------------------------------------------
-// Helpers: mock domain packs for testing
-// ---------------------------------------------------------------------------
-
-function createMockPack(overrides: Partial<DomainPack> = {}): DomainPack {
-  return {
-    name: 'test-design',
-    version: '1.0.0',
-    domains: ['design'],
-    ops: [
-      {
-        name: 'check_contrast',
-        description: 'Check WCAG contrast ratio between two colors.',
-        auth: 'read' as const,
-        schema: z.object({
-          foreground: z.string(),
-          background: z.string(),
-        }),
-        handler: async (_params) => {
-          return { ratio: 4.5, passes: true, level: 'AA' };
-        },
-      },
-      {
-        name: 'validate_token',
-        description: 'Validate a design token name against the token schema.',
-        auth: 'read' as const,
-        schema: z.object({ token: z.string() }),
-        handler: async (params) => {
-          return { valid: true, token: params.token };
-        },
-      },
-      {
-        name: 'get_color_pairs',
-        description: 'Get accessible color pair suggestions.',
-        auth: 'read' as const,
-        schema: z.object({ background: z.string() }),
-        handler: async (params) => {
-          return { pairs: [{ fg: '#000', bg: params.background, ratio: 21 }] };
-        },
-      },
-    ],
-    ...overrides,
-  };
-}
-
-function createMockPackWithFacades(): DomainPack {
-  return {
-    name: 'test-design-full',
-    version: '1.0.0',
-    domains: ['design'],
-    ops: [
-      {
-        name: 'check_contrast',
-        description: 'Check contrast.',
-        auth: 'read' as const,
-        handler: async () => ({ ratio: 4.5 }),
-      },
-    ],
-    facades: [
-      {
-        name: 'design_rules',
-        description: 'Design rules and guidelines.',
-        ops: [
-          {
-            name: 'get_clean_code_rules',
-            description: 'Get clean code rules for design.',
-            auth: 'read' as const,
-            handler: async () => ({ rules: ['no-hex-colors', 'semantic-tokens-only'] }),
-          },
-          {
-            name: 'get_architecture_patterns',
-            description: 'Get architecture patterns.',
-            auth: 'read' as const,
-            handler: async () => ({ patterns: ['component-composition'] }),
-          },
-        ],
-      },
-    ],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 1. DomainPack Types & Validation
-// ---------------------------------------------------------------------------
-
-describe('DomainPack types and validation', () => {
-  it('should validate a well-formed domain pack', () => {
-    const pack = createMockPack();
-    const result = validateDomainPack(pack);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.name).toBe('test-design');
-      expect(result.data.ops.length).toBe(3);
-    }
-  });
-
-  it('should reject pack with missing required fields', () => {
-    const result = validateDomainPack({ name: 'incomplete' });
-    expect(result.success).toBe(false);
-  });
-
-  it('should reject pack with duplicate op names', () => {
-    const pack = createMockPack({
-      ops: [
-        {
-          name: 'duplicate_op',
-          description: 'First.',
-          auth: 'read',
-          handler: async () => ({}),
-        },
-        {
-          name: 'duplicate_op',
-          description: 'Second.',
-          auth: 'read',
-          handler: async () => ({}),
-        },
-      ],
-    });
-    const result = validateDomainPack(pack);
-    expect(result.success).toBe(false);
-  });
-
-  it('should reject pack with facade name colliding with semantic facades', () => {
-    const pack = createMockPack({
-      facades: [
-        {
-          name: 'vault', // collides with semantic facade
-          description: 'Bad facade.',
-          ops: [],
-        },
-      ],
-    });
-    const result = validateDomainPack(pack);
-    expect(result.success).toBe(false);
-  });
-
-  it('should export SEMANTIC_FACADE_NAMES containing core facade names', () => {
-    expect(SEMANTIC_FACADE_NAMES).toContain('vault');
-    expect(SEMANTIC_FACADE_NAMES).toContain('plan');
-    expect(SEMANTIC_FACADE_NAMES).toContain('brain');
-    expect(SEMANTIC_FACADE_NAMES).toContain('memory');
-    expect(SEMANTIC_FACADE_NAMES).toContain('admin');
-    expect(SEMANTIC_FACADE_NAMES).toContain('curator');
-  });
-
-  it('should accept pack with valid KnowledgeManifest tiers', () => {
-    const pack = createMockPack({
-      knowledge: {
-        canonical: './knowledge/canonical',
-        curated: './knowledge/curated',
-      },
-    });
-    const result = validateDomainPack(pack);
-    expect(result.success).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. Pack Dependency Resolution
-// ---------------------------------------------------------------------------
-
-describe('Pack dependency resolution', () => {
-  it('should resolve packs with no dependencies', () => {
-    const packA = createMockPack({ name: 'pack-a' });
-    const packB = createMockPack({ name: 'pack-b', domains: ['testing'] });
-    const sorted = resolveDependencies([packA, packB]);
-    expect(sorted.length).toBe(2);
-  });
-
-  it('should sort packs by dependency order', () => {
-    const packA = createMockPack({ name: 'pack-a', requires: ['pack-b'] });
-    const packB = createMockPack({ name: 'pack-b', domains: ['testing'] });
-    const sorted = resolveDependencies([packA, packB]);
-    const names = sorted.map((p) => p.name);
-    expect(names.indexOf('pack-b')).toBeLessThan(names.indexOf('pack-a'));
-  });
-
-  it('should detect circular dependencies', () => {
-    const packA = createMockPack({ name: 'pack-a', requires: ['pack-b'] });
-    const packB = createMockPack({ name: 'pack-b', domains: ['testing'], requires: ['pack-a'] });
-    expect(() => resolveDependencies([packA, packB])).toThrow(/circular/i);
-  });
-
-  it('should throw on missing dependency', () => {
-    const packA = createMockPack({ name: 'pack-a', requires: ['pack-nonexistent'] });
-    expect(() => resolveDependencies([packA])).toThrow(/not found/i);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Extended createDomainFacades() with pack support
-// ---------------------------------------------------------------------------
-
-describe('createDomainFacades with packs', () => {
-  let runtime: AgentRuntime;
-
-  beforeEach(() => {
-    runtime = createAgentRuntime({
-      agentId: 'test-packs',
-      vaultPath: ':memory:',
-    });
-  });
-
-  afterEach(() => {
-    runtime.close();
-  });
-
-  // --- OCP: no packs = identical behavior ---
-
-  it('should work identically without packs parameter', () => {
-    const withoutPacks = createDomainFacades(runtime, 'test-packs', ['security']);
-    expect(withoutPacks.length).toBe(1);
-    expect(withoutPacks[0].ops.length).toBe(5);
-    expect(withoutPacks[0].name).toBe('test-packs_security');
-  });
-
-  it('should work identically with empty packs array', () => {
-    const withEmpty = createDomainFacades(runtime, 'test-packs', ['security'], []);
-    expect(withEmpty.length).toBe(1);
-    expect(withEmpty[0].ops.length).toBe(5);
-  });
-
-  // --- Pack ops override standard ops ---
-
-  it('should use pack ops for claimed domain', () => {
-    const pack = createMockPack(); // claims 'design'
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const designFacade = facades.find((f) => f.name.includes('design'));
-    expect(designFacade).toBeDefined();
-
-    // Should have pack's 3 custom ops + standard fallbacks for unclaimed names
-    const opNames = designFacade!.ops.map((o) => o.name);
-    expect(opNames).toContain('check_contrast');
-    expect(opNames).toContain('validate_token');
-    expect(opNames).toContain('get_color_pairs');
-  });
-
-  it('should keep standard ops as fallbacks for names not in pack', () => {
-    const pack = createMockPack(); // has check_contrast, validate_token, get_color_pairs
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const designFacade = facades.find((f) => f.name.includes('design'));
-    const opNames = designFacade!.ops.map((o) => o.name);
-
-    // Standard ops not overridden by pack should still exist as fallbacks
-    expect(opNames).toContain('get_patterns');
-    expect(opNames).toContain('search');
-    expect(opNames).toContain('get_entry');
-    expect(opNames).toContain('capture');
-    expect(opNames).toContain('remove');
-  });
-
-  it('should use pack handler when pack overrides a standard op name', () => {
-    const customSearchHandler = async () => ({ custom: true, source: 'pack' });
-    const pack = createMockPack({
-      ops: [
-        {
-          name: 'search', // overrides standard search
-          description: 'Custom domain search with specialized ranking.',
-          auth: 'read' as const,
-          handler: customSearchHandler,
-        },
-      ],
-    });
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const designFacade = facades.find((f) => f.name.includes('design'));
-    const searchOp = designFacade!.ops.find((o) => o.name === 'search');
-    expect(searchOp!.handler).toBe(customSearchHandler);
-  });
-
-  // --- Unclaimed domains get standard 5 ops ---
-
-  it('should give unclaimed domains standard 5 ops', () => {
-    const pack = createMockPack(); // claims 'design' only
-    const facades = createDomainFacades(runtime, 'test-packs', ['design', 'security'], [pack]);
-    const securityFacade = facades.find((f) => f.name.includes('security'));
-    expect(securityFacade).toBeDefined();
-    expect(securityFacade!.ops.length).toBe(5);
-    expect(securityFacade!.ops.map((o) => o.name)).not.toContain('check_contrast');
-  });
-
-  // --- Pack standalone facades ---
-
-  it('should register pack standalone facades as additional facades', () => {
-    const pack = createMockPackWithFacades();
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-
-    // Should have domain facade + standalone design_rules facade
-    const facadeNames = facades.map((f) => f.name);
-    expect(facadeNames.some((n) => n.includes('design_rules'))).toBe(true);
-  });
-
-  it('should prefix standalone facade names with agentId', () => {
-    const pack = createMockPackWithFacades();
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const rulesFacade = facades.find((f) => f.name.includes('design_rules'));
-    expect(rulesFacade!.name).toBe('test-packs_design_rules');
-  });
-
-  it('standalone facade ops should be callable', async () => {
-    const pack = createMockPackWithFacades();
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const rulesFacade = facades.find((f) => f.name.includes('design_rules'));
-    const cleanCodeOp = rulesFacade!.ops.find((o) => o.name === 'get_clean_code_rules');
-    const result = (await cleanCodeOp!.handler({})) as { rules: string[] };
-    expect(result.rules).toContain('no-hex-colors');
-  });
-
-  // --- Custom ops are callable ---
-
-  it('custom pack ops should execute and return results', async () => {
-    const pack = createMockPack();
-    const facades = createDomainFacades(runtime, 'test-packs', ['design'], [pack]);
-    const designFacade = facades.find((f) => f.name.includes('design'));
-    const contrastOp = designFacade!.ops.find((o) => o.name === 'check_contrast');
-    const result = (await contrastOp!.handler({
-      foreground: '#000000',
-      background: '#ffffff',
-    })) as { ratio: number; passes: boolean };
-    expect(result.ratio).toBe(4.5);
-    expect(result.passes).toBe(true);
-  });
-
-  // --- Multiple packs ---
-
-  it('should support multiple packs claiming different domains', () => {
-    const designPack = createMockPack({ name: 'design-pack', domains: ['design'] });
-    const securityPack = createMockPack({
-      name: 'security-pack',
-      domains: ['security'],
-      ops: [
-        {
-          name: 'scan_vulnerabilities',
-          description: 'Scan for security vulnerabilities.',
-          auth: 'read' as const,
-          handler: async () => ({ vulnerabilities: [] }),
-        },
-      ],
-    });
-    const facades = createDomainFacades(
-      runtime,
-      'test-packs',
-      ['design', 'security'],
-      [designPack, securityPack],
-    );
-    expect(facades.length).toBeGreaterThanOrEqual(2);
-
-    const designOps = facades.find((f) => f.name.includes('design'))!.ops.map((o) => o.name);
-    const securityOps = facades.find((f) => f.name.includes('security'))!.ops.map((o) => o.name);
-
-    expect(designOps).toContain('check_contrast');
-    expect(securityOps).toContain('scan_vulnerabilities');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. OCP Regression — existing behavior preserved
-// ---------------------------------------------------------------------------
-
-describe('OCP regression: existing domain-ops behavior', () => {
-  let runtime: AgentRuntime;
-
-  beforeEach(() => {
-    runtime = createAgentRuntime({
-      agentId: 'test-ocp',
-      vaultPath: ':memory:',
-    });
-  });
-
-  afterEach(() => {
-    runtime.close();
-  });
-
-  it('createDomainFacade (singular) still works unchanged', () => {
-    const facade = createDomainFacade(runtime, 'test-ocp', 'security');
-    expect(facade.ops.length).toBe(5);
-    expect(facade.name).toBe('test-ocp_security');
-  });
-
-  it('createDomainFacades without 4th arg still returns standard facades', () => {
-    const facades = createDomainFacades(runtime, 'test-ocp', ['security', 'api-design']);
-    expect(facades.length).toBe(2);
-    facades.forEach((f) => {
-      expect(f.ops.length).toBe(5);
-    });
-  });
-
-  it('standard domain capture still integrates with governance', async () => {
-    const facade = createDomainFacade(runtime, 'test-ocp', 'security');
-    const captureOp = facade.ops.find((o) => o.name === 'capture')!;
-    const result = (await captureOp.handler({
-      id: 'ocp-test-1',
-      type: 'pattern',
-      title: 'OCP Test',
-      severity: 'warning',
-      description: 'Should still work.',
-      tags: ['ocp'],
-    })) as { captured: boolean; governance: { action: string } };
-    expect(result.captured).toBe(true);
-    expect(result.governance.action).toBe('capture');
-  });
-});

package/src/__tests__/enforcement.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { EnforcementRegistry } from '../enforcement/registry.js';
-import { ClaudeCodeAdapter } from '../enforcement/adapters/claude-code.js';
-import type { EnforcementRule } from '../enforcement/types.js';
-
-const makeRule = (overrides: Partial<EnforcementRule> = {}): EnforcementRule => ({
-  id: 'test-rule',
-  description: 'Test rule',
-  trigger: 'pre-tool-use',
-  action: 'block',
-  message: 'This is blocked',
-  ...overrides,
-});
-
-describe('EnforcementRegistry', () => {
-  it('adds and retrieves rules', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule({ id: 'r1' }));
-    reg.addRule(makeRule({ id: 'r2' }));
-    expect(reg.getRules()).toHaveLength(2);
-    expect(reg.getRule('r1')?.id).toBe('r1');
-  });
-
-  it('replaces rules with same ID', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule({ id: 'r1', message: 'old' }));
-    reg.addRule(makeRule({ id: 'r1', message: 'new' }));
-    expect(reg.getRules()).toHaveLength(1);
-    expect(reg.getRule('r1')?.message).toBe('new');
-  });
-
-  it('removes rules by ID', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule({ id: 'r1' }));
-    expect(reg.removeRule('r1')).toBe(true);
-    expect(reg.removeRule('r1')).toBe(false);
-    expect(reg.getRules()).toHaveLength(0);
-  });
-
-  it('filters disabled rules', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule({ id: 'active' }));
-    reg.addRule(makeRule({ id: 'disabled', enabled: false }));
-    expect(reg.getEnabledRules()).toHaveLength(1);
-    expect(reg.getEnabledRules()[0].id).toBe('active');
-  });
-
-  it('addRules adds multiple', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRules([makeRule({ id: 'a' }), makeRule({ id: 'b' }), makeRule({ id: 'c' })]);
-    expect(reg.getRules()).toHaveLength(3);
-  });
-
-  it('registers and lists adapters', () => {
-    const reg = new EnforcementRegistry();
-    reg.registerAdapter(new ClaudeCodeAdapter());
-    expect(reg.listAdapters()).toEqual(['claude-code']);
-    expect(reg.getAdapter('claude-code')).toBeDefined();
-  });
-
-  it('translate returns skipped when no adapter', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule({ id: 'r1' }));
-    const result = reg.translate('unknown-host');
-    expect(result.host).toBe('unknown-host');
-    expect(result.files).toHaveLength(0);
-    expect(result.skipped).toHaveLength(1);
-    expect(result.skipped[0].ruleId).toBe('r1');
-  });
-
-  it('translateAll translates for all adapters', () => {
-    const reg = new EnforcementRegistry();
-    reg.addRule(makeRule());
-    reg.registerAdapter(new ClaudeCodeAdapter());
-    const results = reg.translateAll();
-    expect(results).toHaveLength(1);
-    expect(results[0].host).toBe('claude-code');
-  });
-});
-
-describe('ClaudeCodeAdapter', () => {
-  const adapter = new ClaudeCodeAdapter();
-
-  it('supports expected triggers', () => {
-    expect(adapter.supports('pre-tool-use')).toBe(true);
-    expect(adapter.supports('post-tool-use')).toBe(true);
-    expect(adapter.supports('pre-compact')).toBe(true);
-    expect(adapter.supports('session-start')).toBe(true);
-    expect(adapter.supports('pre-commit')).toBe(true);
-    expect(adapter.supports('on-save')).toBe(false);
-  });
-
-  it('translates pre-tool-use with pattern to settings.json hook', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'no-console', pattern: 'console\\.log', trigger: 'pre-tool-use' })],
-    });
-    expect(result.files.length).toBeGreaterThan(0);
-    const settingsFile = result.files.find((f) => f.path.includes('settings.json'));
-    expect(settingsFile).toBeDefined();
-    const parsed = JSON.parse(settingsFile!.content);
-    expect(parsed.hooks).toHaveLength(1);
-    expect(parsed.hooks[0].event).toBe('PreToolUse');
-    expect(parsed.hooks[0].command).toContain('console\\.log');
-  });
-
-  it('translates pre-commit to hookify file', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'no-debug', trigger: 'pre-commit', pattern: 'debugger' })],
-    });
-    const hookFile = result.files.find((f) => f.path.includes('hookify.no-debug'));
-    expect(hookFile).toBeDefined();
-    expect(hookFile!.content).toContain('name: no-debug');
-    expect(hookFile!.content).toContain('debugger');
-  });
-
-  it('skips unsupported triggers', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'on-save-rule', trigger: 'on-save' })],
-    });
-    expect(result.skipped).toHaveLength(1);
-    expect(result.skipped[0].ruleId).toBe('on-save-rule');
-  });
-
-  it('generates block command with exit 1', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'blocker', action: 'block', pattern: 'bad-thing' })],
-    });
-    const settings = result.files.find((f) => f.path.includes('settings.json'));
-    const parsed = JSON.parse(settings!.content);
-    expect(parsed.hooks[0].command).toContain('exit 1');
-    expect(parsed.hooks[0].command).toContain('BLOCKED');
-  });
-
-  it('generates warn command without exit 1', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'warner', action: 'warn', pattern: 'maybe-bad' })],
-    });
-    const settings = result.files.find((f) => f.path.includes('settings.json'));
-    const parsed = JSON.parse(settings!.content);
-    expect(parsed.hooks[0].command).toContain('WARNING');
-    expect(parsed.hooks[0].command).not.toContain('exit 1');
-  });
-
-  it('handles rules without patterns', () => {
-    const result = adapter.translate({
-      rules: [makeRule({ id: 'simple', trigger: 'session-start' })],
-    });
-    const settings = result.files.find((f) => f.path.includes('settings.json'));
-    const parsed = JSON.parse(settings!.content);
-    expect(parsed.hooks[0].event).toBe('SessionStart');
-    expect(parsed.hooks[0].command).toContain('simple');
-  });
-});