@mseep/claudian 2.0.25

package/src/features/settings/keyboardNavigation.ts

@@ -0,0 +1,60 @@
+import type { KeyboardNavigationSettings } from '@/core/types/settings';
+
+const NAV_ACTIONS = ['scrollUp', 'scrollDown', 'focusInput'] as const;
+type NavAction = (typeof NAV_ACTIONS)[number];
+
+export const buildNavMappingText = (settings: KeyboardNavigationSettings): string => {
+  return [
+    `map ${settings.scrollUpKey} scrollUp`,
+    `map ${settings.scrollDownKey} scrollDown`,
+    `map ${settings.focusInputKey} focusInput`,
+  ].join('\n');
+};
+
+export const parseNavMappings = (
+  value: string
+): { settings?: Record<NavAction, string>; error?: string } => {
+  const parsed: Partial<Record<NavAction, string>> = {};
+  const usedKeys = new Map<string, string>();
+  const lines = value.split('\n');
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const parts = line.split(/\s+/);
+    if (parts.length !== 3 || parts[0] !== 'map') {
+      return { error: 'Each line must follow "map <key> <action>"' };
+    }
+
+    const key = parts[1];
+    const action = parts[2] as NavAction;
+
+    if (!NAV_ACTIONS.includes(action)) {
+      return { error: `Unknown action: ${parts[2]}` };
+    }
+
+    if (key.length !== 1) {
+      return { error: `Key must be a single character for ${action}` };
+    }
+
+    const normalizedKey = key.toLowerCase();
+    if (usedKeys.has(normalizedKey)) {
+      return { error: 'Navigation keys must be unique' };
+    }
+
+    if (parsed[action]) {
+      return { error: `Duplicate mapping for ${action}` };
+    }
+
+    usedKeys.set(normalizedKey, action);
+    parsed[action] = key;
+  }
+
+  const missing = NAV_ACTIONS.filter((action) => !parsed[action]);
+  if (missing.length > 0) {
+    return { error: `Missing mapping for ${missing.join(', ')}` };
+  }
+
+  return { settings: parsed as Record<NavAction, string> };
+};

package/src/features/settings/ui/EnvSnippetManager.ts

@@ -0,0 +1,430 @@
+import type { App } from 'obsidian';
+import { Modal, Notice, setIcon, Setting } from 'obsidian';
+
+import {
+  getEnvironmentScopeUpdates,
+  resolveEnvironmentSnippetScope,
+} from '../../../core/providers/providerEnvironment';
+import { ProviderRegistry } from '../../../core/providers/ProviderRegistry';
+import type { EnvironmentScope, EnvSnippet } from '../../../core/types';
+import { t } from '../../../i18n/i18n';
+import type ClaudianPlugin from '../../../main';
+import { confirmDelete } from '../../../shared/modals/ConfirmModal';
+import { formatContextLimit, parseContextLimit, parseEnvironmentVariables } from '../../../utils/env';
+import type { ClaudianView } from '../../chat/ClaudianView';
+
+export class EnvSnippetModal extends Modal {
+  plugin: ClaudianPlugin;
+  snippet: EnvSnippet | null;
+  snippetScope: EnvironmentScope;
+  onSave: (snippet: EnvSnippet) => void;
+
+  constructor(
+    app: App,
+    plugin: ClaudianPlugin,
+    snippet: EnvSnippet | null,
+    scope: EnvironmentScope,
+    onSave: (snippet: EnvSnippet) => void,
+  ) {
+    super(app);
+    this.plugin = plugin;
+    this.snippet = snippet;
+    this.snippetScope = scope;
+    this.onSave = onSave;
+  }
+
+  onOpen() {
+    const { contentEl } = this;
+    this.setTitle(this.snippet ? t('settings.envSnippets.modal.titleEdit') : t('settings.envSnippets.modal.titleSave'));
+
+    this.modalEl.addClass('claudian-env-snippet-modal');
+
+    let nameEl: HTMLInputElement;
+    let descEl: HTMLInputElement;
+    let envVarsEl: HTMLTextAreaElement;
+    const contextLimitInputs: Map<string, HTMLInputElement> = new Map();
+    const modelAliasInputs: Map<string, HTMLInputElement> = new Map();
+    let contextLimitsContainer: HTMLElement | null = null;
+
+    // !e.isComposing for IME support (Chinese, Japanese, Korean, etc.)
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Enter' && !e.isComposing) {
+        e.preventDefault();
+        saveSnippet();
+      } else if (e.key === 'Escape' && !e.isComposing) {
+        e.preventDefault();
+        this.close();
+      }
+    };
+
+    const saveSnippet = () => {
+      const name = nameEl.value.trim();
+      if (!name) {
+        new Notice(t('settings.envSnippets.nameRequired'));
+        return;
+      }
+
+      const contextLimits: Record<string, number> = {};
+      for (const [modelId, input] of contextLimitInputs) {
+        const value = input.value.trim();
+        if (value) {
+          const parsed = parseContextLimit(value);
+          if (parsed !== null) {
+            contextLimits[modelId] = parsed;
+          }
+        }
+      }
+
+      const modelAliases: Record<string, string> = {};
+      for (const [modelId, input] of modelAliasInputs) {
+        const value = input.value.trim();
+        if (value) {
+          modelAliases[modelId] = value;
+        }
+      }
+
+      const snippet: EnvSnippet = {
+        id: this.snippet?.id || `snippet-${Date.now()}`,
+        name,
+        description: descEl.value.trim(),
+        envVars: envVarsEl.value,
+        scope: resolveEnvironmentSnippetScope(
+          envVarsEl.value,
+          this.snippet?.scope ?? this.snippetScope,
+        ),
+        contextLimits: Object.keys(contextLimits).length > 0 ? contextLimits : undefined,
+        modelAliases: modelAliasInputs.size > 0 ? modelAliases : undefined,
+      };
+
+      this.onSave(snippet);
+      this.close();
+    };
+
+    const renderContextLimitFields = () => {
+      if (!contextLimitsContainer) return;
+      contextLimitsContainer.empty();
+      contextLimitInputs.clear();
+      modelAliasInputs.clear();
+
+      const envVars = parseEnvironmentVariables(envVarsEl.value);
+      const uniqueModelIds = ProviderRegistry.getCustomModelIds(envVars);
+
+      if (uniqueModelIds.size === 0) {
+        contextLimitsContainer.addClass('claudian-hidden');
+        return;
+      }
+
+      contextLimitsContainer.removeClass('claudian-hidden');
+
+      const existingLimits = this.snippet?.contextLimits ?? this.plugin.settings.customContextLimits ?? {};
+      const existingAliases = this.snippet?.modelAliases ?? this.plugin.settings.customModelAliases ?? {};
+
+      contextLimitsContainer.createEl('div', {
+        text: t('settings.customModelOverrides.name'),
+        cls: 'setting-item-name',
+      });
+      contextLimitsContainer.createEl('div', {
+        text: t('settings.customModelOverrides.desc'),
+        cls: 'setting-item-description',
+      });
+
+      for (const modelId of uniqueModelIds) {
+        const row = contextLimitsContainer.createDiv({ cls: 'claudian-snippet-limit-row' });
+        row.createSpan({ text: modelId, cls: 'claudian-snippet-limit-model' });
+        row.createSpan({ cls: 'claudian-snippet-limit-spacer' });
+
+        const aliasInput = row.createEl('input', {
+          type: 'text',
+          placeholder: t('settings.customModelAliases.placeholder'),
+          cls: 'claudian-snippet-alias-input',
+        });
+        aliasInput.value = existingAliases[modelId] ?? '';
+        aliasInput.setAttribute('aria-label', `Alias for ${modelId}`);
+        aliasInput.title = 'Custom label shown in the model selector. Leave empty to use the default.';
+        modelAliasInputs.set(modelId, aliasInput);
+
+        const input = row.createEl('input', {
+          type: 'text',
+          placeholder: '200k',
+          cls: 'claudian-snippet-limit-input',
+        });
+        input.value = existingLimits[modelId] ? formatContextLimit(existingLimits[modelId]) : '';
+        input.setAttribute('aria-label', `Context window for ${modelId}`);
+        contextLimitInputs.set(modelId, input);
+      }
+    };
+
+    new Setting(contentEl)
+      .setName(t('settings.envSnippets.modal.name'))
+      .setDesc(t('settings.envSnippets.modal.namePlaceholder'))
+      .addText((text) => {
+        nameEl = text.inputEl;
+        text.setValue(this.snippet?.name || '');
+                text.inputEl.addEventListener('keydown', handleKeyDown);
+      });
+
+    new Setting(contentEl)
+      .setName(t('settings.envSnippets.modal.description'))
+      .setDesc(t('settings.envSnippets.modal.descPlaceholder'))
+      .addText((text) => {
+        descEl = text.inputEl;
+        text.setValue(this.snippet?.description || '');
+                text.inputEl.addEventListener('keydown', handleKeyDown);
+      });
+
+    const envVarsSetting = new Setting(contentEl)
+      .setName(t('settings.envSnippets.modal.envVars'))
+      .setDesc(t('settings.envSnippets.modal.envVarsPlaceholder'))
+      .addTextArea((text) => {
+        envVarsEl = text.inputEl;
+        const envVarsToShow = this.snippet?.envVars ?? this.plugin.getEnvironmentVariablesForScope(this.snippetScope);
+        text.setValue(envVarsToShow);
+        text.inputEl.rows = 8;
+        text.inputEl.addEventListener('blur', () => renderContextLimitFields());
+      });
+    envVarsSetting.settingEl.addClass('claudian-env-snippet-setting');
+    envVarsSetting.controlEl.addClass('claudian-env-snippet-control');
+
+    contextLimitsContainer = contentEl.createDiv({ cls: 'claudian-snippet-context-limits' });
+    renderContextLimitFields();
+
+    const buttonContainer = contentEl.createDiv({ cls: 'claudian-snippet-buttons' });
+
+    const cancelBtn = buttonContainer.createEl('button', {
+      text: t('settings.envSnippets.modal.cancel'),
+      cls: 'claudian-cancel-btn'
+    });
+    cancelBtn.addEventListener('click', () => this.close());
+
+    const saveBtn = buttonContainer.createEl('button', {
+      text: this.snippet ? t('settings.envSnippets.modal.update') : t('settings.envSnippets.modal.save'),
+      cls: 'claudian-save-btn'
+    });
+    saveBtn.addEventListener('click', () => saveSnippet());
+
+    // Focus name input after modal is rendered (timeout for Windows compatibility)
+    window.setTimeout(() => nameEl?.focus(), 50);
+  }
+
+  onClose() {
+    const { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+export class EnvSnippetManager {
+  private containerEl: HTMLElement;
+  private plugin: ClaudianPlugin;
+  private scope: EnvironmentScope;
+  private onContextLimitsChange?: () => void;
+
+  constructor(
+    containerEl: HTMLElement,
+    plugin: ClaudianPlugin,
+    scope: EnvironmentScope,
+    onContextLimitsChange?: () => void,
+  ) {
+    this.containerEl = containerEl;
+    this.plugin = plugin;
+    this.scope = scope;
+    this.onContextLimitsChange = onContextLimitsChange;
+    this.render();
+  }
+
+  private render() {
+    this.containerEl.empty();
+
+    const headerEl = this.containerEl.createDiv({ cls: 'claudian-snippet-header' });
+    headerEl.createSpan({ text: t('settings.envSnippets.name'), cls: 'claudian-snippet-label' });
+
+    const saveBtn = headerEl.createEl('button', {
+      cls: 'claudian-settings-action-btn',
+      attr: { 'aria-label': t('settings.envSnippets.addBtn') },
+    });
+    setIcon(saveBtn, 'plus');
+    saveBtn.addEventListener('click', () => {
+      void this.saveCurrentEnv();
+    });
+
+    const snippets = this.plugin.settings.envSnippets.filter((snippet) => this.shouldDisplaySnippet(snippet));
+
+    if (snippets.length === 0) {
+      const emptyEl = this.containerEl.createDiv({ cls: 'claudian-snippet-empty' });
+      emptyEl.setText(t('settings.envSnippets.noSnippets'));
+      return;
+    }
+
+    const listEl = this.containerEl.createDiv({ cls: 'claudian-snippet-list' });
+
+    for (const snippet of snippets) {
+      const itemEl = listEl.createDiv({ cls: 'claudian-snippet-item' });
+
+      const infoEl = itemEl.createDiv({ cls: 'claudian-snippet-info' });
+
+      const nameEl = infoEl.createDiv({ cls: 'claudian-snippet-name' });
+      nameEl.setText(snippet.name);
+
+      if (snippet.description) {
+        const descEl = infoEl.createDiv({ cls: 'claudian-snippet-description' });
+        descEl.setText(snippet.description);
+      }
+
+      const actionsEl = itemEl.createDiv({ cls: 'claudian-snippet-actions' });
+
+      const restoreBtn = actionsEl.createEl('button', {
+        cls: 'claudian-settings-action-btn',
+        attr: { 'aria-label': 'Insert' },
+      });
+      setIcon(restoreBtn, 'clipboard-paste');
+      restoreBtn.addEventListener('click', () => {
+        void (async (): Promise<void> => {
+        try {
+          await this.insertSnippet(snippet);
+        } catch {
+          new Notice('Failed to insert snippet');
+        }
+        })();
+      });
+
+      const editBtn = actionsEl.createEl('button', {
+        cls: 'claudian-settings-action-btn',
+        attr: { 'aria-label': 'Edit' },
+      });
+      setIcon(editBtn, 'pencil');
+      editBtn.addEventListener('click', () => {
+        this.editSnippet(snippet);
+      });
+
+      const deleteBtn = actionsEl.createEl('button', {
+        cls: 'claudian-settings-action-btn claudian-settings-delete-btn',
+        attr: { 'aria-label': 'Delete' },
+      });
+      setIcon(deleteBtn, 'trash-2');
+      deleteBtn.addEventListener('click', () => {
+        void (async (): Promise<void> => {
+        try {
+          if (await confirmDelete(this.plugin.app, `Delete environment snippet "${snippet.name}"?`)) {
+            await this.deleteSnippet(snippet);
+          }
+        } catch {
+          new Notice('Failed to delete snippet');
+        }
+        })();
+      });
+    }
+  }
+
+  private async saveCurrentEnv() {
+    const modal = new EnvSnippetModal(
+      this.plugin.app,
+      this.plugin,
+      null,
+      this.scope,
+      (snippet) => {
+        void (async (): Promise<void> => {
+          this.plugin.settings.envSnippets.push(snippet);
+          await this.plugin.saveSettings();
+          this.render();
+          new Notice(`Environment snippet "${snippet.name}" saved`);
+        })();
+      }
+    );
+    modal.open();
+  }
+
+  private async insertSnippet(snippet: EnvSnippet) {
+    const snippetContent = snippet.envVars.trim();
+    const updates = getEnvironmentScopeUpdates(
+      snippetContent,
+      snippet.scope ?? this.scope,
+    );
+
+    if (updates.length === 1) {
+      const [update] = updates;
+      this.syncTextareaValue(update.scope, update.envText);
+      await this.plugin.applyEnvironmentVariables(update.scope, update.envText);
+    } else if (updates.length > 1) {
+      for (const update of updates) {
+        this.syncTextareaValue(update.scope, update.envText);
+      }
+      await this.plugin.applyEnvironmentVariablesBatch(updates);
+    }
+
+    // Legacy snippets without contextLimits don't modify limits
+    if (snippet.contextLimits) {
+      this.plugin.settings.customContextLimits = {
+        ...this.plugin.settings.customContextLimits,
+        ...snippet.contextLimits,
+      };
+    }
+
+    // Legacy snippets without modelAliases don't modify aliases. Snippets saved
+    // with alias fields clear aliases for their own model IDs when left empty.
+    if (snippet.modelAliases) {
+      const modelIds = ProviderRegistry.getCustomModelIds(parseEnvironmentVariables(snippet.envVars));
+      const nextAliases = { ...(this.plugin.settings.customModelAliases ?? {}) };
+      for (const modelId of modelIds) {
+        const alias = snippet.modelAliases[modelId]?.trim();
+        if (alias) {
+          nextAliases[modelId] = alias;
+        } else {
+          delete nextAliases[modelId];
+        }
+      }
+      this.plugin.settings.customModelAliases = nextAliases;
+    }
+    await this.plugin.saveSettings();
+
+    this.onContextLimitsChange?.();
+    const view = this.plugin.app.workspace.getLeavesOfType('claudian-view')[0]?.view as ClaudianView | undefined;
+    view?.refreshModelSelector();
+  }
+
+  private editSnippet(snippet: EnvSnippet) {
+    const modal = new EnvSnippetModal(
+      this.plugin.app,
+      this.plugin,
+      snippet,
+      this.scope,
+      (updatedSnippet) => {
+        void (async (): Promise<void> => {
+          const index = this.plugin.settings.envSnippets.findIndex(s => s.id === snippet.id);
+          if (index !== -1) {
+            this.plugin.settings.envSnippets[index] = updatedSnippet;
+            await this.plugin.saveSettings();
+            this.render();
+            new Notice(`Environment snippet "${updatedSnippet.name}" updated`);
+          }
+        })();
+      }
+    );
+    modal.open();
+  }
+
+  private async deleteSnippet(snippet: EnvSnippet) {
+    this.plugin.settings.envSnippets = this.plugin.settings.envSnippets.filter(s => s.id !== snippet.id);
+    await this.plugin.saveSettings();
+    this.render();
+    new Notice(`Environment snippet "${snippet.name}" deleted`);
+  }
+
+  public refresh() {
+    this.render();
+  }
+
+  private shouldDisplaySnippet(snippet: EnvSnippet): boolean {
+    if (this.scope === 'shared') {
+      return !snippet.scope || snippet.scope === 'shared';
+    }
+
+    return snippet.scope === this.scope;
+  }
+
+  private syncTextareaValue(scope: EnvironmentScope, value: string): void {
+    const selector = `.claudian-settings-env-textarea[data-env-scope="${scope}"]`;
+    const envTextarea = (this.containerEl.ownerDocument ?? window.document).querySelector<HTMLTextAreaElement>(selector);
+    if (envTextarea) {
+      envTextarea.value = value;
+    }
+  }
+}

package/src/features/settings/ui/EnvironmentSettingsSection.ts

@@ -0,0 +1,85 @@
+import { Setting } from 'obsidian';
+
+import { getEnvironmentReviewKeysForScope } from '../../../core/providers/providerEnvironment';
+import type { EnvironmentScope } from '../../../core/types/settings';
+import type ClaudianPlugin from '../../../main';
+import { EnvSnippetManager } from './EnvSnippetManager';
+
+interface EnvironmentSettingsSectionOptions {
+  container: HTMLElement;
+  plugin: ClaudianPlugin;
+  scope: EnvironmentScope;
+  heading?: string;
+  name: string;
+  desc: string;
+  placeholder: string;
+  renderCustomContextLimits?: (container: HTMLElement) => void;
+}
+
+export function renderEnvironmentSettingsSection(
+  options: EnvironmentSettingsSectionOptions,
+): void {
+  const {
+    container,
+    plugin,
+    scope,
+    heading,
+    name,
+    desc,
+    placeholder,
+    renderCustomContextLimits,
+  } = options;
+
+  if (heading) {
+    new Setting(container).setName(heading).setHeading();
+  }
+
+  let envTextarea: HTMLTextAreaElement | null = null;
+  const reviewEl = container.createDiv({
+    cls: 'claudian-env-review-warning claudian-setting-validation claudian-setting-validation-warning claudian-hidden',
+  });
+
+  const updateReviewWarning = () => {
+    const reviewKeys = getEnvironmentReviewKeysForScope(envTextarea?.value ?? '', scope);
+    if (reviewKeys.length === 0) {
+      reviewEl.toggleClass('claudian-hidden', true);
+      reviewEl.empty();
+      return;
+    }
+
+    reviewEl.setText(`Review environment ownership for: ${reviewKeys.join(', ')}`);
+    reviewEl.toggleClass('claudian-hidden', false);
+  };
+
+  new Setting(container)
+    .setName(name)
+    .setDesc(desc)
+    .addTextArea((text) => {
+      text
+        .setPlaceholder(placeholder)
+        .setValue(plugin.getEnvironmentVariablesForScope(scope));
+      text.inputEl.rows = 6;
+      text.inputEl.cols = 50;
+      text.inputEl.addClass('claudian-settings-env-textarea');
+      text.inputEl.dataset.envScope = scope;
+      text.inputEl.addEventListener('input', () => updateReviewWarning());
+      text.inputEl.addEventListener('blur', () => {
+        void (async (): Promise<void> => {
+          await plugin.applyEnvironmentVariables(scope, text.inputEl.value);
+          renderCustomContextLimits?.(contextLimitsContainer);
+          updateReviewWarning();
+        })();
+      });
+      envTextarea = text.inputEl;
+    });
+
+  updateReviewWarning();
+
+  const contextLimitsContainer = container.createDiv({ cls: 'claudian-context-limits-container' });
+  renderCustomContextLimits?.(contextLimitsContainer);
+
+  const envSnippetsContainer = container.createDiv({ cls: 'claudian-env-snippets-container' });
+  new EnvSnippetManager(envSnippetsContainer, plugin, scope, () => {
+    renderCustomContextLimits?.(contextLimitsContainer);
+  });
+}