@dubeyvishal/orbital-cli 1.6.14 → 1.6.15

package/server/src/lib/orbitalConfig.js

@@ -86,73 +86,10 @@ export const updateOrbitalConfig = async (patch = {}) => {
   return nextConfig;
 };
 
-// --- Model Preference Persistence ---
-
-export const getSelectedModel = async () => {
-  const cfg = await readOrbitalConfig();
-  let model = cfg.selectedModel || "gemini-2.5-flash";
-  if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
-  return {
-    provider: cfg.selectedProvider || "gemini",
-    model,
-  };
-};
-
-export const getSelectedModelSync = () => {
-  const cfg = readOrbitalConfigSync();
-  let model = cfg.selectedModel || "gemini-2.5-flash";
-  if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
-  return {
-    provider: cfg.selectedProvider || "gemini",
-    model,
-  };
-};
-
-export const saveSelectedModel = async ({ provider, model }) => {
-  return await updateOrbitalConfig({
-    selectedProvider: provider,
-    selectedModel: model,
-  });
-};
-
-// --- Multi-Provider API Key Management ---
-
-export const normalizeProviderName = (provider = "gemini") => {
-  const p = (provider || "gemini").toLowerCase().trim();
-  if (p === "google" || p === "gemini") return "gemini";
-  if (p === "openai") return "openai";
-  if (p === "xai" || p === "grok") return "grok";
-  return p;
-};
-
-export const getApiKeyFromEnvSync = (provider = "gemini") => {
-  const norm = normalizeProviderName(provider);
-  if (norm === "gemini") {
-    return (
-      (typeof process.env.GOOGLE_GENERATIVE_AI_API_KEY === "string" &&
-        process.env.GOOGLE_GENERATIVE_AI_API_KEY.trim()) ||
-      (typeof process.env.GEMINI_API_KEY === "string" &&
-        process.env.GEMINI_API_KEY.trim()) ||
-      ""
-    );
-  }
-  if (norm === "openai") {
-    return (
-      (typeof process.env.OPENAI_API_KEY === "string" &&
-        process.env.OPENAI_API_KEY.trim()) ||
-      ""
-    );
-  }
-  if (norm === "grok") {
-    return (
-      (typeof process.env.XAI_API_KEY === "string" &&
-        process.env.XAI_API_KEY.trim()) ||
-      (typeof process.env.GROK_API_KEY === "string" &&
-        process.env.GROK_API_KEY.trim()) ||
-      ""
-    );
-  }
-  return "";
+const getGeminiApiKeyFromEnvSync = () => {
+  return typeof process.env.GOOGLE_GENERATIVE_AI_API_KEY === "string"
+    ? process.env.GOOGLE_GENERATIVE_AI_API_KEY.trim()
+    : "";
 };
 
 const getLegacyGeminiApiKeyFromConfigSync = () => {
@@ -176,123 +113,80 @@ const removeLegacyGeminiApiKeyFromConfig = async () => {
   return true;
 };
 
-export const hydrateApiKeyEnv = async (provider = "gemini") => {
-  const norm = normalizeProviderName(provider);
-  const already = getApiKeyFromEnvSync(norm);
+export const hydrateGeminiApiKeyEnv = async () => {
+  const already = getGeminiApiKeyFromEnvSync();
   if (already) return already;
 
-  // OS credential manager via keytar
+  // Primary: OS credential manager via keytar.
   try {
-    const fromKeytar = await getStoredApiKey(norm);
+    const fromKeytar = await getStoredApiKey();
     if (fromKeytar) {
-      if (norm === "gemini") {
-        process.env.GOOGLE_GENERATIVE_AI_API_KEY = fromKeytar;
-      } else if (norm === "openai") {
-        process.env.OPENAI_API_KEY = fromKeytar;
-      } else if (norm === "grok") {
-        process.env.XAI_API_KEY = fromKeytar;
-      }
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY = fromKeytar;
       return fromKeytar;
     }
   } catch {
-    // Ignore keytar error; will be handled in requireApiKey
+    // ignore here; requireGeminiApiKey will surface a helpful error
   }
 
-  // One-time migration for legacy Gemini key on disk
-  if (norm === "gemini") {
-    const legacy = getLegacyGeminiApiKeyFromConfigSync();
-    if (legacy) {
-      await storeApiKey(legacy, "gemini");
-      await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
-      process.env.GOOGLE_GENERATIVE_AI_API_KEY = legacy;
-      return legacy;
-    }
+  // One-time migration: if the key exists in legacy ~/.orbital/config.json,
+  // move it into keytar and remove it from disk.
+  const legacy = getLegacyGeminiApiKeyFromConfigSync();
+  if (legacy) {
+    await storeApiKey(legacy);
+    await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
+    process.env.GOOGLE_GENERATIVE_AI_API_KEY = legacy;
+    return legacy;
   }
 
   return "";
 };
 
-export const hydrateAllApiKeysEnv = async () => {
-  await Promise.all([
-    hydrateApiKeyEnv("gemini"),
-    hydrateApiKeyEnv("openai"),
-    hydrateApiKeyEnv("grok"),
-  ]);
-};
-
-export const getApiKeySync = (provider = "gemini") => {
-  return getApiKeyFromEnvSync(provider);
-};
+export const getGeminiApiKeySync = () => getGeminiApiKeyFromEnvSync();
 
-export const getApiKey = async (provider = "gemini") => {
-  const norm = normalizeProviderName(provider);
-  const fromEnv = getApiKeyFromEnvSync(norm);
+export const getGeminiApiKey = async () => {
+  const fromEnv = getGeminiApiKeyFromEnvSync();
   if (fromEnv) return fromEnv;
-  return await hydrateApiKeyEnv(norm);
+  return await hydrateGeminiApiKeyEnv();
 };
 
-export const hasApiKeySync = (provider = "gemini") => {
-  return Boolean(getApiKeyFromEnvSync(provider));
-};
+export const hasGeminiApiKeySync = () => Boolean(getGeminiApiKeyFromEnvSync());
 
-export const requireApiKeySync = (provider = "gemini") => {
-  const norm = normalizeProviderName(provider);
-  const apiKey = getApiKeyFromEnvSync(norm);
+export const requireGeminiApiKeySync = () => {
+  const apiKey = getGeminiApiKeyFromEnvSync();
   if (!apiKey) {
-    const displayName =
-      norm === "gemini" ? "Gemini" : norm === "openai" ? "OpenAI" : "Grok (xAI)";
     const err = new Error(
-      `${displayName} API key not set. Run: orbital set-key --provider ${norm} <API_KEY>`
+      "Gemini API key not set. Run: orbital set-key <API_KEY>"
     );
-    err.code = `ORBITAL_${norm.toUpperCase()}_API_KEY_NOT_SET`;
+    err.code = "ORBITAL_GEMINI_API_KEY_NOT_SET";
     throw err;
   }
   return apiKey;
 };
 
-export const requireApiKey = async (provider = "gemini") => {
-  const norm = normalizeProviderName(provider);
-  const apiKey = await getApiKey(norm);
+export const requireGeminiApiKey = async () => {
+  const apiKey = await getGeminiApiKey();
   if (!apiKey) {
-    const displayName =
-      norm === "gemini" ? "Gemini" : norm === "openai" ? "OpenAI" : "Grok (xAI)";
     const err = new Error(
-      `${displayName} API key not set. Run: orbital set-key --provider ${norm} <API_KEY>`
+      "Gemini API key not set. Run: orbital set-key <API_KEY>"
     );
-    err.code = `ORBITAL_${norm.toUpperCase()}_API_KEY_NOT_SET`;
+    err.code = "ORBITAL_GEMINI_API_KEY_NOT_SET";
     throw err;
   }
   return apiKey;
 };
 
-export const setApiKey = async (provider = "gemini", apiKey) => {
-  const norm = normalizeProviderName(provider);
+export const setGeminiApiKey = async (apiKey) => {
   const trimmed = typeof apiKey === "string" ? apiKey.trim() : "";
   if (!trimmed) throw new Error("API key is required");
 
-  await storeApiKey(trimmed, norm);
-
-  if (norm === "gemini") {
-    await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
-    process.env.GOOGLE_GENERATIVE_AI_API_KEY = trimmed;
-    process.env.GEMINI_API_KEY = trimmed;
-  } else if (norm === "openai") {
-    process.env.OPENAI_API_KEY = trimmed;
-  } else if (norm === "grok") {
-    process.env.XAI_API_KEY = trimmed;
-    process.env.GROK_API_KEY = trimmed;
-  }
+  await storeApiKey(trimmed);
+  // Ensure any legacy on-disk key is removed.
+  await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
 
+  process.env.GOOGLE_GENERATIVE_AI_API_KEY = trimmed;
   return true;
 };
 
-// --- Back-compatibility exports for Gemini ---
-
-export const hydrateGeminiApiKeyEnv = () => hydrateApiKeyEnv("gemini");
-export const getGeminiApiKeySync = () => getApiKeySync("gemini");
-export const getGeminiApiKey = () => getApiKey("gemini");
-export const hasGeminiApiKeySync = () => hasApiKeySync("gemini");
-export const requireGeminiApiKeySync = () => requireApiKeySync("gemini");
-export const requireGeminiApiKey = () => requireApiKey("gemini");
-export const setGeminiApiKey = (apiKey) => setApiKey("gemini", apiKey);
+// Back-compat exports (no longer reads from config specifically).
 export const requireGeminiApiKeyFromConfigSync = requireGeminiApiKeySync;
+

package/server/src/service/aiService.js

@@ -1,5 +1,5 @@
 import { AIService } from "../cli/ai/googleService.js";
 
-export const getAIService = (modelConfig = null) => {
-  return new AIService(modelConfig);
+export const getAIService = () => {
+  return new AIService();
 };

package/server/src/config/aiConfig.js

@@ -1,159 +0,0 @@
-import "./env.js";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createXai } from "@ai-sdk/xai";
-import { normalizeProviderName, requireApiKeySync } from "../lib/orbitalConfig.js";
-
-export const AI_PROVIDERS = {
-  gemini: {
-    id: "gemini",
-    name: "Google Gemini",
-    defaultModel: "gemini-2.5-flash",
-    envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
-    docsUrl: "https://aistudio.google.com/app/apikey",
-    models: [
-      {
-        id: "gemini-2.5-flash",
-        name: "Gemini 2.5 Flash",
-        hint: "Google (Fast & versatile - Recommended)",
-        isDefault: true,
-      },
-      {
-        id: "gemini-2.5-pro",
-        name: "Gemini 2.5 Pro",
-        hint: "Google (Complex reasoning & large context)",
-      },
-      {
-        id: "gemini-1.5-flash",
-        name: "Gemini 1.5 Flash",
-        hint: "Google (Lightweight & efficient)",
-      },
-      {
-        id: "gemini-1.5-pro",
-        name: "Gemini 1.5 Pro",
-        hint: "Google (Extended analysis)",
-      },
-    ],
-  },
-  openai: {
-    id: "openai",
-    name: "OpenAI",
-    defaultModel: "gpt-4o",
-    envKey: "OPENAI_API_KEY",
-    docsUrl: "https://platform.openai.com/api-keys",
-    models: [
-      {
-        id: "gpt-4o",
-        name: "GPT-4o",
-        hint: "OpenAI (Flagship multimodal intelligence)",
-        isDefault: true,
-      },
-      {
-        id: "gpt-4o-mini",
-        name: "GPT-4o Mini",
-        hint: "OpenAI (Fast & cost-effective)",
-      },
-    ],
-  },
-  grok: {
-    id: "grok",
-    name: "Grok (xAI)",
-    defaultModel: "grok-2-latest",
-    envKey: "XAI_API_KEY",
-    docsUrl: "https://console.x.ai/",
-    models: [
-      {
-        id: "grok-2-latest",
-        name: "Grok 2",
-        hint: "xAI (Frontier model with advanced reasoning)",
-        isDefault: true,
-      },
-      {
-        id: "grok-beta",
-        name: "Grok Beta",
-        hint: "xAI (Experimental release)",
-      },
-    ],
-  },
-};
-
-/**
- * Returns options list suitable for @clack/prompts select()
- */
-export const getModelSelectOptions = () => {
-  const options = [];
-  for (const provider of Object.values(AI_PROVIDERS)) {
-    for (const model of provider.models) {
-      options.push({
-        value: `${provider.id}:${model.id}`,
-        label: `${provider.name} - ${model.name}`,
-        hint: model.hint,
-      });
-    }
-  }
-  return options;
-};
-
-/**
- * Parse a compound value like "openai:gpt-4o" or separate provider/model inputs
- */
-export const parseModelChoice = (choice) => {
-  if (!choice) return { provider: "gemini", model: "gemini-2.5-flash" };
-  if (typeof choice === "object") {
-    const provider = normalizeProviderName(choice.provider || "gemini");
-    const defaultModel = AI_PROVIDERS[provider]?.defaultModel || "gemini-2.5-flash";
-    let model = choice.model || defaultModel;
-    if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
-    return {
-      provider,
-      model,
-    };
-  }
-
-  if (typeof choice === "string" && choice.includes(":")) {
-    const [p, m] = choice.split(":");
-    const provider = normalizeProviderName(p);
-    const model = m.includes("gemini-2.0") ? "gemini-2.5-flash" : m;
-    return { provider, model };
-  }
-
-  // If only provider name is given
-  const provider = normalizeProviderName(choice);
-  return {
-    provider,
-    model: AI_PROVIDERS[provider]?.defaultModel || choice,
-  };
-};
-
-
-export const getModelDisplayName = (provider, modelId) => {
-  const norm = normalizeProviderName(provider);
-  const provInfo = AI_PROVIDERS[norm];
-  if (!provInfo) return `${provider} (${modelId})`;
-  const modelInfo = provInfo.models.find((m) => m.id === modelId);
-  return modelInfo ? `${provInfo.name} (${modelInfo.name})` : `${provInfo.name} (${modelId})`;
-};
-
-/**
- * Creates a language model instance for Vercel AI SDK
- */
-export const createModelInstance = (provider, modelName, apiKey = null) => {
-  const norm = normalizeProviderName(provider);
-  const key = apiKey || requireApiKeySync(norm);
-
-  switch (norm) {
-    case "openai": {
-      const openai = createOpenAI({ apiKey: key });
-      return openai(modelName);
-    }
-    case "grok": {
-      const xai = createXai({ apiKey: key });
-      return xai(modelName);
-    }
-    case "gemini":
-    default: {
-      const google = createGoogleGenerativeAI({ apiKey: key });
-      return google(modelName);
-    }
-  }
-};