@mseep/claudian 2.0.25

package/tests/unit/providers/pi/ui/PiChatUIConfig.test.ts

@@ -0,0 +1,161 @@
+import { getPiProviderSettings } from '@/providers/pi/settings';
+import { piChatUIConfig } from '@/providers/pi/ui/PiChatUIConfig';
+
+const settings: Record<string, unknown> = {
+  providerConfigs: {
+    pi: {
+      discoveredModels: [
+        {
+          encodedId: 'pi:anthropic/claude-sonnet-4',
+          id: 'claude-sonnet-4',
+          input: ['text'],
+          label: 'Claude Sonnet 4',
+          provider: 'anthropic',
+          reasoning: true,
+          thinkingLevels: ['off', 'medium', 'high'],
+        },
+        {
+          encodedId: 'pi:openai/gpt-5',
+          id: 'gpt-5',
+          input: ['text'],
+          label: 'GPT-5',
+          provider: 'openai',
+          reasoning: false,
+          thinkingLevels: ['off'],
+        },
+      ],
+      modelAliases: {
+        'pi:anthropic/claude-sonnet-4': 'Sonnet',
+      },
+      preferredThinkingByModel: {
+        'pi:anthropic/claude-sonnet-4': 'high',
+      },
+      visibleModels: ['pi:anthropic/claude-sonnet-4'],
+    },
+  },
+};
+
+describe('PiChatUIConfig', () => {
+  it('returns visible model options with aliases and pins saved selections', () => {
+    const options = piChatUIConfig.getModelOptions({
+      ...settings,
+      savedProviderModel: {
+        pi: 'pi:openai/gpt-5',
+      },
+    });
+
+    expect(options).toEqual([
+      expect.objectContaining({
+        label: 'Sonnet',
+        value: 'pi:anthropic/claude-sonnet-4',
+      }),
+      expect.objectContaining({
+        label: 'GPT-5',
+        value: 'pi:openai/gpt-5',
+      }),
+    ]);
+  });
+
+  it('returns a synthetic fallback before discovery', () => {
+    expect(piChatUIConfig.getModelOptions({ providerConfigs: { pi: {} } })).toEqual([
+      { value: 'pi', label: 'Pi', description: 'Configure models in settings' },
+    ]);
+    expect(piChatUIConfig.ownsModel('pi', { providerConfigs: { pi: {} } })).toBe(true);
+    expect(piChatUIConfig.ownsModel('pi:anthropic/claude-sonnet-4', { providerConfigs: { pi: {} } })).toBe(true);
+    expect(piChatUIConfig.ownsModel('pi:invalid', { providerConfigs: { pi: {} } })).toBe(false);
+    expect(piChatUIConfig.getReasoningOptions('pi', { providerConfigs: { pi: {} } })).toEqual([
+      { label: 'Off', value: 'off' },
+    ]);
+    expect(piChatUIConfig.getDefaultReasoningValue('pi', { providerConfigs: { pi: {} } })).toBe('off');
+  });
+
+  it('maps reasoning options and defaults from cached model metadata', () => {
+    expect(piChatUIConfig.isAdaptiveReasoningModel('pi:anthropic/claude-sonnet-4', settings)).toBe(true);
+    expect(piChatUIConfig.getReasoningOptions('pi:anthropic/claude-sonnet-4', settings)).toEqual([
+      { label: 'Off', value: 'off' },
+      { label: 'Medium', value: 'medium' },
+      { label: 'High', value: 'high' },
+    ]);
+    expect(piChatUIConfig.getDefaultReasoningValue('pi:anthropic/claude-sonnet-4', settings)).toBe('high');
+  });
+
+  it('resolves context windows from cached Pi model metadata before falling back', () => {
+    const contextSettings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          discoveredModels: [{
+            contextWindow: 1_000_000,
+            encodedId: 'pi:anthropic/claude-sonnet-4',
+            id: 'claude-sonnet-4',
+            input: ['text'],
+            label: 'Claude Sonnet 4',
+            provider: 'anthropic',
+            reasoning: true,
+            thinkingLevels: ['off', 'medium', 'high'],
+          }],
+          visibleModels: ['pi:anthropic/claude-sonnet-4'],
+        },
+      },
+    };
+
+    expect(piChatUIConfig.getContextWindowSize(
+      'pi:anthropic/claude-sonnet-4',
+      { 'pi:anthropic/claude-sonnet-4': 123_000 },
+      contextSettings,
+    )).toBe(1_000_000);
+    expect(piChatUIConfig.getContextWindowSize(
+      'pi:missing/model',
+      { 'pi:missing/model': 123_000 },
+      contextSettings,
+    )).toBe(123_000);
+    expect(piChatUIConfig.getContextWindowSize('pi:missing/model', undefined, contextSettings)).toBe(200_000);
+  });
+
+  it('keeps decoded models on Pi effort controls when discovery metadata is stale', () => {
+    const staleSettings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          visibleModels: ['pi:custom/model'],
+        },
+      },
+      savedProviderModel: {
+        pi: 'pi:custom/model',
+      },
+    };
+
+    expect(piChatUIConfig.getModelOptions(staleSettings)).toEqual([
+      expect.objectContaining({
+        label: 'custom/model',
+        value: 'pi:custom/model',
+      }),
+    ]);
+    expect(piChatUIConfig.isAdaptiveReasoningModel('pi:custom/model', staleSettings)).toBe(true);
+    expect(piChatUIConfig.getReasoningOptions('pi:custom/model', staleSettings)).toEqual([
+      { label: 'Off', value: 'off' },
+      { label: 'Minimal', value: 'minimal' },
+      { label: 'Low', value: 'low' },
+      { label: 'Medium', value: 'medium' },
+      { label: 'High', value: 'high' },
+    ]);
+    expect(piChatUIConfig.getDefaultReasoningValue('pi:custom/model', staleSettings)).toBe('medium');
+
+    piChatUIConfig.applyReasoningSelection?.('pi:custom/model', 'high', staleSettings);
+    expect(getPiProviderSettings(staleSettings).preferredThinkingByModel).toEqual({
+      'pi:custom/model': 'high',
+    });
+  });
+
+  it('maps toolbar permission mode to Pi tool mode', () => {
+    const mutableSettings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          toolMode: 'readonly',
+        },
+      },
+    };
+
+    expect(piChatUIConfig.resolvePermissionMode?.(mutableSettings)).toBe('normal');
+    piChatUIConfig.applyPermissionMode?.('yolo', mutableSettings);
+    expect(piChatUIConfig.resolvePermissionMode?.(mutableSettings)).toBe('yolo');
+  });
+});

package/tests/unit/providers/pi/ui/PiSettingsTab.test.ts

@@ -0,0 +1,492 @@
+import * as fs from 'node:fs';
+
+const mockRenderEnvironmentSettingsSection = jest.fn();
+const mockCliResolverReset = jest.fn();
+const mockDiscoverModels = jest.fn();
+const mockNotices: string[] = [];
+
+interface MockToggleComponent {
+  onChangeCallback: ((value: boolean) => Promise<void> | void) | null;
+  setValue: jest.Mock;
+  value: boolean;
+  onChange(callback: (value: boolean) => Promise<void> | void): MockToggleComponent;
+}
+
+interface MockTextComponent {
+  inputEl: {
+    addClass: jest.Mock;
+    style: Record<string, string>;
+    toggleClass: jest.Mock;
+    value: string;
+  };
+  onChangeCallback: ((value: string) => Promise<void> | void) | null;
+  setPlaceholder: jest.Mock;
+  setValue: jest.Mock;
+  value: string;
+  onChange(callback: (value: string) => Promise<void> | void): MockTextComponent;
+}
+
+interface MockButtonComponent {
+  disabled: boolean;
+  onClickCallback: (() => Promise<void> | void) | null;
+  setButtonText: jest.Mock;
+  setDisabled: jest.Mock;
+  text: string;
+  onClick(callback: () => Promise<void> | void): MockButtonComponent;
+}
+
+interface MockDropdownComponent {
+  onChangeCallback: ((value: string) => Promise<void> | void) | null;
+  options: Record<string, string>;
+  setValue: jest.Mock;
+  value: string;
+  addOption(value: string, label: string): MockDropdownComponent;
+  onChange(callback: (value: string) => Promise<void> | void): MockDropdownComponent;
+}
+
+class MockSetting {
+  buttonComponents: MockButtonComponent[] = [];
+  desc = '';
+  dropdownComponents: MockDropdownComponent[] = [];
+  heading = false;
+  name = '';
+  textComponents: MockTextComponent[] = [];
+  toggleComponents: MockToggleComponent[] = [];
+
+  constructor(_container: unknown) {
+    createdSettings.push(this);
+  }
+
+  setName(name: string): this {
+    this.name = name;
+    return this;
+  }
+
+  setDesc(desc: string): this {
+    this.desc = desc;
+    return this;
+  }
+
+  setHeading(): this {
+    this.heading = true;
+    return this;
+  }
+
+  addToggle(callback: (toggle: MockToggleComponent) => void): this {
+    const component = createToggleComponent();
+    this.toggleComponents.push(component);
+    callback(component);
+    return this;
+  }
+
+  addText(callback: (text: MockTextComponent) => void): this {
+    const component = createTextComponent();
+    this.textComponents.push(component);
+    callback(component);
+    return this;
+  }
+
+  addButton(callback: (button: MockButtonComponent) => void): this {
+    const component = createButtonComponent();
+    this.buttonComponents.push(component);
+    callback(component);
+    return this;
+  }
+
+  addDropdown(callback: (dropdown: MockDropdownComponent) => void): this {
+    const component = createDropdownComponent();
+    this.dropdownComponents.push(component);
+    callback(component);
+    return this;
+  }
+}
+
+jest.mock('node:fs');
+jest.mock('obsidian', () => ({
+  Notice: class MockNotice {
+    constructor(message: string) {
+      mockNotices.push(message);
+    }
+  },
+  Setting: MockSetting,
+}));
+jest.mock('@/features/settings/ui/EnvironmentSettingsSection', () => ({
+  renderEnvironmentSettingsSection: (...args: unknown[]) => mockRenderEnvironmentSettingsSection(...args),
+}));
+jest.mock('@/providers/pi/app/PiWorkspaceServices', () => ({
+  maybeGetPiWorkspaceServices: jest.fn(() => ({
+    cliResolver: {
+      reset: mockCliResolverReset,
+    },
+  })),
+}));
+jest.mock('@/providers/pi/runtime/PiModelDiscoveryService', () => ({
+  PiModelDiscoveryService: jest.fn().mockImplementation(() => ({
+    discoverModels: mockDiscoverModels,
+  })),
+}));
+jest.mock('@/utils/env', () => ({
+  ...jest.requireActual('@/utils/env'),
+  getHostnameKey: () => 'current-host',
+}));
+
+import { getPiProviderSettings } from '@/providers/pi/settings';
+import { piSettingsTabRenderer } from '@/providers/pi/ui/PiSettingsTab';
+
+const createdSettings: MockSetting[] = [];
+const createdDomElements: any[] = [];
+const mockedExists = fs.existsSync as jest.Mock;
+const mockedStat = fs.statSync as jest.Mock;
+
+function createToggleComponent(): MockToggleComponent {
+  const component = {} as MockToggleComponent;
+  component.onChangeCallback = null;
+  component.value = false;
+  component.setValue = jest.fn((value: boolean) => {
+    component.value = value;
+    return component;
+  });
+  component.onChange = (callback: (value: boolean) => Promise<void> | void): MockToggleComponent => {
+    component.onChangeCallback = callback;
+    return component;
+  };
+  return component;
+}
+
+function createTextComponent(): MockTextComponent {
+  const component = {} as MockTextComponent;
+  component.inputEl = {
+    addClass: jest.fn(),
+    style: {},
+    toggleClass: jest.fn(),
+    value: '',
+  };
+  component.onChangeCallback = null;
+  component.value = '';
+  component.setPlaceholder = jest.fn(() => component);
+  component.setValue = jest.fn((value: string) => {
+    component.value = value;
+    component.inputEl.value = value;
+    return component;
+  });
+  component.onChange = (callback: (value: string) => Promise<void> | void): MockTextComponent => {
+    component.onChangeCallback = callback;
+    return component;
+  };
+  return component;
+}
+
+function createButtonComponent(): MockButtonComponent {
+  const component = {} as MockButtonComponent;
+  component.disabled = false;
+  component.onClickCallback = null;
+  component.text = '';
+  component.setButtonText = jest.fn((value: string) => {
+    component.text = value;
+    return component;
+  });
+  component.setDisabled = jest.fn((value: boolean) => {
+    component.disabled = value;
+    return component;
+  });
+  component.onClick = (callback: () => Promise<void> | void): MockButtonComponent => {
+    component.onClickCallback = callback;
+    return component;
+  };
+  return component;
+}
+
+function createDropdownComponent(): MockDropdownComponent {
+  const component = {} as MockDropdownComponent;
+  component.onChangeCallback = null;
+  component.options = {};
+  component.value = '';
+  component.addOption = (value: string, label: string): MockDropdownComponent => {
+    component.options[value] = label;
+    return component;
+  };
+  component.setValue = jest.fn((value: string) => {
+    component.value = value;
+    return component;
+  });
+  component.onChange = (callback: (value: string) => Promise<void> | void): MockDropdownComponent => {
+    component.onChangeCallback = callback;
+    return component;
+  };
+  return component;
+}
+
+function createElement(): any {
+  const classes = new Set<string>();
+  const eventListeners = new Map<string, Array<(...args: unknown[]) => void>>();
+  const element: any = {
+    checked: false,
+    open: false,
+    placeholder: '',
+    style: {},
+    title: '',
+    value: '',
+    classList: {
+      add: jest.fn((cls: string) => classes.add(cls)),
+      remove: jest.fn((cls: string) => classes.delete(cls)),
+      toggle: jest.fn((cls: string, force?: boolean) => {
+        if (force === undefined) {
+          if (classes.has(cls)) {
+            classes.delete(cls);
+            return false;
+          }
+          classes.add(cls);
+          return true;
+        }
+        if (force) {
+          classes.add(cls);
+        } else {
+          classes.delete(cls);
+        }
+        return force;
+      }),
+      contains: jest.fn((cls: string) => classes.has(cls)),
+    },
+    addClass: jest.fn((cls: string) => {
+      cls.split(/\s+/).filter(Boolean).forEach((item) => classes.add(item));
+    }),
+    removeClass: jest.fn((cls: string) => {
+      cls.split(/\s+/).filter(Boolean).forEach((item) => classes.delete(item));
+    }),
+    toggleClass: jest.fn((cls: string, force: boolean) => {
+      if (force) {
+        classes.add(cls);
+      } else {
+        classes.delete(cls);
+      }
+    }),
+    hasClass: jest.fn((cls: string) => classes.has(cls)),
+    setText: jest.fn((value: string) => {
+      element.text = value;
+    }),
+    empty: jest.fn(),
+    setAttribute: jest.fn(),
+    addEventListener: jest.fn((type: string, callback: (...args: unknown[]) => void) => {
+      const listeners = eventListeners.get(type) ?? [];
+      listeners.push(callback);
+      eventListeners.set(type, listeners);
+    }),
+    dispatchMockEvent: async (type: string, event?: unknown) => {
+      for (const listener of eventListeners.get(type) ?? []) {
+        await listener(event);
+      }
+    },
+    blur: jest.fn(),
+    createEl: jest.fn((tag?: string, attrs?: Record<string, unknown>) => {
+      const child = createElement();
+      child.tag = tag;
+      applyElementAttrs(child, attrs);
+      createdDomElements.push(child);
+      return child;
+    }),
+    createDiv: jest.fn((attrs?: Record<string, unknown>) => {
+      const child = createElement();
+      child.tag = 'div';
+      applyElementAttrs(child, attrs);
+      createdDomElements.push(child);
+      return child;
+    }),
+    createSpan: jest.fn((attrs?: Record<string, unknown>) => {
+      const child = createElement();
+      child.tag = 'span';
+      applyElementAttrs(child, attrs);
+      createdDomElements.push(child);
+      return child;
+    }),
+  };
+
+  return element;
+}
+
+function applyElementAttrs(element: any, attrs?: Record<string, unknown>): void {
+  if (!attrs) {
+    return;
+  }
+  if (typeof attrs.cls === 'string') {
+    element.cls = attrs.cls;
+  }
+  if (typeof attrs.text === 'string') {
+    element.text = attrs.text;
+  }
+  if (typeof attrs.value === 'string') {
+    element.value = attrs.value;
+  }
+  if (typeof attrs.type === 'string') {
+    element.type = attrs.type;
+  }
+}
+
+function createContext(settings: Record<string, unknown>) {
+  return {
+    plugin: {
+      saveSettings: jest.fn().mockResolvedValue(undefined),
+      settings,
+    },
+    refreshModelSelectors: jest.fn(),
+    renderHiddenProviderCommandSetting: jest.fn(),
+  };
+}
+
+function render(settings: Record<string, unknown>) {
+  const context = createContext(settings);
+  piSettingsTabRenderer.render(createElement(), context as any);
+  return context;
+}
+
+function findSetting(name: string): MockSetting {
+  const setting = [...createdSettings].reverse().find(entry => entry.name === name);
+  if (!setting) {
+    throw new Error(`Setting not found: ${name}`);
+  }
+  return setting;
+}
+
+function findElement(tag: string, cls: string): any {
+  const element = [...createdDomElements].reverse().find(
+    candidate => candidate.tag === tag && candidate.cls === cls,
+  );
+  if (!element) {
+    throw new Error(`Element not found: ${tag}.${cls}`);
+  }
+  return element;
+}
+
+function findInputByType(type: string): any {
+  const element = [...createdDomElements].reverse().find(
+    candidate => candidate.tag === 'input' && candidate.type === type,
+  );
+  if (!element) {
+    throw new Error(`Input not found: ${type}`);
+  }
+  return element;
+}
+
+describe('PiSettingsTab', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    createdSettings.length = 0;
+    createdDomElements.length = 0;
+    mockNotices.length = 0;
+    mockedExists.mockReturnValue(true);
+    mockedStat.mockReturnValue({ isFile: () => true });
+    mockDiscoverModels.mockResolvedValue({
+      models: [],
+    });
+  });
+
+  it('updates provider config when Pi is enabled', async () => {
+    const settings: Record<string, unknown> = { providerConfigs: { pi: { enabled: false } } };
+    const context = render(settings);
+
+    await findSetting('Enable Pi').toggleComponents[0].onChangeCallback?.(true);
+
+    expect(getPiProviderSettings(settings).enabled).toBe(true);
+    expect(context.plugin.saveSettings).toHaveBeenCalled();
+    expect(context.refreshModelSelectors).toHaveBeenCalled();
+  });
+
+  it('does not render hidden command settings for Pi', () => {
+    const settings: Record<string, unknown> = { providerConfigs: { pi: {} } };
+    const context = render(settings);
+
+    expect(context.renderHiddenProviderCommandSetting).not.toHaveBeenCalled();
+  });
+
+  it('does not render the chat input tool mode setting for Pi', () => {
+    render({ providerConfigs: { pi: { toolMode: 'readonly' } } });
+
+    expect(() => findSetting('Tool mode')).toThrow('Setting not found: Tool mode');
+  });
+
+  it('validates host-scoped CLI paths and resets the resolver after valid changes', async () => {
+    const settings: Record<string, unknown> = { providerConfigs: { pi: {} } };
+    const context = render(settings);
+    const cliInput = findSetting('CLI path').textComponents[0];
+
+    mockedExists.mockReturnValue(false);
+    await cliInput.onChangeCallback?.('/missing/pi');
+    expect(context.plugin.saveSettings).not.toHaveBeenCalled();
+    expect(mockCliResolverReset).not.toHaveBeenCalled();
+
+    mockedExists.mockReturnValue(true);
+    mockedStat.mockReturnValue({ isFile: () => true });
+    await cliInput.onChangeCallback?.('/valid/pi');
+    expect(getPiProviderSettings(settings).cliPathsByHost).toEqual({
+      'current-host': '/valid/pi',
+    });
+    expect(mockCliResolverReset).toHaveBeenCalled();
+    expect(context.plugin.saveSettings).toHaveBeenCalled();
+  });
+
+  it('discovers models through PiModelDiscoveryService and reports failures', async () => {
+    mockDiscoverModels.mockResolvedValueOnce({
+      models: [{
+        encodedId: 'pi:anthropic/claude-sonnet-4',
+        id: 'claude-sonnet-4',
+        input: ['text'],
+        label: 'Claude Sonnet 4',
+        provider: 'anthropic',
+        reasoning: true,
+        thinkingLevels: ['off', 'medium'],
+      }],
+    });
+    const settings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          visibleModels: ['pi:anthropic/claude-sonnet-4'],
+        },
+      },
+    };
+    const context = render(settings);
+
+    await findElement('button', 'claudian-provider-model-picker-action').dispatchMockEvent('click');
+
+    expect(mockDiscoverModels).toHaveBeenCalledTimes(1);
+    expect(getPiProviderSettings(settings).discoveredModels).toHaveLength(1);
+    expect(getPiProviderSettings(settings).visibleModels).toEqual(['pi:anthropic/claude-sonnet-4']);
+    expect(context.refreshModelSelectors).toHaveBeenCalled();
+
+    mockDiscoverModels.mockResolvedValueOnce({ diagnostics: 'not logged in', models: [] });
+    await findElement('button', 'claudian-provider-model-picker-action').dispatchMockEvent('click');
+    expect(mockNotices[0]).toContain('not logged in');
+  });
+
+  it('persists visible model choices and aliases', async () => {
+    const settings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          discoveredModels: [{
+            encodedId: 'pi:anthropic/claude-sonnet-4',
+            id: 'claude-sonnet-4',
+            input: ['text'],
+            label: 'Claude Sonnet 4',
+            provider: 'anthropic',
+            reasoning: true,
+            thinkingLevels: ['off', 'medium'],
+          }],
+          visibleModels: [],
+        },
+      },
+    };
+    const context = render(settings);
+    const checkboxEl = findInputByType('checkbox');
+
+    checkboxEl.checked = true;
+    await checkboxEl.dispatchMockEvent('change');
+    expect(getPiProviderSettings(settings).visibleModels).toEqual(['pi:anthropic/claude-sonnet-4']);
+
+    const aliasInput = findElement('input', 'claudian-provider-model-picker-selected-alias');
+    aliasInput.value = 'Sonnet';
+    await aliasInput.dispatchMockEvent('blur');
+
+    expect(getPiProviderSettings(settings).modelAliases).toEqual({
+      'pi:anthropic/claude-sonnet-4': 'Sonnet',
+    });
+    expect(context.refreshModelSelectors).toHaveBeenCalled();
+  });
+});