@soleri/core 9.5.0 → 9.6.0

package/src/__tests__/adapters/claude-code-adapter.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClaudeCodeRuntimeAdapter } from '../../adapters/claude-code-adapter.js';
+import type { AdapterExecutionContext } from '../../adapters/types.js';
+
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+function makeContext(overrides?: Partial<AdapterExecutionContext>): AdapterExecutionContext {
+  return {
+    runId: 'test-run-1',
+    prompt: 'Hello world',
+    workspace: '/tmp/test-workspace',
+    ...overrides,
+  };
+}
+
+describe('ClaudeCodeRuntimeAdapter', () => {
+  let adapter: ClaudeCodeRuntimeAdapter;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    adapter = new ClaudeCodeRuntimeAdapter();
+  });
+
+  describe('type', () => {
+    it('should have type property set to "claude-code"', () => {
+      expect(adapter.type).toBe('claude-code');
+    });
+  });
+
+  describe('execute()', () => {
+    it('should call the dispatch function with correct args', async () => {
+      const dispatch = vi.fn().mockResolvedValue({ exitCode: 0 });
+      adapter = new ClaudeCodeRuntimeAdapter(dispatch);
+      const ctx = makeContext();
+
+      await adapter.execute(ctx);
+
+      expect(dispatch).toHaveBeenCalledTimes(1);
+      expect(dispatch).toHaveBeenCalledWith('Hello world', '/tmp/test-workspace', undefined);
+    });
+
+    it('should return a proper AdapterExecutionResult shape', async () => {
+      const dispatch = vi.fn().mockResolvedValue({ exitCode: 0, output: 'Done' });
+      adapter = new ClaudeCodeRuntimeAdapter(dispatch);
+
+      const result = await adapter.execute(makeContext());
+
+      expect(result).toHaveProperty('exitCode');
+      expect(typeof result.exitCode).toBe('number');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should handle dispatch that returns an error exit code', async () => {
+      const dispatch = vi.fn().mockResolvedValue({ exitCode: 1 });
+      adapter = new ClaudeCodeRuntimeAdapter(dispatch);
+
+      const result = await adapter.execute(makeContext());
+
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should work without a dispatch function and return a default result', async () => {
+      adapter = new ClaudeCodeRuntimeAdapter();
+
+      const result = await adapter.execute(makeContext());
+
+      expect(result).toHaveProperty('exitCode');
+      expect(typeof result.exitCode).toBe('number');
+    });
+  });
+
+  describe('testEnvironment()', () => {
+    it('should return available: true when CLI exists', async () => {
+      const { execSync } = await import('node:child_process');
+      const mockedExecSync = vi.mocked(execSync);
+      mockedExecSync.mockReturnValue('/usr/local/bin/claude' as any);
+
+      const result = await adapter.testEnvironment();
+
+      expect(result.available).toBe(true);
+    });
+
+    it('should return available: false when CLI is missing', async () => {
+      const { execSync } = await import('node:child_process');
+      const mockedExecSync = vi.mocked(execSync);
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('command not found: claude');
+      });
+
+      const result = await adapter.testEnvironment();
+
+      expect(result.available).toBe(false);
+    });
+
+    it('should never throw even if the environment check fails', async () => {
+      const { execSync } = await import('node:child_process');
+      const mockedExecSync = vi.mocked(execSync);
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('unexpected catastrophic error');
+      });
+
+      // Should not throw — returns a result with available: false
+      const result = await adapter.testEnvironment();
+      expect(result).toHaveProperty('available');
+      expect(result.available).toBe(false);
+    });
+  });
+
+  describe('sessionCodec', () => {
+    it('should have a sessionCodec property', () => {
+      expect(adapter.sessionCodec).toBeDefined();
+    });
+
+    it('should serialize session state to valid JSON', () => {
+      const state = {
+        adapterType: 'claude-code',
+        data: { sessionId: 'sess-123', conversationId: 'conv-456' },
+      };
+
+      const serialized = adapter.sessionCodec!.serialize(state);
+
+      expect(() => JSON.parse(serialized)).not.toThrow();
+      const parsed = JSON.parse(serialized);
+      expect(parsed.adapterType).toBe('claude-code');
+    });
+
+    it('should round-trip serialize and deserialize', () => {
+      const state = {
+        adapterType: 'claude-code',
+        data: { sessionId: 'sess-123', conversationId: 'conv-456' },
+      };
+
+      const serialized = adapter.sessionCodec!.serialize(state);
+      const deserialized = adapter.sessionCodec!.deserialize(serialized);
+
+      expect(deserialized).toEqual(state);
+    });
+
+    it('should return a display ID from getDisplayId()', () => {
+      const state = {
+        adapterType: 'claude-code',
+        data: { sessionId: 'sess-123' },
+      };
+
+      const displayId = adapter.sessionCodec!.getDisplayId(state);
+
+      expect(typeof displayId).toBe('string');
+      expect(displayId).toContain('sess-123');
+    });
+
+    it('should throw on invalid JSON in deserialize()', () => {
+      expect(() => adapter.sessionCodec!.deserialize('not-valid-json{')).toThrow();
+    });
+  });
+
+  describe('syncSkills()', () => {
+    it('should be callable without throwing (smoke test)', async () => {
+      if (adapter.syncSkills) {
+        await expect(adapter.syncSkills([])).resolves.not.toThrow();
+      }
+      // If syncSkills is not defined, that's also acceptable per the interface
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/__tests__/adapters/registry.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RuntimeAdapterRegistry } from '../../adapters/registry.js';
+import type { RuntimeAdapter } from '../../adapters/types.js';
+
+function createMockAdapter(type: string): RuntimeAdapter {
+  return {
+    type,
+    execute: vi.fn().mockResolvedValue({ exitCode: 0 }),
+    testEnvironment: vi.fn().mockResolvedValue({ available: true }),
+  };
+}
+
+describe('RuntimeAdapterRegistry', () => {
+  let registry: RuntimeAdapterRegistry;
+
+  beforeEach(() => {
+    registry = new RuntimeAdapterRegistry();
+  });
+
+  it('should store an adapter via register() and retrieve it via get()', () => {
+    const adapter = createMockAdapter('claude-code');
+    registry.register('claude-code', adapter);
+
+    const result = registry.get('claude-code');
+    expect(result).toBe(adapter);
+  });
+
+  it('should throw when getting an unknown adapter type', () => {
+    expect(() => registry.get('nonexistent')).toThrow(/unknown adapter type/i);
+  });
+
+  it('should return all registered types via list()', () => {
+    registry.register('claude-code', createMockAdapter('claude-code'));
+    registry.register('codex', createMockAdapter('codex'));
+
+    const types = registry.list();
+    expect(types).toContain('claude-code');
+    expect(types).toContain('codex');
+    expect(types).toHaveLength(2);
+  });
+
+  it('should set the default adapter via setDefault()', () => {
+    const adapter = createMockAdapter('claude-code');
+    registry.register('claude-code', adapter);
+    registry.setDefault('claude-code');
+
+    const result = registry.getDefault();
+    expect(result).toBe(adapter);
+  });
+
+  it('should return the default adapter via getDefault()', () => {
+    const a1 = createMockAdapter('claude-code');
+    const a2 = createMockAdapter('codex');
+    registry.register('claude-code', a1);
+    registry.register('codex', a2);
+    registry.setDefault('codex');
+
+    expect(registry.getDefault()).toBe(a2);
+  });
+
+  it('should throw when setDefault() is called with an unregistered type', () => {
+    expect(() => registry.setDefault('nonexistent')).toThrow(/unregistered type/i);
+  });
+
+  it('should throw when register() is called with a duplicate type', () => {
+    registry.register('claude-code', createMockAdapter('claude-code'));
+
+    expect(() => registry.register('claude-code', createMockAdapter('claude-code'))).toThrow(
+      /already registered/i,
+    );
+  });
+
+  it('should return an empty array from list() when no adapters are registered', () => {
+    expect(registry.list()).toEqual([]);
+  });
+
+  it('should allow multiple adapters to coexist', () => {
+    const adapters = ['claude-code', 'codex', 'cursor'];
+    adapters.forEach((type) => registry.register(type, createMockAdapter(type)));
+
+    expect(registry.list()).toHaveLength(3);
+    adapters.forEach((type) => {
+      expect(registry.get(type).type).toBe(type);
+    });
+  });
+
+  it('should throw when getDefault() is called with no default set', () => {
+    expect(() => registry.getDefault()).toThrow(/no default/i);
+  });
+
+  it('should include registered type names in error message when get() fails', () => {
+    registry.register('codex', createMockAdapter('codex'));
+
+    expect(() => registry.get('missing')).toThrow(/codex/);
+  });
+
+  it('should show "(none)" in error message when no adapters are registered and get() fails', () => {
+    expect(() => registry.get('missing')).toThrow(/\(none\)/);
+  });
+});

package/src/__tests__/packs/pack-lifecycle.test.ts

@@ -0,0 +1,379 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PackLifecycleManager } from '../../packs/pack-lifecycle.js';
+import { VALID_TRANSITIONS } from '../../packs/types.js';
+import type { PackState } from '../../packs/types.js';
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+let manager: PackLifecycleManager;
+
+beforeEach(() => {
+  manager = new PackLifecycleManager();
+});
+
+// =============================================================================
+// VALID TRANSITIONS
+// =============================================================================
+
+describe('PackLifecycleManager — valid transitions', () => {
+  it('installed → ready', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+    expect(manager.getState('p1')).toBe('ready');
+  });
+
+  it('installed → error', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'error', 'activation failed');
+    expect(manager.getState('p1')).toBe('error');
+  });
+
+  it('installed → uninstalled', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'uninstalled');
+    expect(manager.getState('p1')).toBe('uninstalled');
+  });
+
+  it('ready → ready (self-transition)', () => {
+    manager.initState('p1', 'ready');
+    manager.transition('p1', 'ready', 'reloaded');
+    expect(manager.getState('p1')).toBe('ready');
+  });
+
+  it('ready → disabled', () => {
+    manager.initState('p1', 'ready');
+    manager.transition('p1', 'disabled');
+    expect(manager.getState('p1')).toBe('disabled');
+  });
+
+  it('ready → error', () => {
+    manager.initState('p1', 'ready');
+    manager.transition('p1', 'error', 'runtime failure');
+    expect(manager.getState('p1')).toBe('error');
+  });
+
+  it('ready → upgrade_pending', () => {
+    manager.initState('p1', 'ready');
+    manager.transition('p1', 'upgrade_pending');
+    expect(manager.getState('p1')).toBe('upgrade_pending');
+  });
+
+  it('ready → uninstalled', () => {
+    manager.initState('p1', 'ready');
+    manager.transition('p1', 'uninstalled');
+    expect(manager.getState('p1')).toBe('uninstalled');
+  });
+
+  it('disabled → ready', () => {
+    manager.initState('p1', 'disabled');
+    manager.transition('p1', 'ready');
+    expect(manager.getState('p1')).toBe('ready');
+  });
+
+  it('disabled → uninstalled', () => {
+    manager.initState('p1', 'disabled');
+    manager.transition('p1', 'uninstalled');
+    expect(manager.getState('p1')).toBe('uninstalled');
+  });
+
+  it('error → ready', () => {
+    manager.initState('p1', 'error');
+    manager.transition('p1', 'ready', 'retry succeeded');
+    expect(manager.getState('p1')).toBe('ready');
+  });
+
+  it('error → uninstalled', () => {
+    manager.initState('p1', 'error');
+    manager.transition('p1', 'uninstalled');
+    expect(manager.getState('p1')).toBe('uninstalled');
+  });
+
+  it('upgrade_pending → ready', () => {
+    manager.initState('p1', 'upgrade_pending');
+    manager.transition('p1', 'ready', 'upgrade complete');
+    expect(manager.getState('p1')).toBe('ready');
+  });
+
+  it('upgrade_pending → error', () => {
+    manager.initState('p1', 'upgrade_pending');
+    manager.transition('p1', 'error', 'upgrade failed');
+    expect(manager.getState('p1')).toBe('error');
+  });
+
+  it('upgrade_pending → uninstalled', () => {
+    manager.initState('p1', 'upgrade_pending');
+    manager.transition('p1', 'uninstalled');
+    expect(manager.getState('p1')).toBe('uninstalled');
+  });
+
+  it('uninstalled → installed', () => {
+    manager.initState('p1', 'uninstalled');
+    manager.transition('p1', 'installed', 'reinstalled');
+    expect(manager.getState('p1')).toBe('installed');
+  });
+});
+
+// =============================================================================
+// INVALID TRANSITIONS
+// =============================================================================
+
+describe('PackLifecycleManager — invalid transitions', () => {
+  it('installed → disabled throws', () => {
+    manager.initState('p1', 'installed');
+    expect(() => manager.transition('p1', 'disabled')).toThrow();
+  });
+
+  it('disabled → error throws', () => {
+    manager.initState('p1', 'disabled');
+    expect(() => manager.transition('p1', 'error')).toThrow();
+  });
+
+  it('uninstalled → ready throws', () => {
+    manager.initState('p1', 'uninstalled');
+    expect(() => manager.transition('p1', 'ready')).toThrow();
+  });
+
+  it('error → disabled throws', () => {
+    manager.initState('p1', 'error');
+    expect(() => manager.transition('p1', 'disabled')).toThrow();
+  });
+
+  it('error message includes current state, target, and valid targets', () => {
+    manager.initState('p1', 'installed');
+    try {
+      manager.transition('p1', 'disabled');
+      expect.unreachable('should have thrown');
+    } catch (err) {
+      const msg = (err as Error).message;
+      expect(msg).toContain('installed');
+      expect(msg).toContain('disabled');
+      // Valid targets from 'installed' are: ready, error, uninstalled
+      expect(msg).toContain('ready');
+      expect(msg).toContain('error');
+      expect(msg).toContain('uninstalled');
+    }
+  });
+
+  it('transition on untracked pack throws', () => {
+    expect(() => manager.transition('ghost', 'ready')).toThrow("Pack 'ghost' is not being tracked");
+  });
+
+  it('installed → upgrade_pending throws', () => {
+    manager.initState('p1', 'installed');
+    expect(() => manager.transition('p1', 'upgrade_pending')).toThrow();
+  });
+});
+
+// =============================================================================
+// CORE BEHAVIOR
+// =============================================================================
+
+describe('PackLifecycleManager — core behavior', () => {
+  it('initState() sets state without validation', () => {
+    // initState should accept any state without checking transitions
+    manager.initState('p1', 'error');
+    expect(manager.getState('p1')).toBe('error');
+  });
+
+  it('initState() overwrites existing state without validation', () => {
+    manager.initState('p1', 'installed');
+    manager.initState('p1', 'ready');
+    expect(manager.getState('p1')).toBe('ready');
+    // Transitions should be reset since initState creates a fresh entry
+    expect(manager.getTransitions('p1')).toEqual([]);
+  });
+
+  it('getState() returns undefined for unknown pack', () => {
+    expect(manager.getState('nonexistent')).toBeUndefined();
+  });
+
+  it('getState() returns correct state after transition', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+    manager.transition('p1', 'disabled');
+    expect(manager.getState('p1')).toBe('disabled');
+  });
+
+  it('getTransitions() returns empty array for new pack', () => {
+    manager.initState('p1', 'installed');
+    expect(manager.getTransitions('p1')).toEqual([]);
+  });
+
+  it('getTransitions() returns empty array for unknown pack', () => {
+    expect(manager.getTransitions('ghost')).toEqual([]);
+  });
+
+  it('getTransitions() records all transitions with timestamps', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready', 'activated');
+    manager.transition('p1', 'disabled', 'user disabled');
+    manager.transition('p1', 'ready', 're-enabled');
+
+    const transitions = manager.getTransitions('p1');
+    expect(transitions).toHaveLength(3);
+
+    expect(transitions[0].from).toBe('installed');
+    expect(transitions[0].to).toBe('ready');
+    expect(transitions[0].reason).toBe('activated');
+    expect(typeof transitions[0].timestamp).toBe('number');
+
+    expect(transitions[1].from).toBe('ready');
+    expect(transitions[1].to).toBe('disabled');
+    expect(transitions[1].reason).toBe('user disabled');
+
+    expect(transitions[2].from).toBe('disabled');
+    expect(transitions[2].to).toBe('ready');
+    expect(transitions[2].reason).toBe('re-enabled');
+
+    // Timestamps should be monotonically non-decreasing
+    expect(transitions[1].timestamp).toBeGreaterThanOrEqual(transitions[0].timestamp);
+    expect(transitions[2].timestamp).toBeGreaterThanOrEqual(transitions[1].timestamp);
+  });
+
+  it('onTransition() callback fires on every transition', () => {
+    const listener = vi.fn();
+    manager.onTransition(listener);
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready', 'activated');
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith('p1', 'installed', 'ready', 'activated');
+  });
+
+  it('onTransition() returns unsubscribe function that works', () => {
+    const listener = vi.fn();
+    const unsub = manager.onTransition(listener);
+
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unsub();
+    manager.transition('p1', 'disabled');
+    expect(listener).toHaveBeenCalledTimes(1); // not called again
+  });
+
+  it('multiple listeners all fire', () => {
+    const listener1 = vi.fn();
+    const listener2 = vi.fn();
+    const listener3 = vi.fn();
+
+    manager.onTransition(listener1);
+    manager.onTransition(listener2);
+    manager.onTransition(listener3);
+
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+
+    expect(listener1).toHaveBeenCalledTimes(1);
+    expect(listener2).toHaveBeenCalledTimes(1);
+    expect(listener3).toHaveBeenCalledTimes(1);
+  });
+
+  it('remove() clears pack state', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+    manager.remove('p1');
+
+    expect(manager.getState('p1')).toBeUndefined();
+    expect(manager.getTransitions('p1')).toEqual([]);
+  });
+
+  it('listAll() returns all tracked packs', () => {
+    manager.initState('alpha', 'installed');
+    manager.initState('beta', 'ready');
+    manager.initState('gamma', 'disabled');
+
+    const all = manager.listAll();
+    expect(all).toHaveLength(3);
+    expect(all).toEqual(
+      expect.arrayContaining([
+        { packId: 'alpha', state: 'installed' },
+        { packId: 'beta', state: 'ready' },
+        { packId: 'gamma', state: 'disabled' },
+      ]),
+    );
+  });
+
+  it('listAll() returns empty array when no packs tracked', () => {
+    expect(manager.listAll()).toEqual([]);
+  });
+
+  it('reset() clears everything', () => {
+    const listener = vi.fn();
+    manager.onTransition(listener);
+
+    manager.initState('p1', 'installed');
+    manager.initState('p2', 'ready');
+    manager.transition('p1', 'ready');
+
+    manager.reset();
+
+    expect(manager.listAll()).toEqual([]);
+    expect(manager.getState('p1')).toBeUndefined();
+    expect(manager.getState('p2')).toBeUndefined();
+
+    // Listeners should be cleared too — re-init and transition should not fire old listener
+    manager.initState('p3', 'installed');
+    manager.transition('p3', 'ready');
+    expect(listener).toHaveBeenCalledTimes(1); // only the pre-reset call
+  });
+
+  it('transition reason is optional', () => {
+    manager.initState('p1', 'installed');
+    manager.transition('p1', 'ready');
+
+    const transitions = manager.getTransitions('p1');
+    expect(transitions[0].reason).toBeUndefined();
+  });
+});
+
+// =============================================================================
+// BACKWARD COMPATIBILITY
+// =============================================================================
+
+describe('PackLifecycleManager — backward compatibility', () => {
+  it('PackState includes old PackStatus values (installed, error, uninstalled)', () => {
+    // These are the three original PackStatus values — they must remain valid PackState values
+    const oldStatuses: PackState[] = ['installed', 'error', 'uninstalled'];
+    for (const status of oldStatuses) {
+      manager.initState('test', status);
+      expect(manager.getState('test')).toBe(status);
+    }
+  });
+
+  it('VALID_TRANSITIONS is exported and has all 6 states as keys', () => {
+    const expectedStates: PackState[] = [
+      'installed',
+      'ready',
+      'disabled',
+      'error',
+      'upgrade_pending',
+      'uninstalled',
+    ];
+    const keys = Object.keys(VALID_TRANSITIONS);
+    expect(keys).toHaveLength(6);
+    for (const state of expectedStates) {
+      expect(VALID_TRANSITIONS).toHaveProperty(state);
+      expect(Array.isArray(VALID_TRANSITIONS[state])).toBe(true);
+    }
+  });
+
+  it('VALID_TRANSITIONS values are all valid PackState values', () => {
+    const allStates: PackState[] = [
+      'installed',
+      'ready',
+      'disabled',
+      'error',
+      'upgrade_pending',
+      'uninstalled',
+    ];
+    for (const [_from, targets] of Object.entries(VALID_TRANSITIONS)) {
+      for (const target of targets) {
+        expect(allStates).toContain(target);
+      }
+    }
+  });
+});