@soleri/core 2.12.0 → 8.0.0

package/src/__tests__/admin-setup-ops.test.ts

@@ -0,0 +1,355 @@
+import { describe, it, expect, afterEach, beforeEach } from 'vitest';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createAdminSetupOps } from '../runtime/admin-setup-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+import {
+  hasSections,
+  removeSections,
+  injectAtPosition,
+  buildInjectionContent,
+  wrapInMarkers,
+  composeAgentModeSection,
+  composeIntegrationSection,
+} from '../runtime/claude-md-helpers.js';
+
+// ─── claude-md-helpers tests ──────────────────────────────────────────
+
+describe('claude-md-helpers', () => {
+  const agentId = 'test-agent';
+  const config = { agentId } as any;
+
+  describe('hasSections', () => {
+    it('returns true when markers present', () => {
+      const content = `# Hello\n<!-- agent:${agentId}:mode -->\nstuff\n<!-- /agent:${agentId}:mode -->\n`;
+      expect(hasSections(content, agentId)).toBe(true);
+    });
+
+    it('returns false when no markers', () => {
+      expect(hasSections('# Hello\nWorld', agentId)).toBe(false);
+    });
+
+    it('returns false for different agent', () => {
+      const content = `<!-- agent:other:mode -->\nstuff\n<!-- /agent:other:mode -->`;
+      expect(hasSections(content, agentId)).toBe(false);
+    });
+  });
+
+  describe('removeSections', () => {
+    it('removes agent section cleanly', () => {
+      const content = `# Hello\n\n<!-- agent:${agentId}:mode -->\nstuff\n<!-- /agent:${agentId}:mode -->\n\n# Footer`;
+      const result = removeSections(content, agentId);
+      expect(result).not.toContain('stuff');
+      expect(result).toContain('# Hello');
+      expect(result).toContain('# Footer');
+    });
+
+    it('returns unchanged content if no markers', () => {
+      const content = '# Hello\nWorld';
+      expect(removeSections(content, agentId)).toBe(content);
+    });
+  });
+
+  describe('injectAtPosition', () => {
+    const section = '## Injected';
+
+    it('injects at start', () => {
+      const result = injectAtPosition('# Hello', section, 'start');
+      expect(result.startsWith('## Injected')).toBe(true);
+    });
+
+    it('injects at end', () => {
+      const result = injectAtPosition('# Hello', section, 'end');
+      expect(result.endsWith('## Injected\n')).toBe(true);
+    });
+
+    it('injects after title', () => {
+      const content = '# My Project\n\nSome content here.';
+      const result = injectAtPosition(content, section, 'after-title');
+      const lines = result.split('\n');
+      const titleIdx = lines.indexOf('# My Project');
+      expect(titleIdx).toBe(0);
+      // Section should appear before "Some content here."
+      expect(result.indexOf('## Injected')).toBeLessThan(result.indexOf('Some content here.'));
+    });
+
+    it('falls back to start if no title found', () => {
+      const content = 'No heading here.';
+      const result = injectAtPosition(content, section, 'after-title');
+      expect(result.startsWith('## Injected')).toBe(true);
+    });
+  });
+
+  describe('wrapInMarkers', () => {
+    it('wraps content in agent markers', () => {
+      const result = wrapInMarkers(agentId, 'hello');
+      expect(result).toContain(`<!-- agent:${agentId}:mode -->`);
+      expect(result).toContain('hello');
+      expect(result).toContain(`<!-- /agent:${agentId}:mode -->`);
+    });
+  });
+
+  describe('composeAgentModeSection', () => {
+    it('generates activation commands', () => {
+      const result = composeAgentModeSection(config);
+      expect(result).toContain('## Test-agent Mode');
+      expect(result).toContain('test-agent_core op:activate');
+      expect(result).toContain('deactivate: true');
+    });
+  });
+
+  describe('composeIntegrationSection', () => {
+    it('generates default tools table when no facades provided', () => {
+      const result = composeIntegrationSection(config);
+      expect(result).toContain('## Test-agent Integration');
+      expect(result).toContain('test-agent_vault');
+      expect(result).toContain('test-agent_admin');
+    });
+
+    it('uses provided facades', () => {
+      const facades = [{ name: 'test-agent_custom', ops: ['op_a', 'op_b'] }];
+      const result = composeIntegrationSection(config, facades);
+      expect(result).toContain('test-agent_custom');
+      expect(result).toContain('`op_a`');
+    });
+  });
+
+  describe('buildInjectionContent', () => {
+    it('wraps in markers', () => {
+      const result = buildInjectionContent(config);
+      expect(result).toContain(`<!-- agent:${agentId}:mode -->`);
+      expect(result).toContain(`<!-- /agent:${agentId}:mode -->`);
+    });
+
+    it('excludes integration when disabled', () => {
+      const result = buildInjectionContent(config, { includeIntegration: false });
+      expect(result).toContain('Mode');
+      expect(result).not.toContain('Integration');
+    });
+  });
+});
+
+// ─── admin-setup-ops tests ────────────────────────────────────────────
+
+describe('createAdminSetupOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let tmpDir: string;
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `soleri-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+
+    runtime = createAgentRuntime({
+      agentId: 'test-setup',
+      vaultPath: ':memory:',
+    });
+    ops = createAdminSetupOps(runtime);
+  });
+
+  afterEach(() => {
+    runtime?.close();
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // cleanup best-effort
+    }
+  });
+
+  it('should return 4 ops', () => {
+    expect(ops).toHaveLength(4);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'admin_inject_claude_md',
+      'admin_setup_global',
+      'admin_setup_project',
+      'admin_check_persistence',
+    ]);
+  });
+
+  // ─── inject_claude_md ───────────────────────────────────────────
+
+  describe('admin_inject_claude_md', () => {
+    it('creates CLAUDE.md when createIfMissing is true', async () => {
+      const result = (await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: true,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      })) as any;
+
+      expect(result.action).toBe('created');
+      expect(existsSync(result.path)).toBe(true);
+      const content = readFileSync(result.path, 'utf-8');
+      expect(content).toContain('<!-- agent:test-setup:mode -->');
+      expect(content).toContain('test-setup_core op:activate');
+    });
+
+    it('errors when CLAUDE.md not found and createIfMissing is false', async () => {
+      const result = (await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: false,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      })) as any;
+
+      expect(result.action).toBe('error');
+      expect(result.error).toContain('not found');
+    });
+
+    it('injects into existing CLAUDE.md', async () => {
+      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nExisting content.\n');
+
+      const result = (await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: false,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      })) as any;
+
+      expect(result.action).toBe('injected');
+      const content = readFileSync(result.path, 'utf-8');
+      expect(content).toContain('# My Project');
+      expect(content).toContain('<!-- agent:test-setup:mode -->');
+      expect(content).toContain('Existing content.');
+    });
+
+    it('is idempotent — updates existing sections', async () => {
+      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n\nExisting content.\n');
+
+      // First injection
+      await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: false,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      });
+
+      // Second injection — should update, not duplicate
+      const result = (await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: false,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      })) as any;
+
+      expect(result.action).toBe('updated');
+      const content = readFileSync(result.path, 'utf-8');
+      // Should have exactly one pair of markers
+      const markerCount = (content.match(/<!-- agent:test-setup:mode -->/g) ?? []).length;
+      expect(markerCount).toBe(1);
+    });
+
+    it('supports dry-run mode', async () => {
+      writeFileSync(join(tmpDir, 'CLAUDE.md'), '# My Project\n');
+
+      const result = (await findOp('admin_inject_claude_md').handler({
+        projectPath: tmpDir,
+        createIfMissing: false,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: true,
+        global: false,
+      })) as any;
+
+      expect(result.action).toBe('would_inject');
+      expect(result.preview).toBeDefined();
+      // File should not be modified
+      const content = readFileSync(join(tmpDir, 'CLAUDE.md'), 'utf-8');
+      expect(content).not.toContain('agent:test-setup:mode');
+    });
+  });
+
+  // ─── setup_global ───────────────────────────────────────────────
+
+  describe('admin_setup_global', () => {
+    it('returns dry-run analysis when install is false', async () => {
+      const result = (await findOp('admin_setup_global').handler({
+        install: false,
+        hooksOnly: false,
+        settingsJsonOnly: false,
+        skillsOnly: false,
+      })) as any;
+
+      expect(result.dryRun).toBe(true);
+      expect(result.agentId).toBe('test-setup');
+      expect(result.hookifyRules).toBeDefined();
+      expect(result.skills).toBeDefined();
+      expect(result.settingsJson).toBeDefined();
+    });
+  });
+
+  // ─── setup_project ─────────────────────────────────────────────
+
+  describe('admin_setup_project', () => {
+    it('returns analysis in default mode', async () => {
+      const result = (await findOp('admin_setup_project').handler({
+        projectPath: tmpDir,
+        cleanup: false,
+        install: false,
+      })) as any;
+
+      expect(result.mode).toBe('analyze');
+      expect(result.projectPath).toBe(tmpDir);
+      expect(typeof result.globalHooks).toBe('number');
+      expect(typeof result.projectHooks).toBe('number');
+    });
+
+    it('returns error for non-existent project', async () => {
+      const result = (await findOp('admin_setup_project').handler({
+        projectPath: '/nonexistent/path',
+        cleanup: false,
+        install: false,
+      })) as any;
+
+      expect(result.error).toBe('PROJECT_NOT_FOUND');
+    });
+  });
+
+  // ─── check_persistence ──────────────────────────────────────────
+
+  describe('admin_check_persistence', () => {
+    it('returns persistence diagnostic', async () => {
+      const result = (await findOp('admin_check_persistence').handler({})) as any;
+
+      expect(result.agentId).toBe('test-setup');
+      expect(result.storageDirectory).toBeDefined();
+      expect(result.files).toBeDefined();
+      expect(result.files.plans).toBeDefined();
+      expect(result.files.vault).toBeDefined();
+      expect(result.status).toBeDefined();
+      expect(result.recommendation).toBeDefined();
+      expect(Array.isArray(result.activePlans)).toBe(true);
+    });
+
+    it('reports correct status for in-memory vault', async () => {
+      const result = (await findOp('admin_check_persistence').handler({})) as any;
+
+      // In-memory vault + no plans file = NO_STORAGE_DIRECTORY or PERSISTENCE_CONFIGURED_BUT_INCOMPLETE
+      expect([
+        'NO_STORAGE_DIRECTORY',
+        'PERSISTENCE_CONFIGURED_BUT_INCOMPLETE',
+        'PERSISTENCE_ACTIVE',
+      ]).toContain(result.status);
+    });
+  });
+});

package/src/__tests__/async-infrastructure.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Tests for async infrastructure — event bus, job queue, pipeline runner.
+ * Phase 1 of #210: generic infrastructure modules.
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { TypedEventBus } from '../events/event-bus.js';
+import { JobQueue } from '../queue/job-queue.js';
+import { PipelineRunner } from '../queue/pipeline-runner.js';
+import { Vault } from '../vault/vault.js';
+
+// ─── Event Bus ───────────────────────────────────────────────────────
+
+describe('TypedEventBus', () => {
+  type TestEvents = {
+    'item:created': { id: string; title: string };
+    'item:deleted': { id: string };
+    tick: { count: number };
+  };
+
+  it('emits and receives typed events', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let received: TestEvents['item:created'] | null = null;
+
+    bus.on('item:created', (payload) => {
+      received = payload;
+    });
+    bus.emit('item:created', { id: '1', title: 'Hello' });
+
+    expect(received).toEqual({ id: '1', title: 'Hello' });
+  });
+
+  it('once listener fires only once', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let count = 0;
+
+    bus.once('tick', () => {
+      count++;
+    });
+    bus.emit('tick', { count: 1 });
+    bus.emit('tick', { count: 2 });
+
+    expect(count).toBe(1);
+  });
+
+  it('off removes a listener', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let count = 0;
+    const listener = () => {
+      count++;
+    };
+
+    bus.on('tick', listener);
+    bus.emit('tick', { count: 1 });
+    bus.off('tick', listener);
+    bus.emit('tick', { count: 2 });
+
+    expect(count).toBe(1);
+  });
+
+  it('listenerCount tracks total listeners', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    expect(bus.listenerCount()).toBe(0);
+
+    bus.on('item:created', () => {});
+    bus.on('item:deleted', () => {});
+    expect(bus.listenerCount()).toBe(2);
+  });
+
+  it('removeAllListeners clears everything', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    bus.on('item:created', () => {});
+    bus.on('tick', () => {});
+    bus.removeAllListeners();
+    expect(bus.listenerCount()).toBe(0);
+  });
+
+  it('supports multiple listeners on same event', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    const results: string[] = [];
+
+    bus.on('item:created', (p) => results.push('A:' + p.id));
+    bus.on('item:created', (p) => results.push('B:' + p.id));
+    bus.emit('item:created', { id: '1', title: 'Test' });
+
+    expect(results).toEqual(['A:1', 'B:1']);
+  });
+});
+
+// ─── Job Queue ───────────────────────────────────────────────────────
+
+describe('JobQueue', () => {
+  let vault: Vault;
+  let queue: JobQueue;
+
+  beforeAll(() => {
+    vault = new Vault(':memory:');
+    queue = new JobQueue(vault.getProvider());
+  });
+
+  afterAll(() => {
+    vault.close();
+  });
+
+  it('enqueue creates a job and returns ID', () => {
+    const id = queue.enqueue('tag-normalize', { entryId: 'e1' });
+    expect(id).toBeTruthy();
+    expect(id.length).toBeGreaterThan(0);
+  });
+
+  it('dequeue returns oldest pending job', () => {
+    const id = queue.enqueue('dedup-check');
+    const job = queue.dequeue();
+    expect(job).not.toBeNull();
+    expect(job!.type).toBe('tag-normalize'); // First enqueued from previous test
+  });
+
+  it('dequeue marks job as running', () => {
+    const job = queue.get(queue.enqueue('test-job'));
+    expect(job!.status).toBe('pending');
+
+    const dequeued = queue.dequeue();
+    expect(dequeued!.status).toBe('running');
+  });
+
+  it('complete marks job as completed with result', () => {
+    const id = queue.enqueue('test-complete');
+    queue.dequeue(); // Mark running
+    queue.complete(id, { ok: true });
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toEqual({ ok: true });
+  });
+
+  it('fail marks job as failed with error', () => {
+    const id = queue.enqueue('test-fail');
+    queue.dequeue();
+    queue.fail(id, 'something went wrong');
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('failed');
+    expect(job!.error).toBe('something went wrong');
+  });
+
+  it('retry resets failed job to pending', () => {
+    const id = queue.enqueue('test-retry');
+    queue.dequeue();
+    queue.fail(id, 'transient error');
+
+    const retried = queue.retry(id);
+    expect(retried).toBe(true);
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('pending');
+    expect(job!.retryCount).toBe(1);
+  });
+
+  it('retry returns false when max retries exceeded', () => {
+    const id = queue.enqueue('test-max-retry', { maxRetries: 1 });
+    queue.dequeue();
+    queue.fail(id, 'fail 1');
+    queue.retry(id);
+    queue.dequeue();
+    queue.fail(id, 'fail 2');
+
+    const retried = queue.retry(id);
+    expect(retried).toBe(false);
+  });
+
+  it('respects DAG dependencies', () => {
+    const dep1 = queue.enqueue('dep-job-1');
+    const dep2 = queue.enqueue('dep-job-2', { dependsOn: [dep1] });
+
+    // dep2 should not dequeue because dep1 is not completed
+    // Clear running jobs first
+    const ready = queue.dequeueReady(10);
+    const readyIds = ready.map((j) => j.id);
+    expect(readyIds).toContain(dep1);
+    expect(readyIds).not.toContain(dep2);
+
+    // Complete dep1
+    queue.complete(dep1, {});
+
+    // Now dep2 should be ready
+    const ready2 = queue.dequeueReady(10);
+    const readyIds2 = ready2.map((j) => j.id);
+    expect(readyIds2).toContain(dep2);
+  });
+
+  it('groups jobs by pipeline', () => {
+    const pid = 'pipeline-123';
+    queue.enqueue('step-1', { pipelineId: pid });
+    queue.enqueue('step-2', { pipelineId: pid });
+
+    const jobs = queue.getByPipeline(pid);
+    expect(jobs.length).toBe(2);
+    expect(jobs.every((j) => j.pipelineId === pid)).toBe(true);
+  });
+
+  it('getStats returns correct counts', () => {
+    const stats = queue.getStats();
+    expect(stats.total).toBeGreaterThan(0);
+    expect(typeof stats.pending).toBe('number');
+    expect(typeof stats.running).toBe('number');
+    expect(typeof stats.completed).toBe('number');
+    expect(typeof stats.failed).toBe('number');
+  });
+
+  it('purge removes old completed/failed jobs', () => {
+    // purge with 0 days should remove all completed/failed
+    const purged = queue.purge(0);
+    expect(purged).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ─── Pipeline Runner ─────────────────────────────────────────────────
+
+describe('PipelineRunner', () => {
+  let vault: Vault;
+  let queue: JobQueue;
+  let runner: PipelineRunner;
+
+  beforeAll(() => {
+    vault = new Vault(':memory:');
+    queue = new JobQueue(vault.getProvider());
+    runner = new PipelineRunner(queue, 100); // 100ms poll for tests
+  });
+
+  afterAll(() => {
+    runner.stop();
+    vault.close();
+  });
+
+  it('registerHandler stores a handler for a job type', () => {
+    runner.registerHandler('test-type', async () => ({ done: true }));
+    expect(runner.hasHandler('test-type')).toBe(true);
+    expect(runner.hasHandler('unknown-type')).toBe(false);
+  });
+
+  it('processOnce dequeues and completes jobs', async () => {
+    const handler = vi.fn().mockResolvedValue({ processed: true });
+    runner.registerHandler('process-test', handler);
+
+    queue.enqueue('process-test', { payload: { key: 'value' } });
+
+    const processed = await runner.processOnce();
+    expect(processed).toBe(1);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('processOnce fails jobs with no handler', async () => {
+    const id = queue.enqueue('no-handler-type');
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('failed');
+    expect(job!.error).toContain('No handler registered');
+  });
+
+  it('processOnce retries on handler error', async () => {
+    const handler = vi.fn().mockRejectedValue(new Error('transient'));
+    runner.registerHandler('flaky-type', handler);
+
+    const id = queue.enqueue('flaky-type');
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    // Should be pending again (retried), not failed
+    expect(job!.status).toBe('pending');
+    expect(job!.retryCount).toBe(1);
+  });
+
+  it('getStatus returns runner state', () => {
+    const status = runner.getStatus();
+    expect(status.running).toBe(false); // Not started yet
+    expect(status.pollIntervalMs).toBe(100);
+    expect(status.jobsProcessed).toBeGreaterThanOrEqual(1);
+  });
+
+  it('start/stop controls background polling', async () => {
+    runner.start();
+    expect(runner.getStatus().running).toBe(true);
+
+    runner.stop();
+    expect(runner.getStatus().running).toBe(false);
+  });
+
+  it('respects DAG in pipeline execution', async () => {
+    const order: string[] = [];
+    runner.registerHandler('dag-step', async (job) => {
+      order.push(job.id);
+      return { step: job.id };
+    });
+
+    const step1 = queue.enqueue('dag-step', { pipelineId: 'dag-test' });
+    const step2 = queue.enqueue('dag-step', { pipelineId: 'dag-test', dependsOn: [step1] });
+
+    // First batch: only step1 should process
+    await runner.processOnce();
+    expect(order).toEqual([step1]);
+
+    // Second batch: step2 should now be ready
+    await runner.processOnce();
+    expect(order).toEqual([step1, step2]);
+  });
+});