@mseep/claudian 2.0.25

package/tests/unit/providers/pi/runtime/PiCliResolver.test.ts

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { PiCliResolver } from '@/providers/pi/runtime/PiCliResolver';
+
+jest.mock('fs');
+jest.mock('@/utils/env', () => ({
+  ...jest.requireActual('@/utils/env'),
+  getHostnameKey: () => 'current-host',
+}));
+
+const mockedStat = fs.statSync as jest.Mock;
+
+describe('PiCliResolver', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
+  });
+
+  it('resolves the current host path before the legacy Pi CLI path', () => {
+    mockedStat.mockImplementation((filePath: string) => {
+      if (filePath === '/current/pi') {
+        return { isFile: () => true };
+      }
+      throw new Error(`ENOENT: ${filePath}`);
+    });
+
+    const resolver = new PiCliResolver();
+
+    expect(resolver.resolve({
+      'current-host': '/current/pi',
+      'other-host': '/other/pi',
+    }, '/legacy/pi')).toBe('/current/pi');
+  });
+
+  it('falls back to cliPath and returns null for invalid paths', () => {
+    mockedStat.mockImplementation((filePath: string) => {
+      if (filePath === '/legacy/pi') {
+        return { isFile: () => true };
+      }
+      throw new Error(`ENOENT: ${filePath}`);
+    });
+
+    const resolver = new PiCliResolver();
+    expect(resolver.resolve({ 'other-host': '/other/pi' }, '/legacy/pi')).toBe('/legacy/pi');
+
+    mockedStat.mockImplementation(() => {
+      throw new Error('ENOENT');
+    });
+    expect(resolver.resolve({ 'other-host': '/other/pi' }, '/legacy/pi')).toBeNull();
+  });
+
+  it('falls back to PATH lookup when no Pi CLI path is configured', () => {
+    const pathDir = '/custom/bin';
+    const pathBinary = path.join(pathDir, 'pi');
+    mockedStat.mockImplementation((filePath: string) => {
+      if (filePath === pathBinary) {
+        return { isFile: () => true };
+      }
+      throw new Error(`ENOENT: ${filePath}`);
+    });
+
+    const resolver = new PiCliResolver();
+
+    expect(resolver.resolve({}, '', `PATH=${pathDir}`)).toBe(pathBinary);
+  });
+
+  it('invalidates cached resolutions when provider environment changes', () => {
+    mockedStat.mockImplementation((filePath: string) => {
+      if (filePath === '/current/pi') {
+        return { isFile: () => true };
+      }
+      throw new Error(`ENOENT: ${filePath}`);
+    });
+
+    const resolver = new PiCliResolver();
+    const firstSettings = {
+      providerConfigs: {
+        pi: {
+          cliPathsByHost: {
+            'current-host': '/current/pi',
+          },
+          environmentVariables: 'PI_OFFLINE=0',
+        },
+      },
+    };
+    const secondSettings = {
+      providerConfigs: {
+        pi: {
+          cliPathsByHost: {
+            'current-host': '/current/pi',
+          },
+          environmentVariables: 'PI_OFFLINE=1',
+        },
+      },
+    };
+
+    expect(resolver.resolveFromSettings(firstSettings)).toBe('/current/pi');
+    expect(resolver.resolveFromSettings(firstSettings)).toBe('/current/pi');
+    expect(mockedStat).toHaveBeenCalledTimes(1);
+
+    expect(resolver.resolveFromSettings(secondSettings)).toBe('/current/pi');
+    expect(mockedStat).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/unit/providers/pi/runtime/PiEventNormalization.test.ts

@@ -0,0 +1,147 @@
+import {
+  createPiEventNormalizationState,
+  normalizePiRpcEvent,
+} from '@/providers/pi/normalizations/piEventNormalization';
+
+describe('Pi event normalization', () => {
+  it('normalizes text and thinking deltas', () => {
+    const state = createPiEventNormalizationState();
+    expect(normalizePiRpcEvent({
+      assistantMessageEvent: { text_delta: 'hello' },
+      type: 'message_update',
+    }, state)).toEqual([{ type: 'text', content: 'hello' }]);
+    expect(normalizePiRpcEvent({
+      assistantMessageEvent: { thinking_delta: 'hmm' },
+      type: 'message_update',
+    }, state)).toEqual([{ type: 'thinking', content: 'hmm' }]);
+  });
+
+  it('dedupes tool use and maps output/result chunks', () => {
+    const state = createPiEventNormalizationState();
+    expect(normalizePiRpcEvent({
+      id: 'tool-1',
+      input: { path: 'a.md' },
+      name: 'read',
+      type: 'toolcall_end',
+    }, state)).toEqual([{
+      id: 'tool-1',
+      input: { file_path: 'a.md', path: 'a.md' },
+      name: 'Read',
+      type: 'tool_use',
+    }]);
+    expect(normalizePiRpcEvent({
+      id: 'tool-1',
+      input: { path: 'a.md' },
+      name: 'read',
+      type: 'tool_execution_start',
+    }, state)).toEqual([]);
+    expect(normalizePiRpcEvent({
+      id: 'tool-1',
+      partialResult: { content: [{ text: 'partial', type: 'text' }] },
+      type: 'tool_execution_update',
+    }, state)).toEqual([{ id: 'tool-1', content: 'partial', type: 'tool_output' }]);
+    expect(normalizePiRpcEvent({
+      id: 'tool-1',
+      result: { content: [{ text: 'done', type: 'text' }] },
+      type: 'tool_execution_end',
+    }, state)).toEqual([{
+      id: 'tool-1',
+      content: 'done',
+      isError: false,
+      toolUseResult: { content: [{ text: 'done', type: 'text' }] },
+      type: 'tool_result',
+    }]);
+  });
+
+  it('normalizes Pi RPC toolName and args to shared renderer tool shapes', () => {
+    const state = createPiEventNormalizationState();
+
+    expect(normalizePiRpcEvent({
+      args: { command: 'pwd' },
+      toolCallId: 'bash-1',
+      toolName: 'bash',
+      type: 'tool_execution_start',
+    }, state)).toEqual([{
+      id: 'bash-1',
+      input: { command: 'pwd' },
+      name: 'Bash',
+      type: 'tool_use',
+    }]);
+
+    expect(normalizePiRpcEvent({
+      args: { pattern: 'src/**/*.ts' },
+      toolCallId: 'find-1',
+      toolName: 'find',
+      type: 'tool_execution_start',
+    }, state)).toEqual([{
+      id: 'find-1',
+      input: { pattern: 'src/**/*.ts' },
+      name: 'Glob',
+      type: 'tool_use',
+    }]);
+  });
+
+  it('preserves Pi write/edit result payloads for diff extraction', () => {
+    const state = createPiEventNormalizationState();
+
+    expect(normalizePiRpcEvent({
+      args: { content: 'new text', path: 'notes/a.md' },
+      toolCallId: 'write-1',
+      toolName: 'write',
+      type: 'tool_execution_start',
+    }, state)).toEqual([{
+      id: 'write-1',
+      input: { content: 'new text', file_path: 'notes/a.md', path: 'notes/a.md' },
+      name: 'Write',
+      type: 'tool_use',
+    }]);
+
+    expect(normalizePiRpcEvent({
+      isError: false,
+      result: {
+        content: [{ text: 'Edited notes/a.md', type: 'text' }],
+        details: { diff: '--- a/notes/a.md\n+++ b/notes/a.md\n@@ -1 +1 @@\n-old\n+new' },
+      },
+      toolCallId: 'write-1',
+      toolName: 'write',
+      type: 'tool_execution_end',
+    }, state)).toEqual([{
+      id: 'write-1',
+      content: 'Edited notes/a.md',
+      isError: false,
+      toolUseResult: {
+        content: [{ text: 'Edited notes/a.md', type: 'text' }],
+        details: { diff: '--- a/notes/a.md\n+++ b/notes/a.md\n@@ -1 +1 @@\n-old\n+new' },
+      },
+      type: 'tool_result',
+    }]);
+  });
+
+  it('maps compaction and extension errors', () => {
+    const state = createPiEventNormalizationState();
+    expect(normalizePiRpcEvent({ type: 'compaction_end' }, state)).toEqual([{ type: 'context_compacted' }]);
+    expect(normalizePiRpcEvent({ error: 'extension failed', type: 'extension_error' }, state)).toEqual([{
+      content: 'extension failed',
+      level: 'warning',
+      type: 'notice',
+    }]);
+  });
+
+  it('surfaces terminal Pi stop-reason errors', () => {
+    const state = createPiEventNormalizationState();
+
+    expect(normalizePiRpcEvent({
+      errorMessage: 'Invalid image',
+      stopReason: 'error',
+      type: 'message_end',
+    }, state)).toEqual([{ type: 'error', content: 'Invalid image' }]);
+
+    expect(normalizePiRpcEvent({
+      assistant_message_event: {
+        error_message: 'Authentication failed',
+        stop_reason: 'error',
+      },
+      type: 'turn_end',
+    }, state)).toEqual([{ type: 'error', content: 'Authentication failed' }]);
+  });
+});

package/tests/unit/providers/pi/runtime/PiExtensionUiBridge.test.ts

@@ -0,0 +1,98 @@
+import { PiExtensionUiBridge, type PiExtensionUiRenderer } from '@/providers/pi/runtime/PiExtensionUiBridge';
+import type { PiRpcTransport } from '@/providers/pi/runtime/PiRpcTransport';
+
+function createBridge(renderer: Partial<PiExtensionUiRenderer>) {
+  const transport = {
+    send: jest.fn(),
+  } as unknown as PiRpcTransport;
+  const bridge = new PiExtensionUiBridge(transport, renderer as PiExtensionUiRenderer);
+  return { bridge, transport };
+}
+
+describe('PiExtensionUiBridge', () => {
+  it('sends dialog responses through the transport', async () => {
+    const renderer = {
+      select: jest.fn().mockResolvedValue({ value: 'choice-a' }),
+    };
+    const { bridge, transport } = createBridge(renderer);
+
+    expect(bridge.handleRequest({ id: 'ui-1', method: 'select', type: 'extension_ui_request' })).toBe(true);
+    await Promise.resolve();
+
+    expect(renderer.select).toHaveBeenCalled();
+    expect(transport.send).toHaveBeenCalledWith({
+      id: 'ui-1',
+      type: 'extension_ui_response',
+      value: 'choice-a',
+    });
+  });
+
+  it('cancels dialog requests when no renderer is available', () => {
+    const transport = {
+      send: jest.fn(),
+    } as unknown as PiRpcTransport;
+    const bridge = new PiExtensionUiBridge(transport, null);
+
+    bridge.handleRequest({ id: 'ui-1', method: 'confirm', type: 'extension_ui_request' });
+
+    expect(transport.send).toHaveBeenCalledWith({
+      cancelled: true,
+      id: 'ui-1',
+      type: 'extension_ui_response',
+    });
+  });
+
+  it('handles notify without sending a response', () => {
+    const renderer = {
+      notify: jest.fn(),
+    };
+    const { bridge, transport } = createBridge(renderer);
+
+    bridge.handleRequest({ message: 'hello', method: 'notify', type: 'extension_ui_request' });
+
+    expect(renderer.notify).toHaveBeenCalledWith({
+      message: 'hello',
+      method: 'notify',
+      type: 'extension_ui_request',
+    });
+    expect(transport.send).not.toHaveBeenCalled();
+  });
+
+  it('cancels pending dialogs on cleanup', () => {
+    const renderer = {
+      input: jest.fn((_request: unknown, signal: AbortSignal) => new Promise<{ cancelled?: boolean }>((resolve) => {
+        signal.addEventListener('abort', () => resolve({ cancelled: true }));
+      })),
+    };
+    const { bridge, transport } = createBridge(renderer);
+
+    bridge.handleRequest({ id: 'ui-1', method: 'input', type: 'extension_ui_request' });
+    bridge.cleanup();
+
+    expect(transport.send).toHaveBeenCalledWith({
+      cancelled: true,
+      id: 'ui-1',
+      type: 'extension_ui_response',
+    });
+  });
+
+  it('does not send duplicate cancellation responses when cleanup aborts a rejecting renderer', async () => {
+    const renderer = {
+      input: jest.fn((_request: unknown, signal: AbortSignal) => new Promise<never>((_resolve, reject) => {
+        signal.addEventListener('abort', () => reject(new Error('aborted')));
+      })),
+    };
+    const { bridge, transport } = createBridge(renderer);
+
+    bridge.handleRequest({ id: 'ui-1', method: 'input', type: 'extension_ui_request' });
+    bridge.cleanup();
+    await Promise.resolve();
+
+    expect(transport.send).toHaveBeenCalledTimes(1);
+    expect(transport.send).toHaveBeenCalledWith({
+      cancelled: true,
+      id: 'ui-1',
+      type: 'extension_ui_response',
+    });
+  });
+});

package/tests/unit/providers/pi/runtime/PiJsonl.test.ts

@@ -0,0 +1,42 @@
+import { PassThrough } from 'node:stream';
+
+import { subscribePiJsonlLines, writePiJsonl } from '@/providers/pi/runtime/PiJsonl';
+
+describe('PiJsonl', () => {
+  it('splits only on LF and strips CR', () => {
+    const stream = new PassThrough();
+    const lines: string[] = [];
+    subscribePiJsonlLines(stream, line => lines.push(line));
+    const separator = String.fromCharCode(0x2028);
+    const paragraphSeparator = String.fromCharCode(0x2029);
+
+    stream.write(`{"a":1}\r\n{"b":"line${separator}separator${paragraphSeparator}still same record"}\n`);
+
+    expect(lines).toEqual([
+      '{"a":1}',
+      `{"b":"line${separator}separator${paragraphSeparator}still same record"}`,
+    ]);
+  });
+
+  it('emits trailing buffered records on end', async () => {
+    const stream = new PassThrough();
+    const lines: string[] = [];
+    subscribePiJsonlLines(stream, line => lines.push(line));
+
+    stream.write('{"a":1}');
+    stream.end();
+    await new Promise(resolve => setImmediate(resolve));
+
+    expect(lines).toEqual(['{"a":1}']);
+  });
+
+  it('writes JSONL records', () => {
+    const output = new PassThrough();
+    const chunks: string[] = [];
+    output.on('data', chunk => chunks.push(chunk.toString('utf8')));
+
+    writePiJsonl(output, { type: 'ping' });
+
+    expect(chunks.join('')).toBe('{"type":"ping"}\n');
+  });
+});

package/tests/unit/providers/pi/runtime/PiLaunchSpec.test.ts

@@ -0,0 +1,92 @@
+import { buildPiLaunchSpec } from '@/providers/pi/runtime/PiLaunchSpec';
+import type { PiProviderSettings } from '@/providers/pi/settings';
+
+const baseSettings: PiProviderSettings = {
+  cliPath: '',
+  cliPathsByHost: {},
+  discoveredModels: [],
+  enabled: true,
+  environmentHash: '',
+  environmentVariables: '',
+  modelAliases: {},
+  preferredThinkingByModel: {},
+  toolMode: 'all',
+  visibleModels: [],
+};
+
+describe('PiLaunchSpec', () => {
+  it('builds main launch args with replacement system prompt and model flags', () => {
+    expect(buildPiLaunchSpec({
+      command: '/bin/pi',
+      cwd: '/vault',
+      model: 'pi:anthropic/claude/sonnet',
+      providerState: { sessionFile: '/tmp/session.jsonl' },
+      settings: baseSettings,
+      systemPrompt: 'System prompt',
+      thinkingLevel: 'high',
+    }).args).toEqual([
+      '--mode',
+      'rpc',
+      '--system-prompt',
+      'System prompt',
+      '--session',
+      '/tmp/session.jsonl',
+      '--provider',
+      'anthropic',
+      '--model',
+      'claude/sonnet',
+      '--thinking',
+      'high',
+    ]);
+  });
+
+  it('adds no-session and read-only tools when requested', () => {
+    expect(buildPiLaunchSpec({
+      command: 'pi',
+      cwd: '/vault',
+      noSession: true,
+      settings: {
+        ...baseSettings,
+        toolMode: 'readonly',
+      },
+    }).args).toEqual([
+      '--mode',
+      'rpc',
+      '--no-session',
+      '--tools',
+      'read,grep,find,ls',
+    ]);
+  });
+
+  it('uses no-tools for passive auxiliary launches', () => {
+    expect(buildPiLaunchSpec({
+      command: 'pi',
+      cwd: '/vault',
+      noSession: true,
+      noTools: true,
+      settings: baseSettings,
+    }).args).toEqual([
+      '--mode',
+      'rpc',
+      '--no-session',
+      '--no-tools',
+    ]);
+  });
+
+  it('includes full runtime environment text in the launch key', () => {
+    const first = buildPiLaunchSpec({
+      command: 'pi',
+      cwd: '/vault',
+      envText: 'PATH=/first',
+      settings: baseSettings,
+    });
+    const second = buildPiLaunchSpec({
+      command: 'pi',
+      cwd: '/vault',
+      envText: 'PATH=/second',
+      settings: baseSettings,
+    });
+
+    expect(first.launchKey).not.toBe(second.launchKey);
+  });
+});

package/tests/unit/providers/pi/runtime/PiModelDiscoveryService.test.ts

@@ -0,0 +1,135 @@
+import '@/providers';
+
+const mockTransportRequest = jest.fn();
+const mockTransportSend = jest.fn();
+const mockTransportStart = jest.fn();
+const mockTransportDispose = jest.fn();
+const mockTransportOnEvent = jest.fn();
+const mockRemoveEventListener = jest.fn();
+const mockProcessStart = jest.fn();
+const mockProcessShutdown = jest.fn().mockResolvedValue(undefined);
+const mockProcessOnClose = jest.fn();
+const mockGetStderrSnapshot = jest.fn(() => '');
+let mockEventHandler: ((event: Record<string, unknown>) => void) | null = null;
+
+jest.mock('@/providers/pi/runtime/PiRpcTransport', () => ({
+  PiRpcTransport: jest.fn().mockImplementation(() => ({
+    dispose: mockTransportDispose,
+    onEvent: mockTransportOnEvent,
+    request: mockTransportRequest,
+    send: mockTransportSend,
+    start: mockTransportStart,
+  })),
+}));
+
+jest.mock('@/providers/pi/runtime/PiSubprocess', () => ({
+  PiSubprocess: jest.fn().mockImplementation(() => ({
+    getStderrSnapshot: mockGetStderrSnapshot,
+    onClose: mockProcessOnClose,
+    shutdown: mockProcessShutdown,
+    start: mockProcessStart,
+    stdin: {},
+    stdout: {},
+  })),
+}));
+
+import { PiModelDiscoveryService } from '@/providers/pi/runtime/PiModelDiscoveryService';
+
+function createPlugin() {
+  return {
+    app: {
+      vault: {
+        adapter: {
+          basePath: '/tmp/vault',
+        },
+      },
+    },
+    getResolvedProviderCliPath: jest.fn(() => '/usr/local/bin/pi'),
+    settings: {
+      providerConfigs: {
+        pi: {
+          enabled: true,
+        },
+      },
+    },
+  } as any;
+}
+
+describe('PiModelDiscoveryService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockEventHandler = null;
+    mockGetStderrSnapshot.mockReturnValue('');
+    mockTransportOnEvent.mockImplementation((handler: (event: Record<string, unknown>) => void) => {
+      mockEventHandler = handler;
+      return mockRemoveEventListener;
+    });
+  });
+
+  it('discovers and normalizes Pi models through a short-lived no-session runtime', async () => {
+    mockTransportRequest.mockResolvedValue({
+      models: [{
+        contextWindow: 200000,
+        id: 'gpt-5',
+        input: ['text', 'image'],
+        maxTokens: 8192,
+        name: 'GPT-5',
+        provider: 'openai',
+        reasoning: true,
+      }],
+    });
+
+    const result = await new PiModelDiscoveryService(createPlugin()).discoverModels();
+
+    expect(result.diagnostics).toBeUndefined();
+    expect(result.models).toEqual([{
+      contextWindow: 200000,
+      encodedId: 'pi:openai/gpt-5',
+      id: 'gpt-5',
+      input: ['text', 'image'],
+      label: 'GPT-5',
+      maxTokens: 8192,
+      provider: 'openai',
+      reasoning: true,
+      thinkingLevels: ['off', 'minimal', 'low', 'medium', 'high'],
+    }]);
+    expect(mockProcessStart).toHaveBeenCalled();
+    expect(mockTransportStart).toHaveBeenCalled();
+    expect(mockTransportRequest).toHaveBeenCalledWith('get_available_models', {}, 20_000);
+    expect(mockRemoveEventListener).toHaveBeenCalled();
+    expect(mockTransportDispose).toHaveBeenCalled();
+    expect(mockProcessShutdown).toHaveBeenCalled();
+  });
+
+  it('cancels extension UI requests during discovery', async () => {
+    mockTransportRequest.mockImplementation(async () => {
+      mockEventHandler?.({
+        id: 'ui-1',
+        type: 'extension_ui_request',
+      });
+      return { models: [] };
+    });
+
+    await new PiModelDiscoveryService(createPlugin()).discoverModels();
+
+    expect(mockTransportSend).toHaveBeenCalledWith({
+      cancelled: true,
+      id: 'ui-1',
+      type: 'extension_ui_response',
+    });
+  });
+
+  it('returns diagnostics and still shuts down when discovery fails', async () => {
+    mockTransportRequest.mockRejectedValue(new Error('not logged in'));
+    mockGetStderrSnapshot.mockReturnValue('Pi stderr');
+
+    const result = await new PiModelDiscoveryService(createPlugin()).discoverModels();
+
+    expect(result).toEqual({
+      diagnostics: 'not logged in\n\nPi stderr',
+      models: [],
+    });
+    expect(mockTransportDispose).toHaveBeenCalled();
+    expect(mockProcessShutdown).toHaveBeenCalled();
+  });
+});

package/tests/unit/providers/pi/runtime/PiRpcPayloads.test.ts

@@ -0,0 +1,15 @@
+import { buildPiSetModelPayload } from '@/providers/pi/runtime/PiRpcPayloads';
+
+describe('Pi RPC payload builders', () => {
+  it('uses Pi RPC modelId field for set_model payloads', () => {
+    expect(buildPiSetModelPayload('pi:openai-codex/gpt-5.2')).toEqual({
+      modelId: 'gpt-5.2',
+      provider: 'openai-codex',
+    });
+  });
+
+  it('rejects invalid Pi model ids', () => {
+    expect(buildPiSetModelPayload('openai-codex/gpt-5.2')).toBeNull();
+    expect(buildPiSetModelPayload('pi:openai-codex')).toBeNull();
+  });
+});