@fixy/core 0.0.0

package/src/__tests__/registry.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AdapterRegistry } from '../registry.js';
+import type { FixyAdapter } from '../adapter.js';
+
+function createStubAdapter(id: string, name: string): FixyAdapter {
+  return {
+    id,
+    name,
+    probe: async () => ({
+      available: true,
+      version: '1.0.0',
+      authStatus: 'ok' as const,
+      detail: null,
+    }),
+    execute: async () => ({
+      exitCode: 0,
+      signal: null,
+      timedOut: false,
+      summary: '',
+      session: null,
+      patches: [],
+      warnings: [],
+      errorMessage: null,
+    }),
+  };
+}
+
+describe('AdapterRegistry', () => {
+  let registry: AdapterRegistry;
+
+  beforeEach(() => {
+    registry = new AdapterRegistry();
+  });
+
+  it('register() adds adapters and list() returns them', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    registry.register(createStubAdapter('codex', 'Codex'));
+    expect(registry.list()).toHaveLength(2);
+  });
+
+  it('require() returns the correct adapter', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    expect(registry.require('claude').name).toBe('Claude');
+  });
+
+  it('require() throws for unknown id', () => {
+    expect(() => registry.require('unknown')).toThrow('Unknown adapter: unknown');
+  });
+
+  it('register() throws on duplicate id', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    expect(() => registry.register(createStubAdapter('claude', 'Claude 2'))).toThrow(
+      'Adapter already registered: claude',
+    );
+  });
+
+  it('unregister() removes the adapter', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    registry.unregister('claude');
+    expect(registry.has('claude')).toBe(false);
+  });
+
+  it('unregister() does not throw for unknown id', () => {
+    expect(() => registry.unregister('nonexistent')).not.toThrow();
+  });
+
+  it('get() returns adapter or undefined', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    expect(registry.get('claude')?.id).toBe('claude');
+    expect(registry.get('unknown')).toBeUndefined();
+  });
+
+  it('clear() removes all adapters', () => {
+    registry.register(createStubAdapter('claude', 'Claude'));
+    registry.register(createStubAdapter('codex', 'Codex'));
+    registry.clear();
+    expect(registry.list()).toHaveLength(0);
+  });
+});

package/src/__tests__/router.test.ts

@@ -0,0 +1,91 @@
+// packages/core/src/__tests__/router.test.ts
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Router } from '../router.js';
+import { AdapterRegistry } from '../registry.js';
+import type { FixyAdapter } from '../adapter.js';
+
+function createStubAdapter(id: string, name: string): FixyAdapter {
+  return {
+    id,
+    name,
+    probe: async () => ({
+      available: true,
+      version: '1.0.0',
+      authStatus: 'ok' as const,
+      detail: null,
+    }),
+    execute: async () => ({
+      exitCode: 0,
+      signal: null,
+      timedOut: false,
+      summary: '',
+      session: null,
+      patches: [],
+      warnings: [],
+      errorMessage: null,
+    }),
+  };
+}
+
+describe('Router', () => {
+  let registry: AdapterRegistry;
+  let router: Router;
+
+  beforeEach(() => {
+    registry = new AdapterRegistry();
+    registry.register(createStubAdapter('claude', 'Claude'));
+    registry.register(createStubAdapter('codex', 'Codex'));
+    router = new Router(registry);
+  });
+
+  it('rule 1: single mention dispatches to that adapter', () => {
+    const result = router.parse('@claude do something');
+    expect(result).toEqual({ kind: 'mention', agentIds: ['claude'], body: 'do something' });
+  });
+
+  it('rule 2: multi mention dispatches to all in order', () => {
+    const result = router.parse('@claude @codex brainstorm');
+    expect(result).toEqual({ kind: 'mention', agentIds: ['claude', 'codex'], body: 'brainstorm' });
+  });
+
+  it('rule 3: @fixy routes to fixy command handler', () => {
+    const result = router.parse('@fixy /status');
+    expect(result).toEqual({ kind: 'fixy', rest: '/status' });
+  });
+
+  it('rule 3: @fixy /worker with args', () => {
+    const result = router.parse('@fixy /worker claude');
+    expect(result).toEqual({ kind: 'fixy', rest: '/worker claude' });
+  });
+
+  it('rule 4: no mention falls to bare', () => {
+    const result = router.parse('just do it');
+    expect(result).toEqual({ kind: 'bare', body: 'just do it' });
+  });
+
+  it('rule 5: unknown mention returns error', () => {
+    const result = router.parse('@unknown do something');
+    expect(result).toEqual({ kind: 'error', reason: 'unknown agent: @unknown' });
+  });
+
+  it('empty string returns bare', () => {
+    const result = router.parse('');
+    expect(result).toEqual({ kind: 'bare', body: '' });
+  });
+
+  it('@fixy alone with no rest', () => {
+    const result = router.parse('@fixy');
+    expect(result).toEqual({ kind: 'fixy', rest: '' });
+  });
+
+  it('mixed known and unknown mentions returns error for unknown', () => {
+    const result = router.parse('@claude @unknown brainstorm');
+    expect(result).toEqual({ kind: 'error', reason: 'unknown agent: @unknown' });
+  });
+
+  it('@fixy takes priority even with other mentions after', () => {
+    const result = router.parse('@fixy @claude do something');
+    expect(result).toEqual({ kind: 'fixy', rest: '@claude do something' });
+  });
+});

package/src/__tests__/smoke.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest';
+
+describe('smoke test', () => {
+  it('should pass a basic assertion', () => {
+    expect(1 + 1).toBe(2);
+  });
+});

package/src/__tests__/store.test.ts

@@ -0,0 +1,151 @@
+// packages/core/src/__tests__/store.test.ts
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import { LocalThreadStore } from '../store.js';
+import type { FixyMessage } from '../thread.js';
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeMessage(content: string, role: 'user' | 'agent' | 'system' = 'user'): FixyMessage {
+  return {
+    id: randomUUID(),
+    createdAt: new Date().toISOString(),
+    role,
+    agentId: role === 'agent' ? 'claude' : null,
+    content,
+    runId: role === 'agent' ? randomUUID() : null,
+    dispatchedTo: role === 'user' ? ['claude'] : [],
+    patches: [],
+    warnings: [],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+let tempDir: string;
+let store: LocalThreadStore;
+const PROJECT_ROOT = '/tmp/fake-project';
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), 'fixy-test-'));
+  process.env['FIXY_HOME'] = tempDir;
+  store = new LocalThreadStore();
+  await store.init();
+});
+
+afterEach(async () => {
+  delete process.env['FIXY_HOME'];
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('LocalThreadStore', () => {
+  describe('createThread', () => {
+    it('creates a thread with correct projectRoot, status=active, and an id', async () => {
+      const thread = await store.createThread(PROJECT_ROOT);
+
+      expect(thread.id).toBeTruthy();
+      expect(typeof thread.id).toBe('string');
+      expect(thread.projectRoot).toBe(PROJECT_ROOT);
+      expect(thread.status).toBe('active');
+
+      // Verify the thread is also persisted on disk
+      const loaded = await store.getThread(thread.id, PROJECT_ROOT);
+      expect(loaded.id).toBe(thread.id);
+      expect(loaded.projectRoot).toBe(PROJECT_ROOT);
+      expect(loaded.status).toBe('active');
+    });
+  });
+
+  describe('appendMessage', () => {
+    it('appends multiple messages in order and persists them to disk', async () => {
+      const thread = await store.createThread(PROJECT_ROOT);
+
+      const msg1 = makeMessage('first message', 'user');
+      const msg2 = makeMessage('second message', 'agent');
+      const msg3 = makeMessage('third message', 'user');
+
+      await store.appendMessage(thread.id, PROJECT_ROOT, msg1);
+      await store.appendMessage(thread.id, PROJECT_ROOT, msg2);
+      await store.appendMessage(thread.id, PROJECT_ROOT, msg3);
+
+      // Reload from disk to confirm persistence
+      const loaded = await store.getThread(thread.id, PROJECT_ROOT);
+      expect(loaded.messages).toHaveLength(3);
+      expect(loaded.messages[0]).toHaveProperty('content', 'first message');
+      expect(loaded.messages[1]).toHaveProperty('content', 'second message');
+      expect(loaded.messages[2]).toHaveProperty('content', 'third message');
+    });
+  });
+
+  describe('getThread / listThreads', () => {
+    it('lists both threads and returns the correct one by id', async () => {
+      const threadA = await store.createThread(PROJECT_ROOT);
+      const threadB = await store.createThread(PROJECT_ROOT);
+
+      const threads = await store.listThreads(PROJECT_ROOT);
+      const ids = threads.map((t) => t.id);
+      expect(ids).toContain(threadA.id);
+      expect(ids).toContain(threadB.id);
+      expect(threads).toHaveLength(2);
+
+      const loadedA = await store.getThread(threadA.id, PROJECT_ROOT);
+      expect(loadedA.id).toBe(threadA.id);
+
+      const loadedB = await store.getThread(threadB.id, PROJECT_ROOT);
+      expect(loadedB.id).toBe(threadB.id);
+    });
+  });
+
+  describe('archiveThread', () => {
+    it('sets status to "archived" and persists the change', async () => {
+      const thread = await store.createThread(PROJECT_ROOT);
+      expect(thread.status).toBe('active');
+
+      const archived = await store.archiveThread(thread.id, PROJECT_ROOT);
+      expect(archived.status).toBe('archived');
+
+      // Reload from disk to confirm persistence
+      const loaded = await store.getThread(thread.id, PROJECT_ROOT);
+      expect(loaded.status).toBe('archived');
+    });
+  });
+
+  describe('atomic write safety', () => {
+    it('leaves no .tmp files in the threads directory after writes', async () => {
+      const thread = await store.createThread(PROJECT_ROOT);
+      await store.appendMessage(thread.id, PROJECT_ROOT, makeMessage('hello'));
+
+      // Derive the threads directory using the same path logic the store uses
+      const { getThreadsDir } = await import('../paths.js');
+      const threadsDir = getThreadsDir(PROJECT_ROOT);
+
+      const entries = await readdir(threadsDir);
+      const tmpFiles = entries.filter((name) => name.endsWith('.tmp'));
+      expect(tmpFiles).toHaveLength(0);
+    });
+  });
+
+  describe('appendMessage on non-existent thread', () => {
+    it('throws an error containing "Thread not found"', async () => {
+      const fakeId = randomUUID();
+      const msg = makeMessage('should fail');
+
+      await expect(store.appendMessage(fakeId, PROJECT_ROOT, msg)).rejects.toThrow(
+        'Thread not found',
+      );
+    });
+  });
+});

package/src/__tests__/turn.test.ts

@@ -0,0 +1,266 @@
+// packages/core/src/__tests__/turn.test.ts
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { TurnController } from '../turn.js';
+import { AdapterRegistry } from '../registry.js';
+import { LocalThreadStore } from '../store.js';
+import type { FixyAdapter, FixyExecutionContext, FixyExecutionResult } from '../adapter.js';
+import type { FixyThread } from '../thread.js';
+import type { TurnParams } from '../turn.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createStubAdapter(
+  id: string,
+  name: string,
+  executeFn?: (ctx: FixyExecutionContext) => Promise<FixyExecutionResult>,
+): FixyAdapter {
+  return {
+    id,
+    name,
+    probe: async () => ({
+      available: true,
+      version: '1.0.0',
+      authStatus: 'ok' as const,
+      detail: null,
+    }),
+    execute:
+      executeFn ??
+      (async () => ({
+        exitCode: 0,
+        signal: null,
+        timedOut: false,
+        summary: `response from ${id}`,
+        session: null,
+        patches: [],
+        warnings: [],
+        errorMessage: null,
+      })),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Suite
+// ---------------------------------------------------------------------------
+
+describe('TurnController', () => {
+  let tmpDir: string;
+  let store: LocalThreadStore;
+  let thread: FixyThread;
+  let registry: AdapterRegistry;
+  let controller: TurnController;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'fixy-turn-test-'));
+    process.env['FIXY_HOME'] = tmpDir;
+
+    store = new LocalThreadStore();
+    await store.init();
+
+    thread = await store.createThread('/tmp/fake-project');
+
+    registry = new AdapterRegistry();
+    registry.register(createStubAdapter('claude', 'Claude'));
+    registry.register(createStubAdapter('codex', 'Codex'));
+
+    controller = new TurnController();
+  });
+
+  afterEach(async () => {
+    delete process.env['FIXY_HOME'];
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  function makeParams(overrides?: Partial<TurnParams>): TurnParams {
+    return {
+      thread,
+      input: '',
+      registry,
+      store,
+      onLog: () => {},
+      signal: AbortSignal.timeout(5000),
+      ...overrides,
+    };
+  }
+
+  // -------------------------------------------------------------------------
+
+  it('single mention dispatches to the mentioned adapter', async () => {
+    await controller.runTurn(makeParams({ input: '@claude hello' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+
+    expect(updated.messages).toHaveLength(2);
+
+    const [userMsg, agentMsg] = updated.messages;
+    expect(userMsg.role).toBe('user');
+    expect(userMsg.content).toBe('@claude hello');
+
+    expect(agentMsg.role).toBe('agent');
+    expect(agentMsg.agentId).toBe('claude');
+    expect(agentMsg.content).toBe('response from claude');
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('multi mention dispatches sequentially, second sees first response', async () => {
+    const capturedMessages: typeof thread.messages = [];
+
+    registry.unregister('claude');
+    registry.unregister('codex');
+
+    registry.register(
+      createStubAdapter('claude', 'Claude', async () => ({
+        exitCode: 0,
+        signal: null,
+        timedOut: false,
+        summary: 'claude says hi',
+        session: null,
+        patches: [],
+        warnings: [],
+        errorMessage: null,
+      })),
+    );
+
+    registry.register(
+      createStubAdapter('codex', 'Codex', async (ctx) => {
+        capturedMessages.push(...ctx.messages);
+        return {
+          exitCode: 0,
+          signal: null,
+          timedOut: false,
+          summary: 'codex says bye',
+          session: null,
+          patches: [],
+          warnings: [],
+          errorMessage: null,
+        };
+      }),
+    );
+
+    await controller.runTurn(makeParams({ input: '@claude @codex brainstorm' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+
+    expect(updated.messages).toHaveLength(3);
+    expect(updated.messages[0].role).toBe('user');
+    expect(updated.messages[1].role).toBe('agent');
+    expect(updated.messages[1].agentId).toBe('claude');
+    expect(updated.messages[2].role).toBe('agent');
+    expect(updated.messages[2].agentId).toBe('codex');
+
+    // Codex's execute received messages that include claude's response.
+    const claudeResponseInCodexCtx = capturedMessages.find(
+      (m) => m.role === 'agent' && m.agentId === 'claude' && m.content === 'claude says hi',
+    );
+    expect(claudeResponseInCodexCtx).toBeDefined();
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('bare message falls to last agent that spoke', async () => {
+    const { randomUUID } = await import('node:crypto');
+
+    // Manually append an agent message from codex so it is the last agent.
+    await store.appendMessage(thread.id, thread.projectRoot, {
+      id: randomUUID(),
+      createdAt: new Date().toISOString(),
+      role: 'agent',
+      agentId: 'codex',
+      content: 'previous codex response',
+      runId: randomUUID(),
+      dispatchedTo: [],
+      patches: [],
+      warnings: [],
+    });
+
+    // Re-read so the thread object held by TurnController has the new message.
+    thread = await store.getThread(thread.id, thread.projectRoot);
+
+    await controller.runTurn(makeParams({ input: 'continue', thread }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+    const lastAgentMsg = [...updated.messages].reverse().find((m) => m.role === 'agent');
+
+    expect(lastAgentMsg?.agentId).toBe('codex');
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('bare message falls to workerModel when no prior agent', async () => {
+    // Thread has no messages yet; workerModel defaults to 'claude'.
+    expect(thread.messages).toHaveLength(0);
+    expect(thread.workerModel).toBe('claude');
+
+    await controller.runTurn(makeParams({ input: 'hello' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+    const agentMsg = updated.messages.find((m) => m.role === 'agent');
+
+    expect(agentMsg?.agentId).toBe('claude');
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('@fixy /status returns adapter status', async () => {
+    await controller.runTurn(makeParams({ input: '@fixy /status' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+    const systemMsg = updated.messages.find((m) => m.role === 'system');
+
+    expect(systemMsg).toBeDefined();
+    expect(systemMsg?.content).toContain('claude');
+    expect(systemMsg?.content).toContain('codex');
+    expect(systemMsg?.content).toContain('yes');
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('@fixy /worker changes workerModel', async () => {
+    expect(thread.workerModel).toBe('claude');
+
+    await controller.runTurn(makeParams({ input: '@fixy /worker codex' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+    expect(updated.workerModel).toBe('codex');
+
+    const systemMsg = updated.messages.find((m) => m.role === 'system');
+    expect(systemMsg?.content).toBe('worker set to codex');
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('unknown mention appends error system message', async () => {
+    await controller.runTurn(makeParams({ input: '@unknown do stuff' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+
+    const systemMsg = updated.messages.find((m) => m.role === 'system');
+    expect(systemMsg?.content).toBe('unknown agent: @unknown');
+
+    const agentMsgs = updated.messages.filter((m) => m.role === 'agent');
+    expect(agentMsgs).toHaveLength(0);
+  });
+
+  // -------------------------------------------------------------------------
+
+  it('4 mentions rejects with max adapters message', async () => {
+    registry.register(createStubAdapter('aider', 'Aider'));
+    registry.register(createStubAdapter('gemini', 'Gemini'));
+
+    await controller.runTurn(makeParams({ input: '@claude @codex @aider @gemini do stuff' }));
+
+    const updated = await store.getThread(thread.id, thread.projectRoot);
+
+    const systemMsg = updated.messages.find((m) => m.role === 'system');
+    expect(systemMsg?.content).toContain('maximum 3 adapters per turn');
+
+    const agentMsgs = updated.messages.filter((m) => m.role === 'agent');
+    expect(agentMsgs).toHaveLength(0);
+  });
+});