@mseep/claudian 2.0.25

package/src/providers/opencode/auxiliary/OpencodeTitleGenerationService.ts

@@ -0,0 +1,27 @@
+import { QueryBackedTitleGenerationService } from '../../../core/auxiliary/QueryBackedTitleGenerationService';
+import type ClaudianPlugin from '../../../main';
+import { decodeOpencodeModelId } from '../models';
+import { OpencodeAuxQueryRunner } from '../runtime/OpencodeAuxQueryRunner';
+import { opencodeChatUIConfig } from '../ui/OpencodeChatUIConfig';
+
+export class OpencodeTitleGenerationService extends QueryBackedTitleGenerationService {
+  constructor(plugin: ClaudianPlugin) {
+    super({
+      createRunner: () => new OpencodeAuxQueryRunner(plugin, {
+        agentProfile: 'passive',
+        artifactPurpose: 'title-gen',
+      }),
+      resolveModel: () => {
+        const settings = plugin.settings as unknown as Record<string, unknown>;
+        const titleModel = typeof settings.titleGenerationModel === 'string'
+          ? settings.titleGenerationModel
+          : '';
+        if (!opencodeChatUIConfig.ownsModel(titleModel, settings)) {
+          return undefined;
+        }
+
+        return decodeOpencodeModelId(titleModel) ?? undefined;
+      },
+    });
+  }
+}

package/src/providers/opencode/capabilities.ts

@@ -0,0 +1,16 @@
+import type { ProviderCapabilities } from '../../core/providers/types';
+
+export const OPENCODE_PROVIDER_CAPABILITIES: Readonly<ProviderCapabilities> = Object.freeze({
+  providerId: 'opencode',
+  supportsPersistentRuntime: true,
+  supportsNativeHistory: true,
+  supportsPlanMode: true,
+  supportsRewind: false,
+  supportsFork: false,
+  supportsProviderCommands: true,
+  supportsImageAttachments: true,
+  supportsInstructionMode: true,
+  supportsMcpTools: false,
+  supportsTurnSteer: false,
+  reasoningControl: 'effort',
+});

package/src/providers/opencode/commands/OpencodeCommandCatalog.ts

@@ -0,0 +1,92 @@
+import type {
+  ProviderCommandCatalog,
+  ProviderCommandDropdownConfig,
+} from '../../../core/providers/commands/ProviderCommandCatalog';
+import type { ProviderCommandEntry } from '../../../core/providers/commands/ProviderCommandEntry';
+import type { SlashCommand } from '../../../core/types';
+
+function slashCommandToEntry(command: SlashCommand): ProviderCommandEntry {
+  return {
+    id: command.id,
+    providerId: 'opencode',
+    kind: 'command',
+    name: command.name,
+    description: command.description,
+    content: command.content,
+    argumentHint: command.argumentHint,
+    allowedTools: command.allowedTools,
+    model: command.model,
+    disableModelInvocation: command.disableModelInvocation,
+    userInvocable: command.userInvocable,
+    context: command.context,
+    agent: command.agent,
+    hooks: command.hooks,
+    scope: 'runtime',
+    source: command.source ?? 'sdk',
+    isEditable: false,
+    isDeletable: false,
+    displayPrefix: '/',
+    insertPrefix: '/',
+  };
+}
+
+function dedupeRuntimeCommands(commands: SlashCommand[]): SlashCommand[] {
+  const deduped: SlashCommand[] = [];
+  const seen = new Set<string>();
+
+  for (const command of commands) {
+    const normalizedName = command.name.trim().replace(/^\/+/, '');
+    if (!normalizedName) {
+      continue;
+    }
+
+    const key = normalizedName.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    deduped.push({
+      ...command,
+      name: normalizedName,
+    });
+  }
+
+  return deduped;
+}
+
+export class OpencodeCommandCatalog implements ProviderCommandCatalog {
+  private runtimeCommands: SlashCommand[] = [];
+
+  setRuntimeCommands(commands: SlashCommand[]): void {
+    this.runtimeCommands = dedupeRuntimeCommands(commands);
+  }
+
+  async listDropdownEntries(_context: { includeBuiltIns: boolean }): Promise<ProviderCommandEntry[]> {
+    return this.runtimeCommands.map(slashCommandToEntry);
+  }
+
+  async listVaultEntries(): Promise<ProviderCommandEntry[]> {
+    return [];
+  }
+
+  async saveVaultEntry(_entry: ProviderCommandEntry): Promise<void> {
+    throw new Error('OpenCode runtime commands are not editable from Claudian.');
+  }
+
+  async deleteVaultEntry(_entry: ProviderCommandEntry): Promise<void> {
+    throw new Error('OpenCode runtime commands are not deletable from Claudian.');
+  }
+
+  getDropdownConfig(): ProviderCommandDropdownConfig {
+    return {
+      providerId: 'opencode',
+      triggerChars: ['/'],
+      builtInPrefix: '/',
+      skillPrefix: '/',
+      commandPrefix: '/',
+    };
+  }
+
+  async refresh(): Promise<void> {}
+}

package/src/providers/opencode/discoveryState.ts

@@ -0,0 +1,135 @@
+import { sameDiscoveredModels, sameModes, sameThinkingOptionsByModel } from './internal/compareCollections';
+import {
+  normalizeOpencodeDiscoveredModels,
+  normalizeOpencodeThinkingOptionsByModel,
+  type OpencodeDiscoveredModel,
+  type OpencodeThinkingOptionsByModel,
+} from './models';
+import {
+  normalizeOpencodeAvailableModes,
+  type OpencodeMode,
+} from './modes';
+
+const OPENCODE_DISCOVERY_STATE = Symbol('opencodeDiscoveryState');
+
+interface OpencodeDiscoveryState {
+  availableModes: OpencodeMode[];
+  discoveredModels: OpencodeDiscoveredModel[];
+  thinkingOptionsByModel: OpencodeThinkingOptionsByModel;
+}
+
+type SettingsBag = Record<string | symbol, unknown>;
+
+function ensureDiscoveryState(settings: Record<string, unknown>): OpencodeDiscoveryState {
+  const bag = settings as SettingsBag;
+  const existing = bag[OPENCODE_DISCOVERY_STATE];
+  if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+    const state = existing as Partial<OpencodeDiscoveryState>;
+    state.availableModes ??= [];
+    state.discoveredModels ??= [];
+    state.thinkingOptionsByModel ??= {};
+    return state as OpencodeDiscoveryState;
+  }
+
+  const next: OpencodeDiscoveryState = {
+    availableModes: [],
+    discoveredModels: [],
+    thinkingOptionsByModel: {},
+  };
+  bag[OPENCODE_DISCOVERY_STATE] = next;
+  return next;
+}
+
+function cloneModes(modes: OpencodeMode[]): OpencodeMode[] {
+  return modes.map((mode) => ({ ...mode }));
+}
+
+function cloneDiscoveredModels(models: OpencodeDiscoveredModel[]): OpencodeDiscoveredModel[] {
+  return models.map((model) => ({ ...model }));
+}
+
+function cloneThinkingOptionsByModel(
+  optionsByModel: OpencodeThinkingOptionsByModel,
+): OpencodeThinkingOptionsByModel {
+  return Object.fromEntries(
+    Object.entries(optionsByModel).map(([rawId, options]) => [
+      rawId,
+      options.map((option) => ({ ...option })),
+    ]),
+  );
+}
+
+export function getOpencodeDiscoveryState(settings: Record<string, unknown>): OpencodeDiscoveryState {
+  const state = ensureDiscoveryState(settings);
+  return {
+    availableModes: cloneModes(state.availableModes),
+    discoveredModels: cloneDiscoveredModels(state.discoveredModels),
+    thinkingOptionsByModel: cloneThinkingOptionsByModel(state.thinkingOptionsByModel),
+  };
+}
+
+export function updateOpencodeDiscoveryState(
+  settings: Record<string, unknown>,
+  updates: Partial<OpencodeDiscoveryState>,
+): boolean {
+  const state = ensureDiscoveryState(settings);
+  const nextAvailableModes = 'availableModes' in updates
+    ? normalizeOpencodeAvailableModes(updates.availableModes)
+    : state.availableModes;
+  const nextDiscoveredModels = 'discoveredModels' in updates
+    ? normalizeOpencodeDiscoveredModels(updates.discoveredModels)
+    : state.discoveredModels;
+  const nextThinkingOptionsByModel = 'thinkingOptionsByModel' in updates
+    ? normalizeOpencodeThinkingOptionsByModel(updates.thinkingOptionsByModel, nextDiscoveredModels)
+    : state.thinkingOptionsByModel;
+  const changed = !sameModes(state.availableModes, nextAvailableModes)
+    || !sameDiscoveredModels(state.discoveredModels, nextDiscoveredModels)
+    || !sameThinkingOptionsByModel(state.thinkingOptionsByModel, nextThinkingOptionsByModel);
+
+  if (!changed) {
+    return false;
+  }
+
+  state.availableModes = cloneModes(nextAvailableModes);
+  state.discoveredModels = cloneDiscoveredModels(nextDiscoveredModels);
+  state.thinkingOptionsByModel = cloneThinkingOptionsByModel(nextThinkingOptionsByModel);
+  return true;
+}
+
+export function clearOpencodeDiscoveryState(settings: Record<string, unknown>): boolean {
+  const state = ensureDiscoveryState(settings);
+  if (
+    state.availableModes.length === 0
+    && state.discoveredModels.length === 0
+    && Object.keys(state.thinkingOptionsByModel).length === 0
+  ) {
+    return false;
+  }
+
+  state.availableModes = [];
+  state.discoveredModels = [];
+  state.thinkingOptionsByModel = {};
+  return true;
+}
+
+export function seedOpencodeDiscoveryStateFromLegacyConfig(
+  settings: Record<string, unknown>,
+  legacyConfig: Record<string, unknown>,
+): boolean {
+  const state = ensureDiscoveryState(settings);
+  const nextAvailableModes = state.availableModes.length > 0
+    ? state.availableModes
+    : normalizeOpencodeAvailableModes(legacyConfig.availableModes);
+  const nextDiscoveredModels = state.discoveredModels.length > 0
+    ? state.discoveredModels
+    : normalizeOpencodeDiscoveredModels(legacyConfig.discoveredModels);
+  const nextThinkingOptionsByModel = Object.keys(state.thinkingOptionsByModel).length > 0
+    ? state.thinkingOptionsByModel
+    : normalizeOpencodeThinkingOptionsByModel(legacyConfig.thinkingOptionsByModel, nextDiscoveredModels);
+
+  return updateOpencodeDiscoveryState(settings, {
+    availableModes: nextAvailableModes,
+    discoveredModels: nextDiscoveredModels,
+    thinkingOptionsByModel: nextThinkingOptionsByModel,
+  });
+}

package/src/providers/opencode/env/OpencodeSettingsReconciler.ts

@@ -0,0 +1,178 @@
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import type { ProviderSettingsReconciler } from '../../../core/providers/types';
+import type { Conversation } from '../../../core/types';
+import { parseEnvironmentVariables } from '../../../utils/env';
+import { clearOpencodeDiscoveryState } from '../discoveryState';
+import { sameStringList, sameStringMap } from '../internal/compareCollections';
+import { ensureProviderProjectionMap } from '../internal/providerProjection';
+import {
+  decodeOpencodeModelId,
+  encodeOpencodeModelId,
+  extractOpencodeModelVariantValue,
+  isOpencodeModelSelectionId,
+  OPENCODE_DEFAULT_THINKING_LEVEL,
+  resolveOpencodeBaseModelRawId,
+} from '../models';
+import {
+  getOpencodeProviderSettings,
+  hasLegacyOpencodeDiscoveryFields,
+  normalizeOpencodePreferredThinkingByModel,
+  normalizeOpencodeVisibleModels,
+  updateOpencodeProviderSettings,
+} from '../settings';
+import { getOpencodeState } from '../types';
+
+interface NormalizedSelection {
+  baseModelId: string | null;
+  variant: string | null;
+}
+
+const OPENCODE_ENV_HASH_KEYS = [
+  'OPENCODE_CONFIG',
+  'OPENCODE_DB',
+  'OPENCODE_DISABLE_PROJECT_CONFIG',
+  'XDG_DATA_HOME',
+] as const;
+
+function computeOpencodeEnvHash(envText: string): string {
+  const envVars = parseEnvironmentVariables(envText || '');
+  return OPENCODE_ENV_HASH_KEYS
+    .filter((key) => envVars[key])
+    .map((key) => `${key}=${envVars[key]}`)
+    .sort()
+    .join('|');
+}
+
+export const opencodeSettingsReconciler: ProviderSettingsReconciler = {
+  handleEnvironmentChange(settings: Record<string, unknown>): boolean {
+    return clearOpencodeDiscoveryState(settings);
+  },
+
+  reconcileModelWithEnvironment(
+    settings: Record<string, unknown>,
+    conversations: Conversation[],
+  ): { changed: boolean; invalidatedConversations: Conversation[] } {
+    const envText = getRuntimeEnvironmentText(settings, 'opencode');
+    const currentHash = computeOpencodeEnvHash(envText);
+    const savedHash = getOpencodeProviderSettings(settings).environmentHash;
+
+    if (currentHash === savedHash) {
+      return { changed: false, invalidatedConversations: [] };
+    }
+
+    const invalidatedConversations: Conversation[] = [];
+    for (const conversation of conversations) {
+      if (conversation.providerId !== 'opencode') {
+        continue;
+      }
+
+      const state = getOpencodeState(conversation.providerState);
+      if (!conversation.sessionId && !state.databasePath) {
+        continue;
+      }
+
+      conversation.sessionId = null;
+      conversation.providerState = undefined;
+      invalidatedConversations.push(conversation);
+    }
+
+    updateOpencodeProviderSettings(settings, { environmentHash: currentHash });
+    return { changed: true, invalidatedConversations };
+  },
+
+  normalizeModelVariantSettings(settings: Record<string, unknown>): boolean {
+    const hadLegacyDiscoveryFields = hasLegacyOpencodeDiscoveryFields(settings);
+    if (hadLegacyDiscoveryFields) {
+      updateOpencodeProviderSettings(settings, {});
+    }
+
+    const opencodeSettings = getOpencodeProviderSettings(settings);
+    let changed = hadLegacyDiscoveryFields;
+
+    const normalizeSelection = (value: unknown): NormalizedSelection => {
+      if (typeof value !== 'string' || !isOpencodeModelSelectionId(value)) {
+        return { baseModelId: null, variant: null };
+      }
+
+      const rawModelId = decodeOpencodeModelId(value);
+      if (!rawModelId) {
+        return { baseModelId: value, variant: null };
+      }
+
+      const baseRawId = resolveOpencodeBaseModelRawId(rawModelId, opencodeSettings.discoveredModels);
+      return {
+        baseModelId: encodeOpencodeModelId(baseRawId),
+        variant: extractOpencodeModelVariantValue(rawModelId, opencodeSettings.discoveredModels),
+      };
+    };
+
+    const modelSelection = normalizeSelection(settings.model);
+    if (typeof settings.model === 'string' && modelSelection.baseModelId && settings.model !== modelSelection.baseModelId) {
+      settings.model = modelSelection.baseModelId;
+      changed = true;
+    }
+    if (
+      modelSelection.variant
+      && (typeof settings.effortLevel !== 'string' || settings.effortLevel.trim().length === 0)
+    ) {
+      settings.effortLevel = modelSelection.variant;
+      changed = true;
+    }
+
+    const titleModelSelection = normalizeSelection(settings.titleGenerationModel);
+    if (
+      typeof settings.titleGenerationModel === 'string'
+      && titleModelSelection.baseModelId
+      && settings.titleGenerationModel !== titleModelSelection.baseModelId
+    ) {
+      settings.titleGenerationModel = titleModelSelection.baseModelId;
+      changed = true;
+    }
+
+    const savedProviderModelRaw = settings.savedProviderModel;
+    if (savedProviderModelRaw && typeof savedProviderModelRaw === 'object' && !Array.isArray(savedProviderModelRaw)) {
+      const savedProviderModel = savedProviderModelRaw as Record<string, unknown>;
+      const savedSelection = normalizeSelection(savedProviderModel.opencode);
+      if (
+        typeof savedProviderModel.opencode === 'string'
+        && savedSelection.baseModelId
+        && savedProviderModel.opencode !== savedSelection.baseModelId
+      ) {
+        savedProviderModel.opencode = savedSelection.baseModelId;
+        changed = true;
+      }
+      if (savedSelection.variant) {
+        const savedEffort = ensureProviderProjectionMap(settings, 'savedProviderEffort');
+        if (typeof savedEffort.opencode !== 'string') {
+          savedEffort.opencode = savedSelection.variant;
+          changed = true;
+        }
+      }
+    }
+
+    const normalizedVisibleModels = normalizeOpencodeVisibleModels(
+      opencodeSettings.visibleModels,
+      opencodeSettings.discoveredModels,
+    );
+    const normalizedPreferredThinking = normalizeOpencodePreferredThinkingByModel(
+      opencodeSettings.preferredThinkingByModel,
+      opencodeSettings.discoveredModels,
+    );
+    const shouldUpdateProviderSettings = !sameStringList(normalizedVisibleModels, opencodeSettings.visibleModels)
+      || !sameStringMap(normalizedPreferredThinking, opencodeSettings.preferredThinkingByModel);
+    if (shouldUpdateProviderSettings) {
+      updateOpencodeProviderSettings(settings, {
+        preferredThinkingByModel: normalizedPreferredThinking,
+        visibleModels: normalizedVisibleModels,
+      });
+      changed = true;
+    }
+
+    if (typeof settings.effortLevel === 'string' && !settings.effortLevel.trim()) {
+      settings.effortLevel = OPENCODE_DEFAULT_THINKING_LEVEL;
+      changed = true;
+    }
+
+    return changed;
+  },
+};

package/src/providers/opencode/history/OpencodeConversationHistoryService.ts

@@ -0,0 +1,84 @@
+import type { ProviderConversationHistoryService } from '../../../core/providers/types';
+import type { Conversation } from '../../../core/types';
+import { getOpencodeState, type OpencodeProviderState } from '../types';
+import {
+  isOpencodeSessionHydrationDiagnosticMessage,
+  loadOpencodeSessionMessages,
+} from './OpencodeHistoryStore';
+
+export class OpencodeConversationHistoryService implements ProviderConversationHistoryService {
+  private hydratedKeys = new Map<string, string>();
+
+  async hydrateConversationHistory(
+    conversation: Conversation,
+    _vaultPath: string | null,
+  ): Promise<void> {
+    const sessionId = conversation.sessionId;
+    if (!sessionId) {
+      this.hydratedKeys.delete(conversation.id);
+      return;
+    }
+
+    const state = getOpencodeState(conversation.providerState);
+    const hydrationKey = `${sessionId}::${state.databasePath ?? ''}`;
+    if (
+      conversation.messages.length > 0
+      && this.hydratedKeys.get(conversation.id) === hydrationKey
+    ) {
+      return;
+    }
+
+    const messages = await loadOpencodeSessionMessages(sessionId, state);
+    if (messages.length === 0) {
+      this.hydratedKeys.delete(conversation.id);
+      return;
+    }
+
+    conversation.messages = messages;
+    if (
+      messages.length === 1
+      && isOpencodeSessionHydrationDiagnosticMessage(messages[0])
+    ) {
+      this.hydratedKeys.delete(conversation.id);
+      return;
+    }
+
+    this.hydratedKeys.set(conversation.id, hydrationKey);
+  }
+
+  async deleteConversationSession(
+    _conversation: Conversation,
+    _vaultPath: string | null,
+  ): Promise<void> {
+    // Never mutate OpenCode native history.
+  }
+
+  resolveSessionIdForConversation(conversation: Conversation | null): string | null {
+    return conversation?.sessionId ?? null;
+  }
+
+  isPendingForkConversation(_conversation: Conversation): boolean {
+    return false;
+  }
+
+  buildForkProviderState(
+    _sourceSessionId: string,
+    _resumeAt: string,
+    _sourceProviderState?: Record<string, unknown>,
+  ): Record<string, unknown> {
+    return {};
+  }
+
+  buildPersistedProviderState(
+    conversation: Conversation,
+  ): Record<string, unknown> | undefined {
+    const state = getOpencodeState(conversation.providerState);
+    const providerState: OpencodeProviderState = {
+      ...(state.databasePath ? { databasePath: state.databasePath } : {}),
+    };
+
+    return Object.keys(providerState).length > 0
+      ? providerState as Record<string, unknown>
+      : undefined;
+  }
+}