Merge pull request #34 from CommandAI/openAI

Open ai

Author: rootedbox

README.md

@@ -54,10 +54,11 @@ This tool is still in its alpha stage, so expect some hiccups as we fine-tune ou
 
 ## 🔥 Features
 
-- **AI Service Selection**: Pick between Ollama and ChatGPT to generate scripts for you.
+- **AI Service Selection**: Pick between Ollama, ChatGPT, and any OpenAI compatable server.
 - **Easy Configuration**: Set everything up quickly with a few prompts.
-- **Execution Plans**: See what’s going to happen before it happens.
-- **Optional Logging**: Keep track of everything for debugging or just for fun.
+- **Command Line Power**: Ask the AI to do any task(s) you would want to do at the command line.
+- **DB Power**: Ask the AI for any information from your DB in plain language.
+- **Conversational AI**: Start a conversation with the AI.
 
 ## 📋 Requirements
 

lib/aiClient/adapters/ChatGPTAdapter.js lib/aiClient/adapters/OpenAIAdapter.jslib/aiClient/adapters/ChatGPTAdapter.js renamed to lib/aiClient/adapters/OpenAIAdapter.js

@@ -1,16 +1,20 @@
 import OpenAI from "openai";
 import BaseAdapter from "./BaseAdapter.js";
 
-class ChatGPTAdapter extends BaseAdapter {
+class OpenAIAdapter extends BaseAdapter {
   constructor(config) {
     super(config);
-    this.apiKey = config.chatgptApiKey;
-    this.model = config.chatgptModel;
+    this.apiKey = config.openAIApiKey;
+    this.model = config.openAIModel;
+    this.apiUrl = config.openAIApiUrl || "https://api.openai.com/v1"; 
   }
 
   async generateResponse(command) {
     try {
-      const openai = new OpenAI({ apiKey: this.apiKey });
+      const openai = new OpenAI({
+        apiKey: this.apiKey,
+        baseURL: this.apiUrl, 
+      });
 
       this.messages.push({
         role: "user",
@@ -33,4 +37,4 @@ class ChatGPTAdapter extends BaseAdapter {
   }
 }
 
-export default ChatGPTAdapter;
+export default OpenAIAdapter;

lib/aiClient/aiClient.js

@@ -1,11 +1,11 @@
 import OllamaAdapter from "./adapters/OllamaAdapter.js";
-import ChatGPTAdapter from "./adapters/ChatGPTAdapter.js";
+import OpenAIAdapter from "./adapters/OpenAIAdapter.js";
 
 class AIClient {
   constructor(config) {
     this.adapter =
-      config.aiService === "ChatGPT"
-        ? new ChatGPTAdapter(config)
+      config.aiService === "ChatGPT" || "OpenAI"
+        ? new OpenAIAdapter(config)
         : new OllamaAdapter(config);
   }
 

lib/config.js

@@ -7,7 +7,8 @@ import { Ollama } from "ollama";
 import gradient from "gradient-string";
 
 const configPath = path.join(os.homedir(), ".commandai", "config.json");
-const defaultChatGPTModel = "gpt-4o";
+const defaultOpenAIModel = "gpt-4o";
+const defaultOpenAIApiUrl = "https://api.openai.com/v1";
 const defaultOllamaUrl = "http://127.0.0.1:11434";
 
 async function checkOllamaActive(url = defaultOllamaUrl) {
@@ -25,8 +26,32 @@ function loadConfig() {
   if (fs.existsSync(configPath)) {
     const configFile = fs.readFileSync(configPath);
     const config = JSON.parse(configFile);
+
+    if (!config.openAIApiUrl) {
+      config.openAIApiUrl = config.chatgptApiUrl;
+     
+      delete config.chatgptApiUrl;
+    }
+
+    if (!config.openAIModel) {
+      config.openAIModel = config.chatgptModel;
+     
+      delete config.chatgptModel;
+    }
+
+    if (!config.openAIApiKey) {
+      config.openAIApiKey = config.chatgptApiKey;
+     
+      delete config.chatgptApiKey;
+    }
+
     config.model =
-      config.aiService === "Ollama" ? config.ollamaModel : config.chatgptModel;
+      config.aiService === "Ollama" ? config.ollamaModel : config.openAIModel;
+
+    if (config.aiService === "ChatGPT") {
+      config.openAIApiUrl = defaultOpenAIApiUrl;
+    }
+
     return config;
   } else {
     return null;
@@ -35,7 +60,7 @@ function loadConfig() {
 
 async function saveConfig(config) {
   config.model =
-    config.aiService === "Ollama" ? config.ollamaModel : config.chatgptModel;
+    config.aiService === "Ollama" ? config.ollamaModel : config.openAIModel;
   const dir = path.dirname(configPath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
@@ -46,9 +71,9 @@ async function saveConfig(config) {
   console.log();
 }
 
-async function validateApiKey(apiKey) {
+async function validateApiKey(apiKey, openAIApiUrl) {
   try {
-    const openai = new OpenAI({ apiKey: apiKey });
+    const openai = new OpenAI({ baseURL: openAIApiUrl, apiKey: apiKey });
     await openai.models.list();
     return true;
   } catch (error) {
@@ -57,9 +82,9 @@ async function validateApiKey(apiKey) {
   }
 }
 
-async function fetchChatGPTModels(apiKey) {
+async function fetchOpenAIModels(openAIApiUrl, apiKey) {
   try {
-    const openai = new OpenAI({ apiKey: apiKey });
+    const openai = new OpenAI({ baseURL: openAIApiUrl, apiKey: apiKey });
     const response = await openai.models.list();
     return response.data.map((model) => model.id);
   } catch (error) {
@@ -161,67 +186,100 @@ async function promptOllamaConfig(defaultUrl, defaultModel) {
   };
 }
 
-async function promptChatGPTAPIKey(defaultApiKey) {
-  const chatgptConfig = await inquirer.prompt([
+async function promptOpenAIAPIKey(defaultApiKey, openAIApiUrl) {
+  const openAIConfig = await inquirer.prompt([
     {
       type: "input",
-      name: "chatgptApiKey",
+      name: "openAIApiKey",
       message: "Enter your OpenAI API key:",
       default: defaultApiKey,
     },
   ]);
 
-  const isValidApiKey = await validateApiKey(chatgptConfig.chatgptApiKey);
+  const isValidApiKey = await validateApiKey(openAIConfig.openAIApiKey, openAIApiUrl);
 
   if (!isValidApiKey) {
     return null;
   }
 
-  return chatgptConfig;
+  return openAIConfig;
 }
 
-async function promptChatGPTModels(defaultModel, defaultApiKey) {
-  const models = await fetchChatGPTModels(defaultApiKey);
+
+async function promptOpenAIModels(defaultModel, openAIApiUrl, openAIApiKey) {
+  const models = await fetchOpenAIModels(openAIApiUrl, openAIApiKey);
+
   if (models.length === 0) {
     console.error(
       "No models found for the provided API key. Please try again.",
     );
     return null;
   }
 
-  const chatgptModel = await inquirer.prompt([
+  const openAIModel = await inquirer.prompt([
     {
       type: "list",
-      name: "chatgptModel",
-      message: "Select the ChatGPT model:",
+      name: "openAIModel",
+      message: "Select the OpenAI model:",
       choices: models,
       default: defaultModel,
     },
   ]);
 
-  return chatgptModel;
+  return openAIModel;
+}
+
+async function promptOpenAIURL(defaultUrl) {
+  const openAIApiUrl = await inquirer.prompt([
+    {
+      type: "input",
+      name: "openAIApiUrl",
+      message: "Enter the URL for the OpenAI server:",
+      default: defaultUrl,
+    },
+  ]);
+
+  return openAIApiUrl;
 }
 
-async function promptChatGPTConfig(defaultApiKey, defaultModel) {
-  const chatgptConfig = await promptChatGPTAPIKey(defaultApiKey);
+async function promptOpenAIConfig(config) {
+  let openAIApiUrl = { openAIApiUrl: config.openAIApiUrl || defaultOpenAIApiUrl };
 
-  if (!chatgptConfig) return null;
+  if (config.aiService === "OpenAI") {
+    openAIApiUrl = await promptOpenAIURL(config.openAIApiUrl);
+    if (!openAIApiUrl) return null;
+  } else {
+    openAIApiUrl = { openAIApiUrl: defaultOpenAIApiUrl };
+  } 
 
-  const chatgptModel = await promptChatGPTModels(defaultModel, defaultApiKey);
+  const openAIConfig = await promptOpenAIAPIKey(config.openAIApiKey, openAIApiUrl.openAIApiUrl);
 
-  if (!chatgptModel) return null;
+  if (!openAIConfig) return null;
 
-  return {
-    chatgptApiKey: chatgptConfig.chatgptApiKey,
-    chatgptModel: chatgptModel.chatgptModel,
-  };
+  const openAIModel = await promptOpenAIModels(config.openAIModel, openAIApiUrl.openAIApiUrl, config.openAIApiKey);
+
+  if (!openAIModel) return null;
+
+  if (openAIApiUrl) {
+    return {
+      openAIApiKey: openAIConfig.openAIApiKey,
+      openAIModel: openAIModel.openAIModel,
+      openAIApiUrl: openAIApiUrl.openAIApiUrl,
+    };
+  } else {
+    return {
+      openAIApiKey: openAIConfig.openAIApiKey,
+      openAIModel: openAIModel.openAIModel,
+    };
+  }
 }
 
 async function getAIServiceChoices() {
   const isOllamaActive = await checkOllamaActive();
   return [
     { name: isOllamaActive ? "Ollama (Running)" : "Ollama", value: "Ollama" },
     { name: "ChatGPT", value: "ChatGPT" },
+    { name: "OpenAI", value: "OpenAI" },
   ];
 }
 
@@ -230,8 +288,9 @@ async function configure(
     aiService: "",
     ollamaUrl: defaultOllamaUrl,
     ollamaModel: "",
-    chatgptApiKey: "",
-    chatgptModel: defaultChatGPTModel,
+    openAIApiKey: "",
+    openAIModel: defaultOpenAIModel,
+    openAIApiUrl: defaultOpenAIApiUrl,
     showExecutionDescription: true,
     showExecutionPlan: true,
     enableLogging: false,
@@ -266,7 +325,7 @@ async function promptAndConfigureAIService(finalConfig, aiServiceChoices) {
     finalConfig.model =
       finalConfig.aiService === "Ollama"
         ? finalConfig.ollamaModel
-        : finalConfig.chatgptModel;
+        : finalConfig.openAIModel;
 
     validConfig = true;
   }
@@ -278,7 +337,9 @@ async function configureSelectedAIService(finalConfig) {
   if (finalConfig.aiService === "Ollama") {
     return await configureOllamaService(finalConfig);
   } else if (finalConfig.aiService === "ChatGPT") {
-    return await configureChatGPTService(finalConfig);
+    return await configureOpenAIService(finalConfig);
+  } else if (finalConfig.aiService === "OpenAI") {
+    return await configureOpenAIService(finalConfig);
   }
   return null;
 }
@@ -296,17 +357,22 @@ async function configureOllamaService(finalConfig) {
   };
 }
 
-async function configureChatGPTService(finalConfig) {
-  const chatgptConfig = await promptChatGPTConfig(
-    finalConfig.chatgptApiKey,
-    finalConfig.chatgptModel,
-  );
-  if (!chatgptConfig) return null;
+async function configureOpenAIService(finalConfig) {
+  const openAIConfig = await promptOpenAIConfig(finalConfig);
+  if (!openAIConfig) return null;
 
-  return {
-    chatgptApiKey: chatgptConfig.chatgptApiKey,
-    chatgptModel: chatgptConfig.chatgptModel,
-  };
+  if (finalConfig.aiService === "OpenAI") {
+    return {
+      openAIApiKey: openAIConfig.openAIApiKey,
+      openAIModel: openAIConfig.openAIModel,
+      openAIApiUrl: openAIConfig.openAIApiUrl,
+    };
+  } else {
+    return {
+      openAIApiKey: openAIConfig.openAIApiKey,
+      openAIModel: openAIConfig.openAIModel,
+    };
+  }
 }
 
 export { loadConfig, saveConfig, configure };