@mseep/claudian 2.0.25

package/src/providers/claude/types/models.ts

@@ -0,0 +1,168 @@
+/**
+ * Model type definitions and constants.
+ */
+
+import { toClaudeRuntimeModelId } from '../modelSelection';
+
+/** Model identifier (string to support custom models via environment variables). */
+export type ClaudeModel = string;
+
+export const DEFAULT_CLAUDE_MODELS: { value: ClaudeModel; label: string; description: string }[] = [
+  { value: 'haiku', label: 'Haiku', description: 'Fast and efficient' },
+  { value: 'sonnet', label: 'Sonnet', description: 'Balanced performance' },
+  { value: 'sonnet[1m]', label: 'Sonnet 1M', description: 'Balanced performance (1M context window)' },
+  { value: 'opus', label: 'Opus', description: 'Most capable' },
+  { value: 'opus[1m]', label: 'Opus 1M', description: 'Most capable (1M context window)' },
+];
+
+/** Effort levels for adaptive thinking models. */
+export type EffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+export const EFFORT_LEVELS: { value: EffortLevel; label: string }[] = [
+  { value: 'low', label: 'Low' },
+  { value: 'medium', label: 'Med' },
+  { value: 'high', label: 'High' },
+  { value: 'xhigh', label: 'XHigh' },
+  { value: 'max', label: 'Max' },
+];
+
+/** Default effort level per model tier. */
+export const DEFAULT_EFFORT_LEVEL: Record<string, EffortLevel> = {
+  'haiku': 'high',
+  'sonnet': 'high',
+  'sonnet[1m]': 'high',
+  'opus': 'high',
+  'opus[1m]': 'high',
+};
+
+const ONE_M_SUFFIX = '[1m]';
+const DEFAULT_MODEL_VALUES = new Set(DEFAULT_CLAUDE_MODELS.map(m => m.value.toLowerCase()));
+
+function normalizeModelId(model: string): string {
+  return toClaudeRuntimeModelId(model).trim().toLowerCase();
+}
+
+function has1MContextSuffix(model: string): boolean {
+  return normalizeModelId(model).endsWith(ONE_M_SUFFIX);
+}
+
+function isBuiltInFamilyVariant(model: string, family: 'sonnet' | 'opus'): boolean {
+  const normalized = normalizeModelId(model);
+  return normalized === family || normalized === `${family}${ONE_M_SUFFIX}`;
+}
+
+function isValidContextLimit(limit: unknown): limit is number {
+  return typeof limit === 'number' && limit > 0 && !isNaN(limit) && isFinite(limit);
+}
+
+function resolveCustomContextLimit(
+  model: string,
+  customLimits?: Record<string, number>,
+): number | null {
+  if (!customLimits) {
+    return null;
+  }
+
+  const exactLimit = customLimits[model];
+  if (isValidContextLimit(exactLimit)) {
+    return exactLimit;
+  }
+
+  const normalizedModel = normalizeModelId(model);
+  const matchingLimits = Object.entries(customLimits)
+    .filter(([key, limit]) => key !== model && normalizeModelId(key) === normalizedModel && isValidContextLimit(limit))
+    .map(([, limit]) => limit);
+
+  return matchingLimits.length === 1 ? matchingLimits[0] : null;
+}
+
+export function isDefaultClaudeModel(model: string): boolean {
+  return DEFAULT_MODEL_VALUES.has(normalizeModelId(model));
+}
+
+/**
+ * Whether the model supports the `xhigh` effort level. Opus 4.7+ only — the SDK
+ * silently falls back to `high` on other models.
+ */
+export function supportsXHighEffort(model: string): boolean {
+  const normalized = normalizeModelId(model);
+  if (isBuiltInFamilyVariant(normalized, 'opus')) return true;
+  return /claude-opus-(4-[7-9]|[5-9])/.test(normalized);
+}
+
+/** Clamp stored effort values to what the selected model actually supports. */
+export function normalizeEffortLevel(
+  model: string,
+  effortLevel: unknown,
+): EffortLevel {
+  const allowsXHigh = supportsXHighEffort(model);
+  const isSupported = EFFORT_LEVELS.some((level) =>
+    level.value === effortLevel && (allowsXHigh || level.value !== 'xhigh')
+  );
+
+  if (isSupported) {
+    return effortLevel as EffortLevel;
+  }
+
+  return DEFAULT_EFFORT_LEVEL[normalizeModelId(model)] ?? 'high';
+}
+
+export function resolveEffortLevel(
+  model: string,
+  effortLevel: unknown,
+): EffortLevel {
+  return normalizeEffortLevel(model, effortLevel);
+}
+
+export const CONTEXT_WINDOW_STANDARD = 200_000;
+export const CONTEXT_WINDOW_1M = 1_000_000;
+
+export function filterVisibleModelOptions<T extends { value: string }>(
+  models: T[],
+  enableOpus1M: boolean,
+  enableSonnet1M: boolean
+): T[] {
+  return models.filter((model) => {
+    if (isBuiltInFamilyVariant(model.value, 'opus')) {
+      return enableOpus1M ? has1MContextSuffix(model.value) : normalizeModelId(model.value) === 'opus';
+    }
+
+    if (isBuiltInFamilyVariant(model.value, 'sonnet')) {
+      return enableSonnet1M ? has1MContextSuffix(model.value) : normalizeModelId(model.value) === 'sonnet';
+    }
+
+    return true;
+  });
+}
+
+export function normalizeVisibleModelVariant(
+  model: string,
+  enableOpus1M: boolean,
+  enableSonnet1M: boolean
+): string {
+  if (isBuiltInFamilyVariant(model, 'opus')) {
+    return enableOpus1M ? 'opus[1m]' : 'opus';
+  }
+
+  if (isBuiltInFamilyVariant(model, 'sonnet')) {
+    return enableSonnet1M ? 'sonnet[1m]' : 'sonnet';
+  }
+
+  return model;
+}
+
+export function getContextWindowSize(
+  model: string,
+  customLimits?: Record<string, number>
+): number {
+  const customLimit = resolveCustomContextLimit(model, customLimits);
+  if (customLimit !== null) {
+    return customLimit;
+  }
+
+  if (has1MContextSuffix(model)) {
+    return CONTEXT_WINDOW_1M;
+  }
+
+  return CONTEXT_WINDOW_STANDARD;
+}

package/src/providers/claude/types/plugins.ts

@@ -0,0 +1,14 @@
+export interface InstalledPluginEntry {
+  scope: 'user' | 'project';
+  installPath: string;
+  version: string;
+  installedAt: string;
+  lastUpdated: string;
+  gitCommitSha?: string;
+  projectPath?: string;
+}
+
+export interface InstalledPluginsFile {
+  version: number;
+  plugins: Record<string, InstalledPluginEntry[]>;
+}

package/src/providers/claude/types/providerState.ts

@@ -0,0 +1,16 @@
+import type { ForkSource } from '../../../core/types/chat';
+import type { SubagentInfo } from '../../../core/types/tools';
+
+export interface ClaudeProviderState {
+  providerSessionId?: string;
+  previousProviderSessionIds?: string[];
+  forkSource?: ForkSource;
+  subagentData?: Record<string, SubagentInfo>;
+}
+
+/** Extracts typed Claude provider state from the opaque bag. */
+export function getClaudeState(
+  providerState: Record<string, unknown> | undefined,
+): ClaudeProviderState {
+  return (providerState ?? {});
+}

package/src/providers/claude/types/settings.ts

@@ -0,0 +1,98 @@
+/** Claude provider settings and Claude Code compatibility types. */
+
+// Re-export shared defaults for backward compatibility within the Claude package
+export { DEFAULT_CLAUDIAN_SETTINGS as DEFAULT_SETTINGS } from '../../../app/settings/defaultSettings';
+
+/**
+ * CC-compatible permission rule string.
+ * Format: "Tool(pattern)" or "Tool" for all
+ * Examples: "Bash(git *)", "Read(*.md)", "WebFetch(domain:github.com)"
+ */
+export type PermissionRule = string & { readonly __brand: 'PermissionRule' };
+
+/**
+ * Create a PermissionRule from a string.
+ */
+export function createPermissionRule(rule: string): PermissionRule {
+  return rule as PermissionRule;
+}
+
+/**
+ * CC-compatible permissions object.
+ * Stored in .claude/settings.json for interoperability with Claude Code CLI.
+ */
+export interface CCPermissions {
+  /** Rules that auto-approve tool actions */
+  allow?: PermissionRule[];
+  /** Rules that auto-deny tool actions (highest persistent priority) */
+  deny?: PermissionRule[];
+  /** Rules that always prompt for confirmation */
+  ask?: PermissionRule[];
+  /** Default permission mode */
+  defaultMode?: 'acceptEdits' | 'auto' | 'bypassPermissions' | 'default' | 'dontAsk' | 'plan';
+  /** Additional directories to include in permission scope */
+  additionalDirectories?: string[];
+}
+
+/**
+ * CC-compatible settings stored in .claude/settings.json.
+ * These settings are shared with Claude Code CLI.
+ */
+export interface CCSettings {
+  /** JSON Schema reference */
+  $schema?: string;
+  /** Tool permissions (CC format) */
+  permissions?: CCPermissions;
+  /** Model override */
+  model?: string;
+  /** Environment variables (object format) */
+  env?: Record<string, string>;
+  /** MCP server settings */
+  enableAllProjectMcpServers?: boolean;
+  enabledMcpjsonServers?: string[];
+  disabledMcpjsonServers?: string[];
+  /** Plugin enabled state (CC format: { "plugin-id": true/false }) */
+  enabledPlugins?: Record<string, boolean>;
+  /** Allow additional properties for CC compatibility */
+  [key: string]: unknown;
+}
+
+// Old DEFAULT_SETTINGS constant has been moved to src/app/settings/defaultSettings.ts.
+// Re-exported above for backward compatibility within the Claude package.
+
+/** Default CC-compatible settings. */
+export const DEFAULT_CC_SETTINGS: CCSettings = {
+  $schema: 'https://json.schemastore.org/claude-code-settings.json',
+  permissions: {
+    allow: [],
+    deny: [],
+    ask: [],
+  },
+};
+
+/** Default CC permissions. */
+export const DEFAULT_CC_PERMISSIONS: CCPermissions = {
+  allow: [],
+  deny: [],
+  ask: [],
+};
+
+/**
+ * Parse a CC permission rule into tool name and pattern.
+ * Examples:
+ *   "Bash(git *)" → { tool: "Bash", pattern: "git *" }
+ *   "Read" → { tool: "Read", pattern: undefined }
+ *   "WebFetch(domain:github.com)" → { tool: "WebFetch", pattern: "domain:github.com" }
+ */
+export function parseCCPermissionRule(rule: PermissionRule): {
+  tool: string;
+  pattern?: string;
+} {
+  const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+  if (!match) {
+    return { tool: rule };
+  }
+
+  const [, tool, pattern] = match;
+  return { tool, pattern };
+}

package/src/providers/claude/ui/AgentSettings.ts

@@ -0,0 +1,389 @@
+import type { App } from 'obsidian';
+import { Modal, Notice, setIcon, Setting } from 'obsidian';
+
+import type {
+  AppAgentManager,
+  AppAgentStorage,
+} from '../../../core/providers/types';
+import type { AgentDefinition } from '../../../core/types';
+import { t } from '../../../i18n/i18n';
+import { confirmDelete } from '../../../shared/modals/ConfirmModal';
+import { validateAgentName } from '../../../utils/agent';
+
+const MODEL_OPTIONS = [
+  { value: 'inherit', label: 'Inherit' },
+  { value: 'sonnet', label: 'Sonnet' },
+  { value: 'opus', label: 'Opus' },
+  { value: 'haiku', label: 'Haiku' },
+] as const;
+
+class AgentModal extends Modal {
+  private existingAgent: AgentDefinition | null;
+  private getAvailableAgents: () => AgentDefinition[];
+  private onSave: (agent: AgentDefinition) => Promise<void>;
+
+  constructor(
+    app: App,
+    existingAgent: AgentDefinition | null,
+    getAvailableAgents: () => AgentDefinition[],
+    onSave: (agent: AgentDefinition) => Promise<void>
+  ) {
+    super(app);
+    this.existingAgent = existingAgent;
+    this.getAvailableAgents = getAvailableAgents;
+    this.onSave = onSave;
+  }
+
+  onOpen() {
+    this.setTitle(
+      this.existingAgent
+        ? t('settings.subagents.modal.titleEdit')
+        : t('settings.subagents.modal.titleAdd')
+    );
+    this.modalEl.addClass('claudian-sp-modal');
+
+    const { contentEl } = this;
+
+    let nameInput: HTMLInputElement;
+    let descInput: HTMLInputElement;
+    let modelValue: string = this.existingAgent?.model ?? 'inherit';
+    let toolsInput: HTMLInputElement;
+    let disallowedToolsInput: HTMLInputElement;
+    let skillsInput: HTMLInputElement;
+
+    new Setting(contentEl)
+      .setName(t('settings.subagents.modal.name'))
+      .setDesc(t('settings.subagents.modal.nameDesc'))
+      .addText(text => {
+        nameInput = text.inputEl;
+        text.setValue(this.existingAgent?.name || '')
+          .setPlaceholder(t('settings.subagents.modal.namePlaceholder'));
+      });
+
+    new Setting(contentEl)
+      .setName(t('settings.subagents.modal.description'))
+      .setDesc(t('settings.subagents.modal.descriptionDesc'))
+      .addText(text => {
+        descInput = text.inputEl;
+        text.setValue(this.existingAgent?.description || '')
+          .setPlaceholder(t('settings.subagents.modal.descriptionPlaceholder'));
+      });
+
+    const details = contentEl.createEl('details', { cls: 'claudian-sp-advanced-section' });
+    details.createEl('summary', {
+      text: t('settings.subagents.modal.advancedOptions'),
+      cls: 'claudian-sp-advanced-summary',
+    });
+    if ((this.existingAgent?.model && this.existingAgent.model !== 'inherit') ||
+        this.existingAgent?.tools?.length ||
+        this.existingAgent?.disallowedTools?.length ||
+        this.existingAgent?.skills?.length) {
+      details.open = true;
+    }
+
+    new Setting(details)
+      .setName(t('settings.subagents.modal.model'))
+      .setDesc(t('settings.subagents.modal.modelDesc'))
+      .addDropdown(dropdown => {
+        for (const opt of MODEL_OPTIONS) {
+          dropdown.addOption(opt.value, opt.label);
+        }
+        dropdown
+          .setValue(modelValue)
+          .onChange(value => { modelValue = value; });
+      });
+
+    new Setting(details)
+      .setName(t('settings.subagents.modal.tools'))
+      .setDesc(t('settings.subagents.modal.toolsDesc'))
+      .addText(text => {
+        toolsInput = text.inputEl;
+        text.setValue(this.existingAgent?.tools?.join(', ') || '');
+      });
+
+    new Setting(details)
+      .setName(t('settings.subagents.modal.disallowedTools'))
+      .setDesc(t('settings.subagents.modal.disallowedToolsDesc'))
+      .addText(text => {
+        disallowedToolsInput = text.inputEl;
+        text.setValue(this.existingAgent?.disallowedTools?.join(', ') || '');
+      });
+
+    new Setting(details)
+      .setName(t('settings.subagents.modal.skills'))
+      .setDesc(t('settings.subagents.modal.skillsDesc'))
+      .addText(text => {
+        skillsInput = text.inputEl;
+        text.setValue(this.existingAgent?.skills?.join(', ') || '');
+      });
+
+    new Setting(contentEl)
+      .setName(t('settings.subagents.modal.prompt'))
+      .setDesc(t('settings.subagents.modal.promptDesc'));
+
+    const contentArea = contentEl.createEl('textarea', {
+      cls: 'claudian-sp-content-area',
+      attr: {
+        rows: '10',
+        placeholder: t('settings.subagents.modal.promptPlaceholder'),
+      },
+    });
+    contentArea.value = this.existingAgent?.prompt || '';
+
+    const buttonContainer = contentEl.createDiv({ cls: 'claudian-sp-modal-buttons' });
+
+    const cancelBtn = buttonContainer.createEl('button', {
+      text: t('common.cancel'),
+      cls: 'claudian-cancel-btn',
+    });
+    cancelBtn.addEventListener('click', () => this.close());
+
+    const saveBtn = buttonContainer.createEl('button', {
+      text: t('common.save'),
+      cls: 'claudian-save-btn',
+    });
+    saveBtn.addEventListener('click', () => {
+      void (async (): Promise<void> => {
+      const name = nameInput.value.trim();
+      const nameError = validateAgentName(name);
+      if (nameError) {
+        new Notice(nameError);
+        return;
+      }
+
+      const description = descInput.value.trim();
+      if (!description) {
+        new Notice(t('settings.subagents.descriptionRequired'));
+        return;
+      }
+
+      const prompt = contentArea.value;
+      if (!prompt.trim()) {
+        new Notice(t('settings.subagents.promptRequired'));
+        return;
+      }
+
+      const allAgents = this.getAvailableAgents();
+      const duplicate = allAgents.find(
+        a => a.id.toLowerCase() === name.toLowerCase() &&
+             a.id !== this.existingAgent?.id
+      );
+      if (duplicate) {
+        new Notice(t('settings.subagents.duplicateName', { name }));
+        return;
+      }
+
+      const parseList = (input: HTMLInputElement): string[] | undefined => {
+        const val = input.value.trim();
+        if (!val) return undefined;
+        return val.split(',').map(s => s.trim()).filter(Boolean);
+      };
+
+      const agent: AgentDefinition = {
+        id: name,
+        name,
+        description,
+        prompt,
+        tools: parseList(toolsInput),
+        disallowedTools: parseList(disallowedToolsInput),
+        model: (modelValue) || 'inherit',
+        source: 'vault',
+        filePath: this.existingAgent?.filePath,
+        skills: parseList(skillsInput),
+        permissionMode: this.existingAgent?.permissionMode,
+        hooks: this.existingAgent?.hooks,
+        extraFrontmatter: this.existingAgent?.extraFrontmatter,
+      };
+
+      try {
+        await this.onSave(agent);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        new Notice(t('settings.subagents.saveFailed', { message }));
+        return;
+      }
+      this.close();
+      })();
+    });
+  }
+
+  onClose() {
+    this.contentEl.empty();
+  }
+}
+
+export interface AgentSettingsDeps {
+  app: App;
+  agentManager: Pick<AppAgentManager, 'getAvailableAgents' | 'loadAgents'>;
+  agentStorage: Pick<AppAgentStorage, 'load' | 'save' | 'delete'>;
+}
+
+export class AgentSettings {
+  private app: App;
+  private containerEl: HTMLElement;
+  private agentManager: Pick<AppAgentManager, 'getAvailableAgents' | 'loadAgents'>;
+  private agentStorage: Pick<AppAgentStorage, 'load' | 'save' | 'delete'>;
+
+  constructor(containerEl: HTMLElement, deps: AgentSettingsDeps) {
+    this.app = deps.app;
+    this.containerEl = containerEl;
+    this.agentManager = deps.agentManager;
+    this.agentStorage = deps.agentStorage;
+    this.render();
+  }
+
+  private render(): void {
+    this.containerEl.empty();
+
+    const headerEl = this.containerEl.createDiv({ cls: 'claudian-sp-header' });
+    headerEl.createSpan({ text: t('settings.subagents.name'), cls: 'claudian-sp-label' });
+
+    const actionsEl = headerEl.createDiv({ cls: 'claudian-sp-header-actions' });
+
+    const refreshBtn = actionsEl.createEl('button', {
+      cls: 'claudian-settings-action-btn',
+      attr: { 'aria-label': t('common.refresh') },
+    });
+    setIcon(refreshBtn, 'refresh-cw');
+    refreshBtn.addEventListener('click', () => { void this.refreshAgents(); });
+
+    const addBtn = actionsEl.createEl('button', {
+      cls: 'claudian-settings-action-btn',
+      attr: { 'aria-label': t('common.add') },
+    });
+    setIcon(addBtn, 'plus');
+    addBtn.addEventListener('click', () => { void this.openAgentModal(null); });
+
+    const allAgents = this.agentManager.getAvailableAgents();
+    const vaultAgents = allAgents.filter(a => a.source === 'vault');
+
+    if (vaultAgents.length === 0) {
+      const emptyEl = this.containerEl.createDiv({ cls: 'claudian-sp-empty-state' });
+      emptyEl.setText(t('settings.subagents.noAgents'));
+      return;
+    }
+
+    const listEl = this.containerEl.createDiv({ cls: 'claudian-sp-list' });
+
+    for (const agent of vaultAgents) {
+      this.renderAgentItem(listEl, agent);
+    }
+  }
+
+  private renderAgentItem(listEl: HTMLElement, agent: AgentDefinition): void {
+    const itemEl = listEl.createDiv({ cls: 'claudian-sp-item' });
+
+    const infoEl = itemEl.createDiv({ cls: 'claudian-sp-info' });
+
+    const headerRow = infoEl.createDiv({ cls: 'claudian-sp-item-header' });
+
+    const nameEl = headerRow.createSpan({ cls: 'claudian-sp-item-name' });
+    nameEl.setText(agent.name);
+
+    if (agent.description) {
+      const descEl = infoEl.createDiv({ cls: 'claudian-sp-item-desc' });
+      descEl.setText(agent.description);
+    }
+
+    const actionsEl = itemEl.createDiv({ cls: 'claudian-sp-item-actions' });
+
+    const editBtn = actionsEl.createEl('button', {
+      cls: 'claudian-settings-action-btn',
+      attr: { 'aria-label': t('common.edit') },
+    });
+    setIcon(editBtn, 'pencil');
+    editBtn.addEventListener('click', () => { void this.openAgentModal(agent); });
+
+    const deleteBtn = actionsEl.createEl('button', {
+      cls: 'claudian-settings-action-btn claudian-settings-delete-btn',
+      attr: { 'aria-label': t('common.delete') },
+    });
+    setIcon(deleteBtn, 'trash-2');
+    deleteBtn.addEventListener('click', () => {
+      void (async (): Promise<void> => {
+      const confirmed = await confirmDelete(
+        this.app,
+        t('settings.subagents.deleteConfirm', { name: agent.name })
+      );
+      if (!confirmed) return;
+      try {
+        await this.deleteAgent(agent);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        new Notice(t('settings.subagents.deleteFailed', { message }));
+      }
+      })();
+    });
+  }
+
+  private async refreshAgents(): Promise<void> {
+    try {
+      await this.agentManager.loadAgents();
+      this.render();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Unknown error';
+      new Notice(t('settings.subagents.refreshFailed', { message }));
+    }
+  }
+
+  private async openAgentModal(existingAgent: AgentDefinition | null): Promise<void> {
+    let fresh: AgentDefinition | null;
+    if (existingAgent) {
+      try {
+        fresh = await this.agentStorage.load(existingAgent) ?? existingAgent;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        new Notice(`Failed to load subagent "${existingAgent.name}": ${message}`);
+        return;
+      }
+    } else {
+      fresh = null;
+    }
+
+    new AgentModal(
+      this.app,
+      fresh,
+      () => this.agentManager.getAvailableAgents(),
+      (agent) => this.saveAgent(agent, fresh)
+    ).open();
+  }
+
+  private async saveAgent(agent: AgentDefinition, existing: AgentDefinition | null): Promise<void> {
+    if (existing && existing.name !== agent.name) {
+      // Rename: save to new name-based path, then delete old file
+      await this.agentStorage.save({ ...agent, filePath: undefined });
+      try {
+        await this.agentStorage.delete(existing);
+      } catch {
+        new Notice(t('settings.subagents.renameCleanupFailed', { name: existing.name }));
+      }
+    } else {
+      await this.agentStorage.save(agent);
+    }
+
+    try {
+      await this.agentManager.loadAgents();
+    } catch {
+      // Non-critical: agent list will refresh on next settings open
+    }
+    this.render();
+    new Notice(
+      existing
+        ? t('settings.subagents.updated', { name: agent.name })
+        : t('settings.subagents.created', { name: agent.name })
+    );
+  }
+
+  private async deleteAgent(agent: AgentDefinition): Promise<void> {
+    await this.agentStorage.delete(agent);
+
+    try {
+      await this.agentManager.loadAgents();
+    } catch {
+      // Non-critical: agent list will refresh on next settings open
+    }
+    this.render();
+    new Notice(t('settings.subagents.deleted', { name: agent.name }));
+  }
+
+}