@mseep/claudian 2.0.25

package/tests/unit/providers/opencode/OpencodeSqliteReader.test.ts

@@ -0,0 +1,185 @@
+import type { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+import {
+  loadOpencodeSessionRows,
+  OPENCODE_MESSAGE_ROW_SQL,
+  OPENCODE_SQLITE_QUERY_MAX_BUFFER,
+} from '../../../../src/providers/opencode/history/OpencodeSqliteReader';
+
+type SpawnSync = typeof nodeSpawnSync;
+
+describe('loadOpencodeSessionRows', () => {
+  let tmpRoot: string;
+
+  beforeEach(() => {
+    tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'claudian-opencode-sqlite-reader-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpRoot, { force: true, recursive: true });
+    jest.restoreAllMocks();
+  });
+
+  it('loads rows through a Node child process when in-process SQLite is unavailable', async () => {
+    const dbPath = createFixtureDatabase(tmpRoot);
+
+    await expect(loadOpencodeSessionRows(dbPath, 'ses-child', {
+      findNodeExecutable: () => process.execPath,
+      requireSqliteModule: () => null,
+    })).resolves.toEqual({
+      messageRows: [{
+        data_time_completed: null,
+        data_time_created: 1_000,
+        data_valid: 1,
+        id: 'msg-user',
+        role: 'user',
+        time_created: 1_000,
+      }],
+      partRows: [{
+        data: JSON.stringify({ text: 'Hello from child process.', type: 'text' }),
+        id: 'part-user',
+        message_id: 'msg-user',
+      }],
+    });
+  });
+
+  it('uses a discovered Node executable before the system sqlite3 fallback', async () => {
+    const spawnSync = jest.fn().mockReturnValue({
+      error: undefined,
+      status: 0,
+      stdout: JSON.stringify({
+        messageRows: [{ id: 'msg-user' }],
+        partRows: [{ id: 'part-user' }],
+      }),
+    });
+
+    await expect(loadOpencodeSessionRows('/tmp/opencode.db', 'ses-node', {
+      findNodeExecutable: () => '/usr/local/bin/node',
+      requireSqliteModule: () => null,
+      spawnSync: toSpawnSync(spawnSync),
+    })).resolves.toEqual({
+      messageRows: [{ id: 'msg-user' }],
+      partRows: [{ id: 'part-user' }],
+    });
+
+    expect(spawnSync).toHaveBeenCalledTimes(1);
+    expect(spawnSync).toHaveBeenCalledWith(
+      '/usr/local/bin/node',
+      [
+        '-e',
+        expect.stringContaining("require('node:sqlite')"),
+        '/tmp/opencode.db',
+        'ses-node',
+        OPENCODE_MESSAGE_ROW_SQL,
+        expect.stringContaining('from part'),
+      ],
+      expect.objectContaining({
+        encoding: 'utf8',
+        maxBuffer: OPENCODE_SQLITE_QUERY_MAX_BUFFER,
+        windowsHide: true,
+      }),
+    );
+  });
+
+  it('keeps sqlite3 as a buffered compatibility fallback', async () => {
+    const spawnSync = jest.fn()
+      .mockReturnValueOnce({
+        error: undefined,
+        status: 0,
+        stdout: JSON.stringify([{ id: 'msg-user' }]),
+      })
+      .mockReturnValueOnce({
+        error: undefined,
+        status: 0,
+        stdout: JSON.stringify([{ id: 'part-user' }]),
+      });
+
+    await expect(loadOpencodeSessionRows('/tmp/opencode.db', 'ses-with-quote\'s', {
+      findNodeExecutable: () => null,
+      requireSqliteModule: () => null,
+      spawnSync: toSpawnSync(spawnSync),
+    })).resolves.toEqual({
+      messageRows: [{ id: 'msg-user' }],
+      partRows: [{ id: 'part-user' }],
+    });
+
+    expect(spawnSync).toHaveBeenCalledTimes(2);
+    expect(spawnSync).toHaveBeenNthCalledWith(
+      1,
+      'sqlite3',
+      [
+        '-json',
+        '/tmp/opencode.db',
+        expect.stringContaining("where session_id = 'ses-with-quote''s'"),
+      ],
+      expect.objectContaining({
+        encoding: 'utf8',
+        maxBuffer: OPENCODE_SQLITE_QUERY_MAX_BUFFER,
+        windowsHide: true,
+      }),
+    );
+    expect(spawnSync).toHaveBeenNthCalledWith(
+      2,
+      'sqlite3',
+      [
+        '-json',
+        '/tmp/opencode.db',
+        expect.stringContaining("where session_id = 'ses-with-quote''s'"),
+      ],
+      expect.objectContaining({
+        encoding: 'utf8',
+        maxBuffer: OPENCODE_SQLITE_QUERY_MAX_BUFFER,
+        windowsHide: true,
+      }),
+    );
+  });
+});
+
+function toSpawnSync(mock: jest.Mock): SpawnSync {
+  return mock as unknown as SpawnSync;
+}
+
+function createFixtureDatabase(tmpRoot: string): string {
+  const dbPath = path.join(tmpRoot, 'opencode.db');
+  const db = new DatabaseSync(dbPath);
+  try {
+    db.exec(`
+      create table message (
+        id text primary key,
+        session_id text not null,
+        time_created integer not null,
+        data text not null
+      );
+      create table part (
+        id text primary key,
+        session_id text not null,
+        message_id text not null,
+        data text not null
+      );
+    `);
+
+    db.prepare('insert into message (id, session_id, time_created, data) values (?, ?, ?, ?)').run(
+      'msg-user',
+      'ses-child',
+      1_000,
+      JSON.stringify({
+        role: 'user',
+        time: { created: 1_000 },
+      }),
+    );
+    db.prepare('insert into part (id, session_id, message_id, data) values (?, ?, ?, ?)').run(
+      'part-user',
+      'ses-child',
+      'msg-user',
+      JSON.stringify({ text: 'Hello from child process.', type: 'text' }),
+    );
+  } finally {
+    db.close();
+  }
+
+  return dbPath;
+}

package/tests/unit/providers/opencode/agents/OpencodeAgentMentionProvider.test.ts

@@ -0,0 +1,56 @@
+import { OpencodeAgentMentionProvider } from '@/providers/opencode/agents/OpencodeAgentMentionProvider';
+import type { OpencodeAgentStorage } from '@/providers/opencode/storage/OpencodeAgentStorage';
+import type { OpencodeAgentDefinition } from '@/providers/opencode/types/agent';
+
+function makeAgent(overrides: Partial<OpencodeAgentDefinition> = {}): OpencodeAgentDefinition {
+  return {
+    name: 'test-agent',
+    description: 'A test agent',
+    prompt: 'Do useful work.',
+    ...overrides,
+  };
+}
+
+function makeMockStorage(agents: OpencodeAgentDefinition[] = []): OpencodeAgentStorage {
+  return { loadAll: async () => agents } as unknown as OpencodeAgentStorage;
+}
+
+describe('OpencodeAgentMentionProvider', () => {
+  it('returns an empty array before loadAgents is called', () => {
+    const provider = new OpencodeAgentMentionProvider(makeMockStorage([makeAgent()]));
+    expect(provider.searchAgents('')).toEqual([]);
+  });
+
+  it('returns only explicit subagents after load', async () => {
+    const provider = new OpencodeAgentMentionProvider(makeMockStorage([
+      makeAgent({ name: 'review', description: 'Reviews code', mode: 'subagent' }),
+      makeAgent({ name: 'plan', description: 'Plans work', mode: 'all' }),
+      makeAgent({ name: 'general', description: 'Uses the default all-mode behavior' }),
+      makeAgent({ name: 'build', description: 'Primary only', mode: 'primary' }),
+      makeAgent({ name: 'hidden-review', description: 'Hidden', hidden: true, mode: 'subagent' }),
+      makeAgent({ name: 'disabled-review', description: 'Disabled', disable: true, mode: 'subagent' }),
+    ]));
+    await provider.loadAgents();
+
+    expect(provider.searchAgents('')).toEqual([
+      {
+        id: 'review',
+        name: 'review',
+        description: 'Reviews code',
+        source: 'vault',
+      },
+    ]);
+  });
+
+  it('filters case-insensitively by name and description', async () => {
+    const provider = new OpencodeAgentMentionProvider(makeMockStorage([
+      makeAgent({ name: 'security/review', description: 'Finds auth issues', mode: 'subagent' }),
+      makeAgent({ name: 'perf/explore', description: 'Profiles hot paths', mode: 'subagent' }),
+    ]));
+    await provider.loadAgents();
+
+    expect(provider.searchAgents('SECURITY')).toHaveLength(1);
+    expect(provider.searchAgents('auth')).toHaveLength(1);
+    expect(provider.searchAgents('missing')).toEqual([]);
+  });
+});

package/tests/unit/providers/opencode/buildOpencodePrompt.test.ts

@@ -0,0 +1,87 @@
+import { buildOpencodePromptBlocks, buildOpencodePromptText } from '../../../../src/providers/opencode/runtime/buildOpencodePrompt';
+
+describe('buildOpencodePromptText', () => {
+  it('appends Claudian XML context to the user query', () => {
+    const prompt = buildOpencodePromptText({
+      browserSelection: {
+        selectedText: 'Browser quote',
+        source: 'browser:https://example.com',
+        title: 'Example',
+        url: 'https://example.com',
+      },
+      currentNotePath: 'notes/today.md',
+      editorSelection: {
+        mode: 'selection',
+        notePath: 'notes/today.md',
+        selectedText: 'Selected text',
+        startLine: 4,
+        lineCount: 2,
+      },
+      text: 'Summarize this',
+    });
+
+    expect(prompt).toContain('Summarize this');
+    expect(prompt).toContain('<current_note>');
+    expect(prompt).toContain('notes/today.md');
+    expect(prompt).toContain('<editor_selection path="notes/today.md" lines="4-5">');
+    expect(prompt).toContain('<browser_selection source="browser:https://example.com" title="Example" url="https://example.com">');
+  });
+
+  it('does not auto-attach external context folders to the OpenCode prompt', () => {
+    const prompt = buildOpencodePromptText({
+      externalContextPaths: ['/tmp/project'],
+      text: 'Summarize this',
+    });
+
+    expect(prompt).toContain('Summarize this');
+    expect(prompt).not.toContain('<context_files>');
+    expect(prompt).not.toContain('/tmp/project');
+  });
+
+  it('rebuilds prior conversation context when a native session must be recreated', () => {
+    const prompt = buildOpencodePromptText(
+      {
+        text: 'Continue with the fix',
+      },
+      [
+        {
+          content: 'Inspect the bug',
+          id: 'user-1',
+          role: 'user',
+          timestamp: 1,
+        },
+        {
+          content: 'I found the failing path',
+          id: 'assistant-1',
+          role: 'assistant',
+          timestamp: 2,
+        },
+      ],
+    );
+
+    expect(prompt).toContain('User: Inspect the bug');
+    expect(prompt).toContain('Assistant: I found the failing path');
+    expect(prompt).toContain('User: Continue with the fix');
+  });
+});
+
+describe('buildOpencodePromptBlocks', () => {
+  it('includes image attachments after the main text block', () => {
+    const blocks = buildOpencodePromptBlocks({
+      images: [{
+        data: 'base64-image',
+        id: 'img-1',
+        mediaType: 'image/png',
+        name: 'diagram.png',
+        size: 123,
+        source: 'file',
+      }],
+      text: 'Inspect this image',
+    });
+
+    expect(blocks).toEqual([
+      { type: 'text', text: 'Inspect this image' },
+      { type: 'image', mimeType: 'image/png', data: 'base64-image' },
+    ]);
+  });
+});

package/tests/unit/providers/opencode/capabilities.test.ts

@@ -0,0 +1,39 @@
+import { OPENCODE_PROVIDER_CAPABILITIES } from '@/providers/opencode/capabilities';
+
+describe('OPENCODE_PROVIDER_CAPABILITIES', () => {
+  it('should have opencode as providerId', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.providerId).toBe('opencode');
+  });
+
+  it('should support persistent runtime', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsPersistentRuntime).toBe(true);
+  });
+
+  it('should support native history', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsNativeHistory).toBe(true);
+  });
+
+  it('should support plan mode', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsPlanMode).toBe(true);
+  });
+
+  it('should not support rewind', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsRewind).toBe(false);
+  });
+
+  it('should not support fork', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsFork).toBe(false);
+  });
+
+  it('should support provider commands', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.supportsProviderCommands).toBe(true);
+  });
+
+  it('should use effort-based reasoning control', () => {
+    expect(OPENCODE_PROVIDER_CAPABILITIES.reasoningControl).toBe('effort');
+  });
+
+  it('should be frozen', () => {
+    expect(Object.isFrozen(OPENCODE_PROVIDER_CAPABILITIES)).toBe(true);
+  });
+});

package/tests/unit/providers/opencode/models.test.ts

@@ -0,0 +1,273 @@
+import {
+  buildOpencodeBaseModels,
+  combineOpencodeRawModelSelection,
+  decodeOpencodeModelId,
+  encodeOpencodeModelId,
+  extractOpencodeModelVariantValue,
+  getOpencodeModelVariants,
+  groupOpencodeDiscoveredModels,
+  isOpencodeModelSelectionId,
+  OPENCODE_DEFAULT_THINKING_LEVEL,
+  OPENCODE_SYNTHETIC_MODEL_ID,
+  resolveOpencodeBaseModelRawId,
+  splitOpencodeModelLabel,
+} from '../../../../src/providers/opencode/models';
+import { opencodeChatUIConfig } from '../../../../src/providers/opencode/ui/OpencodeChatUIConfig';
+
+describe('OpenCode model identity', () => {
+  it('namespaces provider-owned model ids for the shared selector', () => {
+    expect(encodeOpencodeModelId('anthropic/claude-sonnet-4')).toBe('opencode:anthropic/claude-sonnet-4');
+    expect(decodeOpencodeModelId('opencode:anthropic/claude-sonnet-4')).toBe('anthropic/claude-sonnet-4');
+    expect(decodeOpencodeModelId(OPENCODE_SYNTHETIC_MODEL_ID)).toBeNull();
+    expect(isOpencodeModelSelectionId('opencode:anthropic/claude-sonnet-4')).toBe(true);
+    expect(isOpencodeModelSelectionId('claude-sonnet-4')).toBe(false);
+  });
+});
+
+describe('OpenCode base model derivation', () => {
+  const discoveredModels = [
+    { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+    { label: 'Anthropic/Claude Sonnet 4 (high)', rawId: 'anthropic/claude-sonnet-4/high' },
+    { label: 'Anthropic/Claude Sonnet 4 (max)', rawId: 'anthropic/claude-sonnet-4/max' },
+    { label: 'Google/Gemini 2.5 Pro', rawId: 'google/gemini-2.5-pro' },
+  ];
+
+  it('collapses discovered variants into base models', () => {
+    expect(buildOpencodeBaseModels(discoveredModels)).toEqual([
+      {
+        label: 'Anthropic/Claude Sonnet 4',
+        rawId: 'anthropic/claude-sonnet-4',
+        variants: [
+          { label: 'High', value: 'high' },
+          { label: 'Max', value: 'max' },
+        ],
+      },
+      {
+        label: 'Google/Gemini 2.5 Pro',
+        rawId: 'google/gemini-2.5-pro',
+        variants: [],
+      },
+    ]);
+  });
+
+  it('sorts thinking variants by semantic effort instead of alphabetically', () => {
+    expect(buildOpencodeBaseModels([
+      { label: 'OpenAI/GPT-5', rawId: 'openai/gpt-5' },
+      { label: 'OpenAI/GPT-5 (xhigh)', rawId: 'openai/gpt-5/xhigh' },
+      { label: 'OpenAI/GPT-5 (medium)', rawId: 'openai/gpt-5/medium' },
+      { label: 'OpenAI/GPT-5 (low)', rawId: 'openai/gpt-5/low' },
+      { label: 'OpenAI/GPT-5 (high)', rawId: 'openai/gpt-5/high' },
+      { label: 'OpenAI/GPT-5 (max)', rawId: 'openai/gpt-5/max' },
+    ])).toEqual([
+      {
+        label: 'OpenAI/GPT-5',
+        rawId: 'openai/gpt-5',
+        variants: [
+          { label: 'Low', value: 'low' },
+          { label: 'Medium', value: 'medium' },
+          { label: 'High', value: 'high' },
+          { label: 'Max', value: 'max' },
+          { label: 'XHigh', value: 'xhigh' },
+        ],
+      },
+    ]);
+  });
+
+  it('extracts and combines thinking variants from discovered model ids', () => {
+    expect(resolveOpencodeBaseModelRawId(
+      'anthropic/claude-sonnet-4/high',
+      discoveredModels,
+    )).toBe('anthropic/claude-sonnet-4');
+    expect(extractOpencodeModelVariantValue(
+      'anthropic/claude-sonnet-4/high',
+      discoveredModels,
+    )).toBe('high');
+    expect(getOpencodeModelVariants(
+      'anthropic/claude-sonnet-4',
+      discoveredModels,
+    )).toEqual([
+      { label: 'High', value: 'high' },
+      { label: 'Max', value: 'max' },
+    ]);
+    expect(combineOpencodeRawModelSelection(
+      'anthropic/claude-sonnet-4',
+      'high',
+      discoveredModels,
+    )).toBe('anthropic/claude-sonnet-4/high');
+    expect(combineOpencodeRawModelSelection(
+      'anthropic/claude-sonnet-4',
+      OPENCODE_DEFAULT_THINKING_LEVEL,
+      discoveredModels,
+    )).toBe('anthropic/claude-sonnet-4');
+  });
+});
+
+describe('opencodeChatUIConfig', () => {
+  it('keeps visible OpenCode model order stable and appends saved variant selections only when absent', () => {
+    const options = opencodeChatUIConfig.getModelOptions({
+      model: 'haiku',
+      providerConfigs: {
+        opencode: {
+          discoveredModels: [
+            { label: 'OpenAI/GPT-5', rawId: 'openai/gpt-5' },
+            { label: 'OpenAI/GPT-5 (high)', rawId: 'openai/gpt-5/high' },
+            { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+            { label: 'Anthropic/Claude Sonnet 4 (high)', rawId: 'anthropic/claude-sonnet-4/high' },
+          ],
+          visibleModels: [
+            'openai/gpt-5',
+          ],
+          preferredThinkingByModel: {
+            'anthropic/claude-sonnet-4': 'high',
+          },
+        },
+      },
+      savedProviderModel: {
+        opencode: 'opencode:anthropic/claude-sonnet-4/high',
+      },
+    });
+
+    expect(options).toEqual([
+      {
+        description: 'ACP runtime',
+        label: 'OpenAI/GPT-5',
+        value: 'opencode:openai/gpt-5',
+      },
+      {
+        description: 'ACP runtime',
+        label: 'Anthropic/Claude Sonnet 4',
+        value: 'opencode:anthropic/claude-sonnet-4',
+      },
+    ]);
+  });
+
+  it('uses modelAliases to override the label in model selector options', () => {
+    const options = opencodeChatUIConfig.getModelOptions({
+      providerConfigs: {
+        opencode: {
+          discoveredModels: [
+            { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+            { label: 'OpenAI/GPT-5', rawId: 'openai/gpt-5' },
+          ],
+          modelAliases: {
+            'anthropic/claude-sonnet-4': 'Sonnet',
+          },
+          visibleModels: [
+            'anthropic/claude-sonnet-4',
+            'openai/gpt-5',
+          ],
+        },
+      },
+    });
+
+    expect(options).toEqual([
+      {
+        description: 'ACP runtime',
+        label: 'Sonnet',
+        value: 'opencode:anthropic/claude-sonnet-4',
+      },
+      {
+        description: 'ACP runtime',
+        label: 'OpenAI/GPT-5',
+        value: 'opencode:openai/gpt-5',
+      },
+    ]);
+  });
+
+  it('shows configured base model ids even before discovery finishes', () => {
+    expect(opencodeChatUIConfig.getModelOptions({
+      providerConfigs: {
+        opencode: {
+          visibleModels: [
+            'google/gemini-2.5-pro',
+          ],
+        },
+      },
+    })).toEqual([
+      {
+        description: 'Configured model',
+        label: 'google/gemini-2.5-pro',
+        value: 'opencode:google/gemini-2.5-pro',
+      },
+    ]);
+  });
+
+  it('falls back to the synthetic entry before models are discovered', () => {
+    expect(opencodeChatUIConfig.getModelOptions({})).toEqual([
+      { description: 'ACP runtime', label: 'OpenCode', value: 'opencode' },
+    ]);
+  });
+
+  it('returns per-model thinking options from ACP thought-level discovery', () => {
+    const settings = {
+      model: 'opencode:anthropic/claude-sonnet-4',
+      providerConfigs: {
+        opencode: {
+          discoveredModels: [
+            { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+          ],
+          preferredThinkingByModel: {
+            'anthropic/claude-sonnet-4': 'max',
+          },
+          thinkingOptionsByModel: {
+            'anthropic/claude-sonnet-4': [
+              { label: 'Low', value: 'low' },
+              { label: 'High', value: 'high' },
+              { label: 'Max', value: 'max' },
+            ],
+          },
+        },
+      },
+    };
+
+    expect(opencodeChatUIConfig.getReasoningOptions(
+      'opencode:anthropic/claude-sonnet-4',
+      settings,
+    )).toEqual([
+      { label: 'Low', value: 'low' },
+      { label: 'High', value: 'high' },
+      { label: 'Max', value: 'max' },
+    ]);
+    expect(opencodeChatUIConfig.getDefaultReasoningValue(
+      'opencode:anthropic/claude-sonnet-4',
+      settings,
+    )).toBe('max');
+  });
+});
+
+describe('OpenCode discovered model grouping', () => {
+  it('splits provider and model labels for grouped picker rendering', () => {
+    expect(splitOpencodeModelLabel('Google/Gemini 2.5 Flash')).toEqual({
+      modelLabel: 'Gemini 2.5 Flash',
+      providerLabel: 'Google',
+    });
+    expect(splitOpencodeModelLabel('standalone-model')).toEqual({
+      modelLabel: 'standalone-model',
+      providerLabel: 'Other',
+    });
+  });
+
+  it('groups discovered models by provider label', () => {
+    expect(groupOpencodeDiscoveredModels([
+      { label: 'Google/Gemini 2.5 Flash', rawId: 'google/gemini-2.5-flash' },
+      { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+      { label: 'Google/Gemini 2.5 Pro', rawId: 'google/gemini-2.5-pro' },
+    ])).toEqual([
+      {
+        models: [
+          { label: 'Anthropic/Claude Sonnet 4', rawId: 'anthropic/claude-sonnet-4' },
+        ],
+        providerKey: 'anthropic',
+        providerLabel: 'Anthropic',
+      },
+      {
+        models: [
+          { label: 'Google/Gemini 2.5 Flash', rawId: 'google/gemini-2.5-flash' },
+          { label: 'Google/Gemini 2.5 Pro', rawId: 'google/gemini-2.5-pro' },
+        ],
+        providerKey: 'google',
+        providerLabel: 'Google',
+      },
+    ]);
+  });
+});