nemoris 0.1.0

package/src/onboarding/model-catalog.js

@@ -0,0 +1,344 @@
+import { inspectOpenAICodexProfile } from "../auth/openai-codex-oauth.js";
+import { getAuthProfile } from "../auth/auth-profiles.js";
+
+export const PROVIDER_ENV_KEYS = {
+  anthropic: ["NEMORIS_ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  openai: ["NEMORIS_OPENAI_API_KEY", "OPENAI_API_KEY"],
+};
+
+export const CURATED_MODELS = {
+  anthropic: [
+    {
+      value: "anthropic/claude-haiku-4-5",
+      label: "claude-haiku-4-5",
+      hint: "ctx 200k · fast · cheapest",
+    },
+    {
+      value: "anthropic/claude-sonnet-4-6",
+      label: "claude-sonnet-4-6",
+      hint: "ctx 200k · balanced · recommended",
+    },
+    {
+      value: "anthropic/claude-opus-4-6",
+      label: "claude-opus-4-6",
+      hint: "ctx 200k · most capable · expensive",
+    },
+  ],
+  openai: [
+    {
+      value: "openai-codex/gpt-4.1",
+      label: "gpt-4.1",
+      hint: "ctx 1M · latest · recommended",
+    },
+    {
+      value: "openai-codex/gpt-4o",
+      label: "gpt-4o",
+      hint: "ctx 128k · fast · multimodal",
+    },
+    {
+      value: "openai-codex/o4-mini",
+      label: "o4-mini",
+      hint: "ctx 200k · reasoning · efficient",
+    },
+    {
+      value: "openai-codex/o3",
+      label: "o3",
+      hint: "ctx 200k · reasoning · most capable",
+    },
+  ],
+  openrouter: [
+    {
+      value: "openrouter/anthropic/claude-haiku-4-5",
+      label: "anthropic/claude-haiku-4-5",
+      hint: "ctx 200k · fast · recommended",
+    },
+    {
+      value: "openrouter/anthropic/claude-sonnet-4-6",
+      label: "anthropic/claude-sonnet-4-6",
+      hint: "ctx 200k · balanced · strong default",
+    },
+    {
+      value: "openrouter/openai/gpt-4o",
+      label: "openai/gpt-4o",
+      hint: "ctx 128k · vision · broad compatibility",
+    },
+    {
+      value: "openrouter/google/gemini-2.5-flash",
+      label: "google/gemini-2.5-flash",
+      hint: "ctx 1M · fast · long context",
+    },
+    {
+      value: "openrouter/anthropic/claude-opus-4-6",
+      label: "anthropic/claude-opus-4-6",
+      hint: "ctx 200k · most capable · expensive",
+    },
+  ],
+};
+
+const OPENAI_CHAT_MODEL_PREFIXES = ["gpt-4", "gpt-3.5", "o1", "o2", "o3", "o4"];
+const OPENAI_EXCLUDED_MODEL_TOKENS = ["whisper", "tts", "dall-e", "text-embedding", "babbage", "davinci", "curie", "ada"];
+
+function isOpenAIChatModelId(id) {
+  const normalized = String(id || "").trim().toLowerCase();
+  if (!normalized) return false;
+  if (!OPENAI_CHAT_MODEL_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+    return false;
+  }
+  return !OPENAI_EXCLUDED_MODEL_TOKENS.some((token) => normalized.includes(token));
+}
+
+export async function fetchOpenAIModels(apiKey, { fetchImpl = globalThis.fetch } = {}) {
+  const token = String(apiKey || "").trim();
+  if (!token || typeof fetchImpl !== "function") {
+    return [];
+  }
+
+  try {
+    const response = await fetchImpl("https://api.openai.com/v1/models", {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!response?.ok) {
+      return [];
+    }
+
+    const payload = await response.json();
+    if (!Array.isArray(payload?.data)) {
+      return [];
+    }
+
+    const seen = new Set();
+    return payload.data
+      .filter((item) => isOpenAIChatModelId(item?.id))
+      .sort((left, right) => {
+        const rightCreated = Number(right?.created) || 0;
+        const leftCreated = Number(left?.created) || 0;
+        if (rightCreated !== leftCreated) {
+          return rightCreated - leftCreated;
+        }
+        return String(left?.id || "").localeCompare(String(right?.id || ""));
+      })
+      .map((item) => item.id)
+      .filter((id) => {
+        if (!id || seen.has(id)) return false;
+        seen.add(id);
+        return true;
+      });
+  } catch {
+    return [];
+  }
+}
+
+export function resolveEnvKey(provider, env = process.env) {
+  const candidates = PROVIDER_ENV_KEYS[provider] || [];
+  for (const key of candidates) {
+    if (env[key]) {
+      return { name: key, value: env[key] };
+    }
+  }
+  return { name: candidates[0] || null, value: null };
+}
+
+export function maskSecret(secret) {
+  const value = String(secret || "").trim();
+  if (!value) return "missing";
+  if (value.length <= 8) return "****";
+  return `${value.slice(0, 6)}...${value.slice(-4)}`;
+}
+
+export function formatExpiry(msUntilExpiry) {
+  if (!Number.isFinite(msUntilExpiry)) return "expires unknown";
+  if (msUntilExpiry <= 0) return "expired";
+  const days = Math.floor(msUntilExpiry / (24 * 60 * 60 * 1000));
+  if (days >= 1) return `expires in ${days}d`;
+  const hours = Math.max(1, Math.floor(msUntilExpiry / (60 * 60 * 1000)));
+  return `expires in ${hours}h`;
+}
+
+export function detectProviderOptions({ env = process.env, ollamaResult = { ok: false, models: [] } } = {}) {
+  const anthropic = resolveEnvKey("anthropic", env);
+  const openrouter = resolveEnvKey("openrouter", env);
+  const openai = resolveEnvKey("openai", env);
+
+  return [
+    {
+      value: "anthropic",
+      label: "Anthropic",
+      hint: anthropic.value ? "API key found in env" : "API key required",
+      detected: Boolean(anthropic.value),
+    },
+    {
+      value: "openai",
+      label: "OpenAI",
+      hint: openai.value ? "API key found in env" : "API key or ChatGPT OAuth",
+      detected: Boolean(openai.value),
+    },
+    {
+      value: "openrouter",
+      label: "OpenRouter",
+      hint: openrouter.value ? "API key found" : "One key, 100+ models — openrouter.ai",
+      detected: Boolean(openrouter.value),
+    },
+    {
+      value: "ollama",
+      label: "Ollama",
+      hint: ollamaResult.ok
+        ? `Local, free — ${ollamaResult.models?.length || 0} models installed`
+        : "Local, free — not detected",
+      detected: Boolean(ollamaResult.ok),
+    },
+    {
+      value: "skip",
+      label: "Skip for now",
+      hint: "Finish setup without provider auth.",
+      detected: false,
+    },
+  ];
+}
+
+export function detectPreferredProvider({ env = process.env, ollamaResult = { ok: false } } = {}) {
+  for (const provider of ["anthropic", "openai", "openrouter"]) {
+    if (resolveEnvKey(provider, env).value) {
+      return provider;
+    }
+  }
+  if (ollamaResult.ok) return "ollama";
+  return "skip";
+}
+
+function normalizeProviderModel(provider, value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return "";
+  if (provider === "openrouter") {
+    return trimmed.startsWith("openrouter/") ? trimmed : `openrouter/${trimmed}`;
+  }
+  if (provider === "openai") {
+    return trimmed.startsWith("openai-codex/") ? trimmed : `openai-codex/${trimmed}`;
+  }
+  if (provider === "anthropic") {
+    return trimmed.startsWith("anthropic/") ? trimmed : `anthropic/${trimmed}`;
+  }
+  if (provider === "ollama") {
+    return trimmed.startsWith("ollama/") ? trimmed.slice("ollama/".length) : trimmed;
+  }
+  return trimmed;
+}
+
+export function buildModelSelectionOptions({
+  provider,
+  currentModel = "",
+  installedModels = [],
+  discoveredModels = [],
+  includeKeep = true,
+  includeManual = true,
+} = {}) {
+  const options = [];
+  const seen = new Set();
+  const add = (entry) => {
+    if (!entry || !entry.value || seen.has(entry.value)) return;
+    seen.add(entry.value);
+    options.push(entry);
+  };
+
+  if (includeKeep && currentModel) {
+    add({ value: "__keep__", label: `Keep current (${currentModel})` });
+  }
+  if (includeManual) {
+    add({ value: "__manual__", label: "Enter model name manually" });
+  }
+
+  for (const entry of CURATED_MODELS[provider] || []) {
+    add(entry);
+  }
+
+  const rawModels = provider === "ollama"
+    ? installedModels
+    : discoveredModels;
+  for (const model of rawModels) {
+    const normalized = normalizeProviderModel(provider, model);
+    if (!normalized) continue;
+    add({
+      value: normalized,
+      label: provider === "ollama" ? model : normalized.replace(/^openai-codex\//, "").replace(/^openrouter\//, ""),
+      hint: provider === "ollama" ? "installed locally" : "detected from provider",
+    });
+  }
+
+  return options;
+}
+
+export function summarizeSelectedModels(selectedModels = []) {
+  const unique = [...new Set(selectedModels.filter(Boolean))];
+  return {
+    defaultModel: unique[0] || "",
+    fallbackModel: unique[1] || "",
+    localModel: unique.find((model) => String(model).startsWith("ollama/")) || "",
+  };
+}
+
+export function buildModelsOverview({ router = {}, providers = {}, authProfilesPath } = {}) {
+  const defaultModel = router.interactive_primary?.primary || "";
+  const fallbackModel = router.interactive_primary?.fallback || router.report_fallback_lowcost?.primary || "";
+  const localModel = router.local_primary?.primary || router.local_report?.primary || "";
+
+  const authLines = [];
+  for (const provider of ["anthropic", "openrouter", "openai-codex", "ollama"]) {
+    const providerConfig = providers[provider];
+    if (!providerConfig) continue;
+
+    if (provider === "ollama") {
+      authLines.push({
+        provider,
+        ok: true,
+        method: "local",
+        detail: localModel.replace(/^ollama\//, "") || "configured",
+      });
+      continue;
+    }
+
+    const authRef = providerConfig.authRef || "";
+    if (authRef.startsWith("env:")) {
+      const envName = authRef.slice(4);
+      const secret = process.env[envName] || "";
+      authLines.push({
+        provider,
+        ok: Boolean(secret),
+        method: "token",
+        detail: secret ? maskSecret(secret) : `missing ${envName}`,
+      });
+      continue;
+    }
+
+    if (authRef.startsWith("profile:")) {
+      const profileId = authRef.slice("profile:".length);
+      const profile = getAuthProfile(profileId, authProfilesPath);
+      const inspection = inspectOpenAICodexProfile(profile, { now: Date.now() });
+      authLines.push({
+        provider,
+        ok: inspection.state === "usable_token" || inspection.state === "refresh_needed",
+        method: "oauth",
+        detail: inspection.expiresAt ? formatExpiry(inspection.expiresAt - Date.now()) : inspection.reason,
+      });
+      continue;
+    }
+
+    authLines.push({
+      provider,
+      ok: false,
+      method: "unknown",
+      detail: "not configured",
+    });
+  }
+
+  return {
+    defaultModel,
+    fallbackModel,
+    localModel,
+    authLines,
+  };
+}