@mseep/claudian 2.0.25

package/src/providers/opencode/models.ts

@@ -0,0 +1,378 @@
+export interface OpencodeDiscoveredModel {
+  description?: string;
+  label: string;
+  rawId: string;
+}
+
+export interface OpencodeModelVariant {
+  description?: string;
+  label: string;
+  value: string;
+}
+
+export type OpencodeThinkingOptionsByModel = Record<string, OpencodeModelVariant[]>;
+
+export interface OpencodeBaseModel {
+  description?: string;
+  label: string;
+  rawId: string;
+  variants: OpencodeModelVariant[];
+}
+
+export interface OpencodeDiscoveredModelGroup {
+  models: OpencodeDiscoveredModel[];
+  providerKey: string;
+  providerLabel: string;
+}
+
+export const OPENCODE_SYNTHETIC_MODEL_ID = 'opencode';
+export const OPENCODE_DEFAULT_THINKING_LEVEL = 'default';
+
+const OPENCODE_MODEL_PREFIX = 'opencode:';
+const OPENCODE_VARIANT_ASCENDING_ORDER = [
+  'none',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'max',
+  'xhigh',
+] as const;
+const OPENCODE_VARIANT_ASCENDING_RANK = new Map<string, number>(
+  OPENCODE_VARIANT_ASCENDING_ORDER.map((value, index) => [value, index] as const),
+);
+
+export function isOpencodeModelSelectionId(model: string): boolean {
+  return model === OPENCODE_SYNTHETIC_MODEL_ID || model.startsWith(OPENCODE_MODEL_PREFIX);
+}
+
+export function encodeOpencodeModelId(rawModelId: string): string {
+  const normalized = rawModelId.trim();
+  return normalized ? `${OPENCODE_MODEL_PREFIX}${normalized}` : OPENCODE_SYNTHETIC_MODEL_ID;
+}
+
+export function decodeOpencodeModelId(model: string): string | null {
+  if (!model.startsWith(OPENCODE_MODEL_PREFIX)) {
+    return null;
+  }
+
+  const rawModelId = model.slice(OPENCODE_MODEL_PREFIX.length).trim();
+  return rawModelId || null;
+}
+
+export function normalizeOpencodeDiscoveredModels(value: unknown): OpencodeDiscoveredModel[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const normalized: OpencodeDiscoveredModel[] = [];
+  const seen = new Set<string>();
+  for (const entry of value as unknown[]) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry as Record<string, unknown>;
+
+    const rawId = typeof record.rawId === 'string' ? record.rawId.trim() : '';
+    const label = typeof record.label === 'string' ? record.label.trim() : rawId;
+    const description = typeof record.description === 'string'
+      ? record.description.trim()
+      : '';
+
+    if (!rawId || seen.has(rawId)) {
+      continue;
+    }
+
+    seen.add(rawId);
+    normalized.push({
+      ...(description ? { description } : {}),
+      label: label || rawId,
+      rawId,
+    });
+  }
+
+  return normalized;
+}
+
+export function normalizeOpencodeModelVariants(value: unknown): OpencodeModelVariant[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const variants: OpencodeModelVariant[] = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      continue;
+    }
+
+    const record = entry as Record<string, unknown>;
+    const rawValue = typeof record.value === 'string' ? record.value.trim() : '';
+    if (!rawValue) {
+      continue;
+    }
+
+    let rawLabel = '';
+    if (typeof record.label === 'string') {
+      rawLabel = record.label.trim();
+    } else if (typeof record.name === 'string') {
+      rawLabel = record.name.trim();
+    }
+    const description = typeof record.description === 'string'
+      ? record.description.trim()
+      : '';
+
+    variants.push({
+      ...(description ? { description } : {}),
+      label: rawLabel || formatOpencodeThinkingLevelLabel(rawValue),
+      value: rawValue,
+    });
+  }
+
+  return dedupeOpencodeVariants(variants);
+}
+
+export function normalizeOpencodeThinkingOptionsByModel(
+  value: unknown,
+  discoveredModels: OpencodeDiscoveredModel[] = [],
+): OpencodeThinkingOptionsByModel {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const normalized: OpencodeThinkingOptionsByModel = {};
+  for (const [rawId, variants] of Object.entries(value as Record<string, unknown>)) {
+    const normalizedRawId = resolveOpencodeBaseModelRawId(rawId.trim(), discoveredModels);
+    const normalizedVariants = normalizeOpencodeModelVariants(variants);
+    if (!normalizedRawId || normalizedVariants.length === 0) {
+      continue;
+    }
+
+    normalized[normalizedRawId] = normalizedVariants;
+  }
+
+  return normalized;
+}
+
+export function resolveOpencodeBaseModelRawId(
+  rawId: string,
+  discoveredModels: OpencodeDiscoveredModel[] | Set<string>,
+): string {
+  const normalizedRawId = rawId.trim();
+  if (!normalizedRawId) {
+    return '';
+  }
+
+  const discoveredRawIds = discoveredModels instanceof Set
+    ? discoveredModels
+    : new Set(discoveredModels.map((model) => model.rawId));
+  const slashIndex = normalizedRawId.lastIndexOf('/');
+  if (slashIndex <= 0) {
+    return normalizedRawId;
+  }
+
+  const candidate = normalizedRawId.slice(0, slashIndex);
+  if (discoveredRawIds.has(candidate)) {
+    return candidate;
+  }
+
+  const variant = normalizedRawId.slice(slashIndex + 1).trim().toLowerCase();
+  return OPENCODE_VARIANT_ASCENDING_RANK.has(variant)
+    ? candidate
+    : normalizedRawId;
+}
+
+export function extractOpencodeModelVariantValue(
+  rawId: string,
+  discoveredModels: OpencodeDiscoveredModel[] | Set<string>,
+): string | null {
+  const normalizedRawId = rawId.trim();
+  if (!normalizedRawId) {
+    return null;
+  }
+
+  const baseRawId = resolveOpencodeBaseModelRawId(normalizedRawId, discoveredModels);
+  if (baseRawId === normalizedRawId || baseRawId.length >= normalizedRawId.length) {
+    return null;
+  }
+
+  const variant = normalizedRawId.slice(baseRawId.length + 1).trim();
+  return variant || null;
+}
+
+export function combineOpencodeRawModelSelection(
+  baseRawId: string | null | undefined,
+  thinkingLevel: string | null | undefined,
+  discoveredModels: OpencodeDiscoveredModel[],
+): string | null {
+  const normalizedBaseRawId = baseRawId?.trim();
+  if (!normalizedBaseRawId) {
+    return null;
+  }
+
+  const variant = thinkingLevel?.trim();
+  if (!variant || variant === OPENCODE_DEFAULT_THINKING_LEVEL) {
+    return normalizedBaseRawId;
+  }
+
+  const supportedVariants = new Set(
+    getOpencodeModelVariants(normalizedBaseRawId, discoveredModels).map((entry) => entry.value),
+  );
+  return supportedVariants.has(variant)
+    ? `${normalizedBaseRawId}/${variant}`
+    : normalizedBaseRawId;
+}
+
+export function splitOpencodeModelLabel(label: string): {
+  modelLabel: string;
+  providerLabel: string;
+} {
+  const trimmed = label.trim();
+  const slashIndex = trimmed.indexOf('/');
+  if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
+    return {
+      modelLabel: trimmed,
+      providerLabel: 'Other',
+    };
+  }
+
+  return {
+    modelLabel: trimmed.slice(slashIndex + 1).trim(),
+    providerLabel: trimmed.slice(0, slashIndex).trim(),
+  };
+}
+
+export function buildOpencodeBaseModels(
+  models: OpencodeDiscoveredModel[],
+): OpencodeBaseModel[] {
+  const discoveredRawIds = new Set(models.map((model) => model.rawId));
+  const discoveredByRawId = new Map(models.map((model) => [model.rawId, model] as const));
+  const grouped = new Map<string, OpencodeDiscoveredModel[]>();
+
+  for (const model of models) {
+    const baseRawId = resolveOpencodeBaseModelRawId(model.rawId, discoveredRawIds);
+    const existing = grouped.get(baseRawId);
+    if (existing) {
+      existing.push(model);
+    } else {
+      grouped.set(baseRawId, [model]);
+    }
+  }
+
+  return Array.from(grouped.entries())
+    .map(([baseRawId, entries]) => {
+      const baseModel = discoveredByRawId.get(baseRawId) ?? entries[0];
+      const variants = entries.flatMap((entry) => {
+        if (entry.rawId === baseRawId) {
+          return [];
+        }
+
+        const variant = extractOpencodeModelVariantValue(entry.rawId, discoveredRawIds);
+        if (!variant) {
+          return [];
+        }
+
+        return [{
+          ...(entry.description ? { description: entry.description } : {}),
+          label: formatOpencodeThinkingLevelLabel(variant),
+          value: variant,
+        }];
+      });
+
+      return {
+        ...(baseModel?.description ? { description: baseModel.description } : {}),
+        label: baseModel?.label ?? baseRawId,
+        rawId: baseRawId,
+        variants: dedupeOpencodeVariants(variants),
+      };
+    })
+    .sort((left, right) => left.label.localeCompare(right.label));
+}
+
+export function getOpencodeModelVariants(
+  rawId: string,
+  models: OpencodeDiscoveredModel[],
+): OpencodeModelVariant[] {
+  const baseRawId = resolveOpencodeBaseModelRawId(rawId, models);
+  return buildOpencodeBaseModels(models)
+    .find((model) => model.rawId === baseRawId)?.variants ?? [];
+}
+
+function formatOpencodeThinkingLevelLabel(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return '';
+  }
+
+  if (trimmed.toLowerCase() === 'xhigh') {
+    return 'XHigh';
+  }
+
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+
+export function groupOpencodeDiscoveredModels(
+  models: OpencodeDiscoveredModel[],
+): OpencodeDiscoveredModelGroup[] {
+  const groups = new Map<string, OpencodeDiscoveredModelGroup>();
+  for (const model of buildOpencodeBaseModels(models)) {
+    const { providerLabel } = splitOpencodeModelLabel(model.label || model.rawId);
+    const providerKey = providerLabel.toLowerCase();
+    const existing = groups.get(providerKey);
+    if (existing) {
+      existing.models.push({
+        ...(model.description ? { description: model.description } : {}),
+        label: model.label,
+        rawId: model.rawId,
+      });
+      continue;
+    }
+
+    groups.set(providerKey, {
+      models: [{
+        ...(model.description ? { description: model.description } : {}),
+        label: model.label,
+        rawId: model.rawId,
+      }],
+      providerKey,
+      providerLabel,
+    });
+  }
+
+  return Array.from(groups.values())
+    .map((group) => ({
+      ...group,
+      models: [...group.models].sort((left, right) => left.label.localeCompare(right.label)),
+    }))
+    .sort((left, right) => left.providerLabel.localeCompare(right.providerLabel));
+}
+
+function dedupeOpencodeVariants(variants: OpencodeModelVariant[]): OpencodeModelVariant[] {
+  const unique = new Map<string, OpencodeModelVariant>();
+  for (const variant of variants) {
+    if (!unique.has(variant.value)) {
+      unique.set(variant.value, variant);
+    }
+  }
+
+  return Array.from(unique.values())
+    .sort((left, right) => compareOpencodeVariantValues(left.value, right.value));
+}
+
+function compareOpencodeVariantValues(left: string, right: string): number {
+  const leftRank = OPENCODE_VARIANT_ASCENDING_RANK.get(left.toLowerCase());
+  const rightRank = OPENCODE_VARIANT_ASCENDING_RANK.get(right.toLowerCase());
+
+  if (leftRank !== undefined && rightRank !== undefined) {
+    return leftRank - rightRank;
+  }
+
+  if (leftRank !== undefined) {
+    return -1;
+  }
+
+  if (rightRank !== undefined) {
+    return 1;
+  }
+
+  return left.localeCompare(right);
+}

package/src/providers/opencode/modes.ts

@@ -0,0 +1,150 @@
+export interface OpencodeMode {
+  description?: string;
+  id: string;
+  name: string;
+}
+
+export const OPENCODE_BUILD_MODE_ID = 'build';
+export const OPENCODE_YOLO_MODE_ID = 'claudian-yolo';
+export const OPENCODE_SAFE_MODE_ID = 'claudian-safe';
+export const OPENCODE_PLAN_MODE_ID = 'plan';
+
+export const OPENCODE_FALLBACK_MODES: ReadonlyArray<OpencodeMode> = Object.freeze([
+  {
+    description: 'The default agent. Executes tools based on configured permissions.',
+    id: OPENCODE_YOLO_MODE_ID,
+    name: 'yolo',
+  },
+  {
+    description: 'Safe mode. Asks before shell commands and file edits.',
+    id: OPENCODE_SAFE_MODE_ID,
+    name: 'safe',
+  },
+  {
+    description: 'Plan mode. Disallows all edit tools.',
+    id: OPENCODE_PLAN_MODE_ID,
+    name: OPENCODE_PLAN_MODE_ID,
+  },
+]);
+
+const OPENCODE_MANAGED_MODE_IDS = new Set([
+  OPENCODE_BUILD_MODE_ID,
+  ...OPENCODE_FALLBACK_MODES.map((mode) => mode.id),
+]);
+
+export function normalizeOpencodeAvailableModes(value: unknown): OpencodeMode[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const normalized: OpencodeMode[] = [];
+  const seen = new Set<string>();
+  for (const entry of value as unknown[]) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry as Record<string, unknown>;
+
+    const id = typeof record.id === 'string' ? record.id.trim() : '';
+    const name = typeof record.name === 'string' ? record.name.trim() : id;
+    const description = typeof record.description === 'string'
+      ? record.description.trim()
+      : '';
+
+    if (!id || seen.has(id)) {
+      continue;
+    }
+
+    seen.add(id);
+    normalized.push({
+      ...(description ? { description } : {}),
+      id,
+      name: name || id,
+    });
+  }
+
+  return normalized;
+}
+
+export function getEffectiveOpencodeModes(modes: OpencodeMode[]): OpencodeMode[] {
+  return modes.length > 0 ? modes : [...OPENCODE_FALLBACK_MODES];
+}
+
+export function isManagedOpencodeModeId(value: string): boolean {
+  return OPENCODE_MANAGED_MODE_IDS.has(value);
+}
+
+export function getManagedOpencodeModes(modes: OpencodeMode[]): OpencodeMode[] {
+  const effectiveModes = getEffectiveOpencodeModes(modes);
+  return OPENCODE_FALLBACK_MODES.map((fallbackMode) => (
+    effectiveModes.find((mode) => mode.id === fallbackMode.id) ?? fallbackMode
+  ));
+}
+
+export function normalizeOpencodeSelectedMode(
+  value: unknown,
+): string {
+  if (typeof value !== 'string') {
+    return '';
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return '';
+  }
+
+  return trimmed;
+}
+
+export function normalizeManagedOpencodeSelectedMode(
+  value: unknown,
+  modes: OpencodeMode[] = [],
+): string {
+  const normalized = normalizeOpencodeSelectedMode(value);
+  if (!normalized) {
+    return '';
+  }
+
+  const canonicalModeId = normalized === OPENCODE_BUILD_MODE_ID
+    ? OPENCODE_YOLO_MODE_ID
+    : normalized;
+  const managedModes = getManagedOpencodeModes(modes);
+  return managedModes.some((mode) => mode.id === canonicalModeId)
+    ? canonicalModeId
+    : (managedModes[0]?.id ?? '');
+}
+
+export function resolveOpencodeModeForPermissionMode(
+  permissionMode: unknown,
+  modes: OpencodeMode[] = [],
+): string {
+  const managedModes = getManagedOpencodeModes(modes);
+  const managedModeIds = new Set(managedModes.map((mode) => mode.id));
+
+  if (permissionMode === 'plan' && managedModeIds.has(OPENCODE_PLAN_MODE_ID)) {
+    return OPENCODE_PLAN_MODE_ID;
+  }
+  if (permissionMode === 'normal' && managedModeIds.has(OPENCODE_SAFE_MODE_ID)) {
+    return OPENCODE_SAFE_MODE_ID;
+  }
+  if (managedModeIds.has(OPENCODE_YOLO_MODE_ID)) {
+    return OPENCODE_YOLO_MODE_ID;
+  }
+
+  return managedModes[0]?.id ?? '';
+}
+
+export function resolvePermissionModeForManagedOpencodeMode(
+  modeId: unknown,
+): 'normal' | 'plan' | 'yolo' | null {
+  if (modeId === OPENCODE_BUILD_MODE_ID || modeId === OPENCODE_YOLO_MODE_ID) {
+    return 'yolo';
+  }
+  if (modeId === OPENCODE_SAFE_MODE_ID) {
+    return 'normal';
+  }
+  if (modeId === OPENCODE_PLAN_MODE_ID) {
+    return 'plan';
+  }
+  return null;
+}