@mseep/claudian 2.0.25

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

@@ -0,0 +1,151 @@
+import {
+  getEffectiveOpencodeModes,
+  getManagedOpencodeModes,
+  normalizeManagedOpencodeSelectedMode,
+  normalizeOpencodeAvailableModes,
+  normalizeOpencodeSelectedMode,
+  OPENCODE_BUILD_MODE_ID,
+  OPENCODE_FALLBACK_MODES,
+  OPENCODE_SAFE_MODE_ID,
+  OPENCODE_YOLO_MODE_ID,
+  resolveOpencodeModeForPermissionMode,
+  resolvePermissionModeForManagedOpencodeMode,
+} from '../../../../src/providers/opencode/modes';
+import { opencodeChatUIConfig } from '../../../../src/providers/opencode/ui/OpencodeChatUIConfig';
+
+describe('OpenCode mode settings', () => {
+  it('normalizes duplicate/invalid mode entries', () => {
+    expect(normalizeOpencodeAvailableModes([
+      { id: 'build', name: 'Build' },
+      { id: 'build', name: 'Duplicate build' },
+      { id: 'plan', name: 'Plan', description: 'Planning-first agent' },
+      null,
+    ])).toEqual([
+      { id: 'build', name: 'Build' },
+      { description: 'Planning-first agent', id: 'plan', name: 'Plan' },
+    ]);
+  });
+
+  it('preserves a saved mode string until fresh discovery decides whether it is valid', () => {
+    expect(normalizeOpencodeSelectedMode('plan')).toBe('plan');
+  });
+
+  it('falls back to the built-in primary modes before ACP discovery finishes', () => {
+    expect(getEffectiveOpencodeModes([])).toEqual(OPENCODE_FALLBACK_MODES);
+  });
+
+  it('keeps Claudian on managed YOLO/safe/plan modes even when discovery only reports custom agents', () => {
+    expect(getManagedOpencodeModes([
+      { id: 'compaction', name: 'compaction' },
+      { id: 'summary', name: 'summary' },
+    ])).toEqual(OPENCODE_FALLBACK_MODES);
+  });
+
+  it('normalizes saved custom mode selections back to the managed YOLO mode', () => {
+    expect(normalizeManagedOpencodeSelectedMode('compaction')).toBe(OPENCODE_YOLO_MODE_ID);
+  });
+
+  it('normalizes the legacy build id back to the managed YOLO mode', () => {
+    expect(normalizeManagedOpencodeSelectedMode(OPENCODE_BUILD_MODE_ID)).toBe(OPENCODE_YOLO_MODE_ID);
+  });
+
+  it('maps shared permission modes onto managed OpenCode modes', () => {
+    expect(resolveOpencodeModeForPermissionMode('yolo')).toBe(OPENCODE_YOLO_MODE_ID);
+    expect(resolveOpencodeModeForPermissionMode('normal')).toBe(OPENCODE_SAFE_MODE_ID);
+    expect(resolveOpencodeModeForPermissionMode('plan')).toBe('plan');
+  });
+
+  it('maps managed OpenCode modes back to shared permission modes', () => {
+    expect(resolvePermissionModeForManagedOpencodeMode(OPENCODE_BUILD_MODE_ID)).toBe('yolo');
+    expect(resolvePermissionModeForManagedOpencodeMode(OPENCODE_YOLO_MODE_ID)).toBe('yolo');
+    expect(resolvePermissionModeForManagedOpencodeMode(OPENCODE_SAFE_MODE_ID)).toBe('normal');
+    expect(resolvePermissionModeForManagedOpencodeMode('plan')).toBe('plan');
+    expect(resolvePermissionModeForManagedOpencodeMode('summary')).toBeNull();
+  });
+});
+
+describe('opencodeChatUIConfig permission mode wiring', () => {
+  it('exposes the shared Safe/YOLO/Plan toggle instead of a provider-owned mode selector', () => {
+    expect(opencodeChatUIConfig.getModeSelector?.({
+      providerConfigs: {
+        opencode: {
+          availableModes: [
+            { id: OPENCODE_YOLO_MODE_ID, name: 'YOLO' },
+            { id: OPENCODE_SAFE_MODE_ID, name: 'Safe' },
+            { id: 'plan', name: 'Plan' },
+          ],
+          selectedMode: OPENCODE_SAFE_MODE_ID,
+        },
+      },
+    }) ?? null).toBeNull();
+
+    expect(opencodeChatUIConfig.getPermissionModeToggle?.()).toEqual({
+      activeLabel: 'YOLO',
+      activeValue: 'yolo',
+      inactiveLabel: 'Safe',
+      inactiveValue: 'normal',
+      planLabel: 'Plan',
+      planValue: 'plan',
+    });
+  });
+
+  it('derives shared permission mode from the saved managed OpenCode mode', () => {
+    expect(opencodeChatUIConfig.resolvePermissionMode?.({
+      providerConfigs: {
+        opencode: {
+          selectedMode: OPENCODE_BUILD_MODE_ID,
+        },
+      },
+    })).toBe('yolo');
+
+    expect(opencodeChatUIConfig.resolvePermissionMode?.({
+      providerConfigs: {
+        opencode: {
+          selectedMode: OPENCODE_SAFE_MODE_ID,
+        },
+      },
+    })).toBe('normal');
+
+    expect(opencodeChatUIConfig.resolvePermissionMode?.({
+      providerConfigs: {
+        opencode: {
+          selectedMode: OPENCODE_YOLO_MODE_ID,
+        },
+      },
+    })).toBe('yolo');
+
+    expect(opencodeChatUIConfig.resolvePermissionMode?.({
+      providerConfigs: {
+        opencode: {
+          selectedMode: 'plan',
+        },
+      },
+    })).toBe('plan');
+  });
+
+  it('maps shared permission mode changes back into managed OpenCode modes', () => {
+    const settings: Record<string, unknown> = {
+      permissionMode: 'yolo',
+      providerConfigs: {
+        opencode: {
+          availableModes: [
+            { id: OPENCODE_YOLO_MODE_ID, name: 'YOLO' },
+            { id: OPENCODE_SAFE_MODE_ID, name: 'Safe' },
+            { id: 'plan', name: 'Plan' },
+          ],
+          selectedMode: OPENCODE_YOLO_MODE_ID,
+        },
+      },
+    };
+
+    opencodeChatUIConfig.applyPermissionMode?.('normal', settings);
+    expect(settings.permissionMode).toBe('normal');
+    expect((settings.providerConfigs as Record<string, Record<string, unknown>>).opencode.selectedMode).toBe(OPENCODE_SAFE_MODE_ID);
+
+    opencodeChatUIConfig.applyPermissionMode?.('plan', settings);
+    expect((settings.providerConfigs as Record<string, Record<string, unknown>>).opencode.selectedMode).toBe('plan');
+
+    opencodeChatUIConfig.applyPermissionMode?.('yolo', settings);
+    expect((settings.providerConfigs as Record<string, Record<string, unknown>>).opencode.selectedMode).toBe(OPENCODE_YOLO_MODE_ID);
+  });
+});

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

@@ -0,0 +1,197 @@
+import {
+  createOpencodeToolStreamAdapter,
+  normalizeOpencodeToolInput,
+} from '../../../../src/providers/opencode/normalization/opencodeToolNormalization';
+
+describe('normalizeOpencodeToolInput', () => {
+  it('maps websearch payloads to the WebSearch renderer shape', () => {
+    expect(normalizeOpencodeToolInput('websearch', {
+      action: {
+        queries: [
+          'obsidian plugin API',
+          'obsidian docs',
+          'obsidian plugin API',
+        ],
+      },
+    })).toEqual({
+      actionType: 'search',
+      query: 'obsidian plugin API',
+      queries: [
+        'obsidian plugin API',
+        'obsidian docs',
+      ],
+    });
+  });
+
+  it('maps question payloads to the AskUserQuestion renderer shape', () => {
+    expect(normalizeOpencodeToolInput('question', {
+      questions: [{
+        header: 'Tests',
+        id: 'tests',
+        multiple: true,
+        options: [
+          { description: 'Update the related tests', label: 'Yes' },
+          { description: 'Skip test edits', label: 'No' },
+        ],
+        question: 'Update tests too?',
+      }],
+    })).toEqual({
+      questions: [{
+        header: 'Tests',
+        id: 'tests',
+        multiSelect: true,
+        options: [
+          { description: 'Update the related tests', label: 'Yes' },
+          { description: 'Skip test edits', label: 'No' },
+        ],
+        question: 'Update tests too?',
+      }],
+    });
+  });
+
+  it('maps todowrite statuses into the TodoWrite renderer shape', () => {
+    expect(normalizeOpencodeToolInput('todowrite', {
+      todos: [
+        { content: 'Ship feature', status: 'in_progress' },
+        { content: 'Drop stale task', status: 'cancelled' },
+      ],
+    })).toEqual({
+      todos: [
+        { activeForm: 'Ship feature', content: 'Ship feature', status: 'in_progress' },
+        { activeForm: 'Drop stale task', content: 'Drop stale task', status: 'completed' },
+      ],
+    });
+  });
+});
+
+describe('createOpencodeToolStreamAdapter', () => {
+  it('keeps the original tool identity when completion updates replace title with a filepath', () => {
+    const adapter = createOpencodeToolStreamAdapter();
+
+    expect(adapter.normalizeToolCall({
+      rawInput: {},
+      title: 'read',
+      toolCallId: 'tool-1',
+    }, [{
+      id: 'tool-1',
+      input: {},
+      name: 'read',
+      type: 'tool_use',
+    }])).toEqual([{
+      id: 'tool-1',
+      input: {},
+      name: 'Read',
+      type: 'tool_use',
+    }]);
+
+    expect(adapter.normalizeToolCallUpdate({
+      kind: 'read',
+      rawInput: {
+        filePath: '/vault/notes/today.md',
+      },
+      status: 'completed',
+      title: 'notes/today.md',
+      toolCallId: 'tool-1',
+    }, [{
+      content: 'read ok',
+      id: 'tool-1',
+      isError: false,
+      type: 'tool_result',
+    }])).toEqual([
+      {
+        id: 'tool-1',
+        input: { file_path: '/vault/notes/today.md' },
+        name: 'Read',
+        type: 'tool_use',
+      },
+      {
+        content: 'read ok',
+        id: 'tool-1',
+        isError: false,
+        type: 'tool_result',
+      },
+    ]);
+  });
+
+  it('attaches structured answers for question tool results', () => {
+    const adapter = createOpencodeToolStreamAdapter();
+
+    adapter.normalizeToolCall({
+      rawInput: {
+        questions: [{
+          header: 'Deploy',
+          id: 'deploy',
+          options: [
+            { description: 'Ship the change', label: 'Yes' },
+            { description: 'Hold the deploy', label: 'No' },
+          ],
+          question: 'Deploy now?',
+        }],
+      },
+      title: 'question',
+      toolCallId: 'tool-2',
+    }, [{
+      id: 'tool-2',
+      input: {},
+      name: 'question',
+      type: 'tool_use',
+    }]);
+
+    expect(adapter.normalizeToolCallUpdate({
+      rawOutput: {
+        metadata: {
+          answers: [['Yes']],
+        },
+        output: 'User has answered your questions.',
+      },
+      status: 'completed',
+      title: 'Asked 1 question',
+      toolCallId: 'tool-2',
+    }, [{
+      content: 'User has answered your questions.',
+      id: 'tool-2',
+      isError: false,
+      type: 'tool_result',
+    }])).toEqual([{
+      content: 'User has answered your questions.',
+      id: 'tool-2',
+      isError: false,
+      toolUseResult: {
+        answers: {
+          deploy: 'Yes',
+          'Deploy now?': 'Yes',
+        },
+      },
+      type: 'tool_result',
+    }]);
+  });
+
+  it('normalizes websearch tool calls to the shared WebSearch renderer contract', () => {
+    const adapter = createOpencodeToolStreamAdapter();
+
+    expect(adapter.normalizeToolCall({
+      rawInput: {
+        action: {
+          pattern: 'tools',
+          url: 'https://example.com/docs',
+        },
+      },
+      title: 'websearch',
+      toolCallId: 'tool-3',
+    }, [{
+      id: 'tool-3',
+      input: {},
+      name: 'websearch',
+      type: 'tool_use',
+    }])).toEqual([{
+      id: 'tool-3',
+      input: {
+        actionType: 'find_in_page',
+        pattern: 'tools',
+        url: 'https://example.com/docs',
+      },
+      name: 'WebSearch',
+      type: 'tool_use',
+    }]);
+  });
+});