@mseep/claudian 2.0.25

package/src/providers/pi/ui/ObsidianPiExtensionUiRenderer.ts

@@ -0,0 +1,251 @@
+import { type App, Modal, Notice } from 'obsidian';
+
+import type {
+  PiExtensionUiConfirmRequest,
+  PiExtensionUiEditorRequest,
+  PiExtensionUiInputRequest,
+  PiExtensionUiNotifyRequest,
+  PiExtensionUiRenderer,
+  PiExtensionUiSelectRequest,
+  PiExtensionUiSetEditorTextRequest,
+  PiExtensionUiSetStatusRequest,
+  PiExtensionUiSetTitleRequest,
+  PiExtensionUiSetWidgetRequest,
+} from './PiExtensionUiRenderer';
+
+export class ObsidianPiExtensionUiRenderer implements PiExtensionUiRenderer {
+  constructor(private readonly app: App) {}
+
+  async select(
+    request: PiExtensionUiSelectRequest,
+    signal: AbortSignal,
+  ): Promise<{ cancelled?: boolean; value?: string }> {
+    return new PiSelectModal(this.app, request, signal).openAndWait();
+  }
+
+  async confirm(
+    request: PiExtensionUiConfirmRequest,
+    signal: AbortSignal,
+  ): Promise<{ cancelled?: boolean; confirmed?: boolean }> {
+    return new PiConfirmModal(this.app, request, signal).openAndWait();
+  }
+
+  async input(
+    request: PiExtensionUiInputRequest,
+    signal: AbortSignal,
+  ): Promise<{ cancelled?: boolean; value?: string }> {
+    return new PiTextModal(this.app, request, signal, false).openAndWait();
+  }
+
+  async editor(
+    request: PiExtensionUiEditorRequest,
+    signal: AbortSignal,
+  ): Promise<{ cancelled?: boolean; value?: string }> {
+    return new PiTextModal(this.app, request, signal, true).openAndWait();
+  }
+
+  notify(request: PiExtensionUiNotifyRequest): void {
+    new Notice(getDisplayText(request));
+  }
+
+  setStatus(_request: PiExtensionUiSetStatusRequest): void {}
+  setWidget(_request: PiExtensionUiSetWidgetRequest): void {}
+  setTitle(_request: PiExtensionUiSetTitleRequest): void {}
+  setEditorText(_request: PiExtensionUiSetEditorTextRequest): void {}
+}
+
+function getDisplayText(request: Record<string, unknown>): string {
+  const message = typeof request.message === 'string' ? request.message.trim() : '';
+  const title = typeof request.title === 'string' ? request.title.trim() : '';
+  return message || title || 'Pi extension notification.';
+}
+
+function getTitle(request: Record<string, unknown>, fallback: string): string {
+  return typeof request.title === 'string' && request.title.trim()
+    ? request.title.trim()
+    : fallback;
+}
+
+function getMessage(request: Record<string, unknown>): string {
+  return typeof request.message === 'string' ? request.message.trim() : '';
+}
+
+interface PiSelectOption {
+  label: string;
+  value: string;
+}
+
+function getSelectOptions(request: Record<string, unknown>): PiSelectOption[] {
+  const rawOptions = Array.isArray(request.options) ? request.options : [];
+  return rawOptions.flatMap((option): PiSelectOption[] => {
+    if (typeof option === 'string' && option.trim()) {
+      return [{ label: option.trim(), value: option.trim() }];
+    }
+    if (!option || typeof option !== 'object' || Array.isArray(option)) {
+      return [];
+    }
+
+    const record = option as Record<string, unknown>;
+    const value = typeof record.value === 'string' ? record.value.trim() : '';
+    const label = typeof record.label === 'string' && record.label.trim()
+      ? record.label.trim()
+      : value;
+    return value ? [{ label, value }] : [];
+  });
+}
+
+abstract class PiExtensionModal<TResult extends Record<string, unknown>> extends Modal {
+  private done = false;
+  private resolve!: (result: TResult) => void;
+  private readonly resultPromise = new Promise<TResult>((resolve) => {
+    this.resolve = resolve;
+  });
+
+  constructor(
+    app: App,
+    protected readonly request: Record<string, unknown>,
+    private readonly signal: AbortSignal,
+  ) {
+    super(app);
+  }
+
+  openAndWait(): Promise<TResult> {
+    if (this.signal.aborted) {
+      return Promise.resolve(this.cancelledResult());
+    }
+
+    const abortHandler = (): void => {
+      this.finish(this.cancelledResult());
+      this.close();
+    };
+    this.signal.addEventListener('abort', abortHandler, { once: true });
+    void this.resultPromise.finally(() => {
+      this.signal.removeEventListener('abort', abortHandler);
+    });
+    this.open();
+    return this.resultPromise;
+  }
+
+  override onOpen(): void {
+    this.contentEl.empty();
+    this.contentEl.addClass('claudian-pi-extension-modal');
+    this.render();
+  }
+
+  override onClose(): void {
+    this.finish(this.cancelledResult());
+  }
+
+  protected abstract cancelledResult(): TResult;
+  protected abstract render(): void;
+
+  protected finish(result: TResult): void {
+    if (this.done) {
+      return;
+    }
+
+    this.done = true;
+    this.resolve(result);
+  }
+
+  protected renderHeader(fallbackTitle: string): void {
+    this.contentEl.createEl('h2', { text: getTitle(this.request, fallbackTitle) });
+    const message = getMessage(this.request);
+    if (message) {
+      this.contentEl.createEl('p', { text: message });
+    }
+  }
+}
+
+class PiSelectModal extends PiExtensionModal<{ cancelled?: boolean; value?: string }> {
+  protected cancelledResult(): { cancelled: true } {
+    return { cancelled: true };
+  }
+
+  protected render(): void {
+    this.renderHeader('Pi extension');
+    const options = getSelectOptions(this.request);
+    const listEl = this.contentEl.createDiv({ cls: 'claudian-pi-extension-options' });
+    for (const option of options) {
+      const button = listEl.createEl('button', { text: option.label });
+      button.addEventListener('click', () => {
+        this.finish({ value: option.value });
+        this.close();
+      });
+    }
+    this.renderCancelButton();
+  }
+
+  private renderCancelButton(): void {
+    const cancelButton = this.contentEl.createEl('button', { text: 'Cancel' });
+    cancelButton.addEventListener('click', () => {
+      this.finish({ cancelled: true });
+      this.close();
+    });
+  }
+}
+
+class PiConfirmModal extends PiExtensionModal<{ cancelled?: boolean; confirmed?: boolean }> {
+  protected cancelledResult(): { cancelled: true } {
+    return { cancelled: true };
+  }
+
+  protected render(): void {
+    this.renderHeader('Pi extension');
+    const actionsEl = this.contentEl.createDiv({ cls: 'claudian-pi-extension-actions' });
+    const confirmButton = actionsEl.createEl('button', { text: 'Confirm' });
+    confirmButton.addEventListener('click', () => {
+      this.finish({ confirmed: true });
+      this.close();
+    });
+    const cancelButton = actionsEl.createEl('button', { text: 'Cancel' });
+    cancelButton.addEventListener('click', () => {
+      this.finish({ confirmed: false });
+      this.close();
+    });
+  }
+}
+
+class PiTextModal extends PiExtensionModal<{ cancelled?: boolean; value?: string }> {
+  constructor(
+    app: App,
+    request: Record<string, unknown>,
+    signal: AbortSignal,
+    private readonly multiline: boolean,
+  ) {
+    super(app, request, signal);
+  }
+
+  protected cancelledResult(): { cancelled: true } {
+    return { cancelled: true };
+  }
+
+  protected render(): void {
+    this.renderHeader('Pi extension');
+    const initialValue = typeof this.request.value === 'string'
+      ? this.request.value
+      : typeof this.request.defaultValue === 'string'
+      ? this.request.defaultValue
+      : '';
+    const input = this.multiline
+      ? this.contentEl.createEl('textarea')
+      : this.contentEl.createEl('input', { type: 'text' });
+    input.value = initialValue;
+    if (this.multiline) {
+      (input as HTMLTextAreaElement).rows = 8;
+    }
+
+    const actionsEl = this.contentEl.createDiv({ cls: 'claudian-pi-extension-actions' });
+    const submitButton = actionsEl.createEl('button', { text: 'Submit' });
+    submitButton.addEventListener('click', () => {
+      this.finish({ value: input.value });
+      this.close();
+    });
+    const cancelButton = actionsEl.createEl('button', { text: 'Cancel' });
+    cancelButton.addEventListener('click', () => {
+      this.finish({ cancelled: true });
+      this.close();
+    });
+    window.setTimeout(() => input.focus(), 0);
+  }
+}

package/src/providers/pi/ui/PiChatUIConfig.ts

@@ -0,0 +1,265 @@
+import type {
+  ProviderChatUIConfig,
+  ProviderPermissionModeToggleConfig,
+  ProviderReasoningOption,
+  ProviderUIOption,
+} from '../../../core/providers/types';
+import { PI_PROVIDER_ICON } from '../../../shared/icons';
+import {
+  clampPiThinkingLevel,
+  decodePiModelId,
+  getPiSupportedThinkingLevels,
+  isPiModelSelectionId,
+  PI_DEFAULT_THINKING_LEVEL,
+  PI_SYNTHETIC_MODEL_ID,
+  type PiDiscoveredModel,
+  type PiThinkingLevel,
+} from '../models';
+import {
+  getPiProviderSettings,
+  updatePiProviderSettings,
+} from '../settings';
+
+const PI_MODELS: ProviderUIOption[] = [
+  { value: PI_SYNTHETIC_MODEL_ID, label: 'Pi', description: 'Configure models in settings' },
+];
+const DEFAULT_PI_REASONING_LEVELS = getPiSupportedThinkingLevels({ reasoning: true });
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const PI_PERMISSION_MODE_TOGGLE: ProviderPermissionModeToggleConfig = {
+  inactiveValue: 'normal',
+  inactiveLabel: 'Read-only',
+  activeValue: 'yolo',
+  activeLabel: 'All tools',
+};
+
+export const piChatUIConfig: ProviderChatUIConfig = {
+  getModelOptions(settings): ProviderUIOption[] {
+    const piSettings = getPiProviderSettings(settings);
+    const discoveredModels = new Map(piSettings.discoveredModels.map((model) => [
+      model.encodedId,
+      buildModelOption(model, piSettings.modelAliases[model.encodedId]),
+    ]));
+    const savedProviderModel = (
+      settings.savedProviderModel
+      && typeof settings.savedProviderModel === 'object'
+      && !Array.isArray(settings.savedProviderModel)
+    )
+      ? settings.savedProviderModel as Record<string, unknown>
+      : null;
+
+    const options: ProviderUIOption[] = [];
+    const seen = new Set<string>();
+    for (const encodedId of piSettings.visibleModels) {
+      pushOption(
+        options,
+        seen,
+        encodedId,
+        discoveredModels.get(encodedId)
+          ?? {
+            description: 'Configured model',
+            label: piSettings.modelAliases[encodedId] ?? formatFallbackLabel(encodedId),
+            value: encodedId,
+          },
+      );
+    }
+
+    const selectedModelValues = [
+      typeof settings.model === 'string' ? settings.model : '',
+      typeof savedProviderModel?.pi === 'string' ? savedProviderModel.pi : '',
+    ];
+
+    for (const model of selectedModelValues) {
+      if (!model || model === PI_SYNTHETIC_MODEL_ID || !decodePiModelId(model)) {
+        continue;
+      }
+
+      pushOption(
+        options,
+        seen,
+        model,
+        discoveredModels.get(model)
+          ?? {
+            description: 'Selected in an existing session',
+            label: piSettings.modelAliases[model] ?? formatFallbackLabel(model),
+            value: model,
+          },
+      );
+    }
+
+    return options.length > 0 ? options : [...PI_MODELS];
+  },
+
+  ownsModel(model: string): boolean {
+    return model === PI_SYNTHETIC_MODEL_ID || decodePiModelId(model) !== null;
+  },
+
+  isAdaptiveReasoningModel(model: string, settings: Record<string, unknown>): boolean {
+    const piModel = getCachedModel(model, settings);
+    if (piModel) {
+      return piModel.thinkingLevels.some(level => level !== 'off');
+    }
+
+    return !!decodePiModelId(model);
+  },
+
+  getReasoningOptions(model: string, settings: Record<string, unknown>): ProviderReasoningOption[] {
+    const piModel = getCachedModel(model, settings);
+    const levels = piModel?.thinkingLevels
+      ?? (decodePiModelId(model) ? DEFAULT_PI_REASONING_LEVELS : ['off']);
+    return levels.map((level) => ({
+      label: formatThinkingLevelLabel(level),
+      value: level,
+    }));
+  },
+
+  getDefaultReasoningValue: getPiDefaultReasoningValue,
+
+  getContextWindowSize(
+    model: string,
+    customLimits?: Record<string, number>,
+    settings?: Record<string, unknown>,
+  ): number {
+    const metadataContextWindow = settings
+      ? getCachedModel(model, settings)?.contextWindow
+      : undefined;
+    return metadataContextWindow ?? customLimits?.[model] ?? DEFAULT_CONTEXT_WINDOW;
+  },
+
+  isDefaultModel(model: string): boolean {
+    return isPiModelSelectionId(model);
+  },
+
+  applyModelDefaults(model: string, settings: unknown): void {
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return;
+    }
+
+    const settingsBag = settings as Record<string, unknown>;
+    if (!decodePiModelId(model)) {
+      settingsBag.effortLevel = 'off';
+      return;
+    }
+
+    settingsBag.model = model;
+    settingsBag.effortLevel = getPiDefaultReasoningValue(model, settingsBag);
+  },
+
+  applyReasoningSelection(model: string, value: string, settings: unknown): void {
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return;
+    }
+
+    const settingsBag = settings as Record<string, unknown>;
+    const piModel = getCachedModel(model, settingsBag);
+    const encodedId = piModel?.encodedId ?? (decodePiModelId(model) ? model : '');
+    if (!encodedId) {
+      return;
+    }
+    const supportedLevels = piModel?.thinkingLevels ?? DEFAULT_PI_REASONING_LEVELS;
+
+    const nextPreferredThinkingByModel = {
+      ...getPiProviderSettings(settingsBag).preferredThinkingByModel,
+    };
+    const normalizedValue = value as PiThinkingLevel;
+    if (!supportedLevels.includes(normalizedValue)) {
+      delete nextPreferredThinkingByModel[encodedId];
+    } else {
+      nextPreferredThinkingByModel[encodedId] = normalizedValue;
+    }
+
+    updatePiProviderSettings(settingsBag, {
+      preferredThinkingByModel: nextPreferredThinkingByModel,
+    });
+  },
+
+  normalizeModelVariant(model: string): string {
+    return decodePiModelId(model) ? model : model;
+  },
+
+  getCustomModelIds(): Set<string> {
+    return new Set<string>();
+  },
+
+  getModeSelector(): null {
+    return null;
+  },
+
+  getPermissionModeToggle(): ProviderPermissionModeToggleConfig {
+    return PI_PERMISSION_MODE_TOGGLE;
+  },
+
+  resolvePermissionMode(settings: Record<string, unknown>): string | null {
+    return getPiProviderSettings(settings).toolMode === 'readonly' ? 'normal' : 'yolo';
+  },
+
+  applyPermissionMode(value: string, settings: unknown): void {
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      return;
+    }
+
+    const settingsBag = settings as Record<string, unknown>;
+    settingsBag.permissionMode = value;
+    updatePiProviderSettings(settingsBag, {
+      toolMode: value === 'normal' ? 'readonly' : 'all',
+    });
+  },
+
+  getProviderIcon() {
+    return PI_PROVIDER_ICON;
+  },
+};
+
+function getCachedModel(model: string, settings: Record<string, unknown>): PiDiscoveredModel | null {
+  if (!decodePiModelId(model)) {
+    return null;
+  }
+
+  return getPiProviderSettings(settings).discoveredModels.find(entry => entry.encodedId === model) ?? null;
+}
+
+function getPiDefaultReasoningValue(model: string, settings: Record<string, unknown>): string {
+  const piModel = getCachedModel(model, settings);
+  if (!piModel) {
+    return decodePiModelId(model) ? PI_DEFAULT_THINKING_LEVEL : 'off';
+  }
+
+  const piSettings = getPiProviderSettings(settings);
+  return clampPiThinkingLevel(
+    piSettings.preferredThinkingByModel[piModel.encodedId],
+    piModel.thinkingLevels,
+  );
+}
+
+function buildModelOption(model: PiDiscoveredModel, alias: string | undefined): ProviderUIOption {
+  return {
+    description: `${model.provider} runtime`,
+    group: model.provider,
+    label: alias ?? model.label,
+    value: model.encodedId,
+  };
+}
+
+function formatFallbackLabel(encodedId: string): string {
+  const decoded = decodePiModelId(encodedId);
+  return decoded ? `${decoded.provider}/${decoded.modelId}` : 'Pi';
+}
+
+function formatThinkingLevelLabel(value: PiThinkingLevel): string {
+  return value === 'xhigh'
+    ? 'XHigh'
+    : value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function pushOption(
+  target: ProviderUIOption[],
+  seenValues: Set<string>,
+  value: string,
+  option: ProviderUIOption,
+): void {
+  if (seenValues.has(value)) {
+    return;
+  }
+
+  seenValues.add(value);
+  target.push(option);
+}

package/src/providers/pi/ui/PiExtensionUiRenderer.ts

@@ -0,0 +1,12 @@
+export type {
+  PiExtensionUiConfirmRequest,
+  PiExtensionUiEditorRequest,
+  PiExtensionUiInputRequest,
+  PiExtensionUiNotifyRequest,
+  PiExtensionUiRenderer,
+  PiExtensionUiSelectRequest,
+  PiExtensionUiSetEditorTextRequest,
+  PiExtensionUiSetStatusRequest,
+  PiExtensionUiSetTitleRequest,
+  PiExtensionUiSetWidgetRequest,
+} from '../runtime/PiExtensionUiBridge';