@nhonh/qabot 0.1.0 → 0.2.0

package/bin/qabot.js

@@ -7,6 +7,7 @@ import { registerRunCommand } from "../src/cli/commands/run.js";
 import { registerListCommand } from "../src/cli/commands/list.js";
 import { registerGenerateCommand } from "../src/cli/commands/generate.js";
 import { registerReportCommand } from "../src/cli/commands/report.js";
+import { registerAuthCommand } from "../src/cli/commands/auth.js";
 
 const program = new Command();
 
@@ -20,5 +21,6 @@ registerRunCommand(program);
 registerListCommand(program);
 registerGenerateCommand(program);
 registerReportCommand(program);
+registerAuthCommand(program);
 
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nhonh/qabot",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI-powered universal QA automation tool. Import any project, AI analyzes and runs tests across all layers.",
   "main": "src/index.js",
   "bin": {

package/src/ai/ai-engine.js

@@ -3,16 +3,42 @@ import {
   buildGenerationPrompt,
   buildRecommendationPrompt,
 } from "./prompt-builder.js";
+import { AI_PROVIDER_DEFAULTS } from "../core/constants.js";
 
 export class AIEngine {
   constructor(config = {}) {
     this.provider = config.provider || "none";
-    this.model = config.model || "gpt-4o";
-    this.apiKey = process.env[config.apiKeyEnv || "OPENAI_API_KEY"] || "";
+    this.model =
+      config.model || AI_PROVIDER_DEFAULTS[this.provider]?.model || "gpt-4o";
+    this.apiKey = resolveApiKey(config);
+    this.baseUrl =
+      config.baseUrl || AI_PROVIDER_DEFAULTS[this.provider]?.baseUrl || "";
+    this.authHeader =
+      config.authHeader ||
+      AI_PROVIDER_DEFAULTS[this.provider]?.authHeader ||
+      "Authorization";
+    this.authPrefix =
+      config.authPrefix ??
+      AI_PROVIDER_DEFAULTS[this.provider]?.authPrefix ??
+      "Bearer ";
+    this.extraHeaders = config.extraHeaders || {};
+    this.temperature = config.temperature ?? 0.3;
+    this.maxTokens = config.maxTokens ?? 4096;
   }
 
   isAvailable() {
-    return this.provider !== "none" && !!this.apiKey;
+    if (this.provider === "none") return false;
+    if (this.provider === "ollama") return true;
+    return !!this.apiKey;
+  }
+
+  getProviderInfo() {
+    return {
+      provider: this.provider,
+      model: this.model,
+      baseUrl: this.baseUrl,
+      hasApiKey: !!this.apiKey,
+    };
   }
 
   async analyzeCode(code, context) {
@@ -45,70 +71,171 @@ export class AIEngine {
   async complete(prompt) {
     switch (this.provider) {
       case "openai":
-        return this.callOpenAI(prompt);
+      case "deepseek":
+      case "groq":
+        return this.callOpenAICompatible(prompt);
       case "anthropic":
         return this.callAnthropic(prompt);
+      case "gemini":
+        return this.callGemini(prompt);
       case "ollama":
         return this.callOllama(prompt);
+      case "proxy":
+        return this.callProxy(prompt);
       default:
         throw new Error(
-          `AI provider "${this.provider}" not configured. Set provider in qabot.config.js`,
+          `AI provider "${this.provider}" not supported. Available: openai, anthropic, gemini, deepseek, groq, ollama, proxy`,
         );
     }
   }
 
-  async callOpenAI(prompt) {
-    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+  buildAuthHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.extraHeaders,
+    };
+    if (this.authHeader && this.apiKey) {
+      headers[this.authHeader] = `${this.authPrefix}${this.apiKey}`;
+    }
+    return headers;
+  }
+
+  async callOpenAICompatible(prompt) {
+    const url = `${this.baseUrl}/chat/completions`;
+    const headers = this.buildAuthHeaders();
+
+    const res = await fetch(url, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-      },
+      headers,
       body: JSON.stringify({
         model: this.model,
         messages: [{ role: "user", content: prompt }],
-        temperature: 0.3,
-        max_tokens: 4096,
+        temperature: this.temperature,
+        max_tokens: this.maxTokens,
       }),
     });
-    if (!res.ok)
-      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`${this.provider} API error (${res.status}): ${body}`);
+    }
     const data = await res.json();
     return data.choices?.[0]?.message?.content || "";
   }
 
   async callAnthropic(prompt) {
-    const res = await fetch("https://api.anthropic.com/v1/messages", {
+    const url = `${this.baseUrl}/messages`;
+    const headers = {
+      ...this.buildAuthHeaders(),
+      "anthropic-version": "2023-06-01",
+    };
+
+    const res = await fetch(url, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01",
-      },
+      headers,
       body: JSON.stringify({
-        model: this.model || "claude-sonnet-4-20250514",
-        max_tokens: 4096,
+        model: this.model,
+        max_tokens: this.maxTokens,
         messages: [{ role: "user", content: prompt }],
       }),
     });
-    if (!res.ok)
-      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Anthropic API error (${res.status}): ${body}`);
+    }
     const data = await res.json();
     return data.content?.[0]?.text || "";
   }
 
+  async callGemini(prompt) {
+    const url = `${this.baseUrl}/models/${this.model}:generateContent`;
+    const headers = this.buildAuthHeaders();
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: prompt }] }],
+        generationConfig: {
+          temperature: this.temperature,
+          maxOutputTokens: this.maxTokens,
+        },
+      }),
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Gemini API error (${res.status}): ${body}`);
+    }
+    const data = await res.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+  }
+
   async callOllama(prompt) {
-    const res = await fetch("http://localhost:11434/api/generate", {
+    const url = `${this.baseUrl}/api/generate`;
+    const res = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, prompt, stream: false }),
+    });
+    if (!res.ok) throw new Error(`Ollama API error (${res.status})`);
+    const data = await res.json();
+    return data.response || "";
+  }
+
+  async callProxy(prompt) {
+    if (!this.baseUrl) {
+      throw new Error(
+        "Proxy provider requires baseUrl. Set ai.baseUrl in qabot.config.js",
+      );
+    }
+
+    const headers = this.buildAuthHeaders();
+
+    const res = await fetch(this.baseUrl, {
+      method: "POST",
+      headers,
       body: JSON.stringify({
-        model: this.model || "llama3",
-        prompt,
-        stream: false,
+        model: this.model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: this.temperature,
+        max_tokens: this.maxTokens,
       }),
     });
-    if (!res.ok) throw new Error(`Ollama API error: ${res.status}`);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Proxy API error (${res.status}): ${body}`);
+    }
+
     const data = await res.json();
-    return data.response || "";
+
+    if (data.choices?.[0]?.message?.content)
+      return data.choices[0].message.content;
+    if (data.content?.[0]?.text) return data.content[0].text;
+    if (data.candidates?.[0]?.content?.parts?.[0]?.text)
+      return data.candidates[0].content.parts[0].text;
+    if (data.response) return data.response;
+    if (typeof data.text === "string") return data.text;
+    if (typeof data.output === "string") return data.output;
+    if (typeof data.result === "string") return data.result;
+
+    throw new Error(
+      "Proxy returned unknown response format. Expected OpenAI/Anthropic/Gemini compatible response.",
+    );
   }
 }
+
+function resolveApiKey(config) {
+  if (config.apiKey) return config.apiKey;
+  if (config.apiKeyEnv) return process.env[config.apiKeyEnv] || "";
+
+  const envMap = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    gemini: "GEMINI_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    groq: "GROQ_API_KEY",
+    proxy: "PROXY_API_KEY",
+  };
+
+  const envName = envMap[config.provider];
+  return envName ? process.env[envName] || "" : "";
+}

package/src/cli/commands/auth.js

@@ -0,0 +1,253 @@
+import Enquirer from "enquirer";
+import chalk from "chalk";
+import { logger } from "../../core/logger.js";
+import { loadConfig, writeConfig } from "../../core/config.js";
+import { AI_PROVIDERS, AI_PROVIDER_DEFAULTS } from "../../core/constants.js";
+import { AIEngine } from "../../ai/ai-engine.js";
+
+export function registerAuthCommand(program) {
+  program
+    .command("auth")
+    .description("Configure AI provider for test generation")
+    .option("--test", "Test current AI configuration")
+    .option("--show", "Show current AI configuration")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runAuth);
+}
+
+async function runAuth(options) {
+  const projectDir = options.dir;
+  const { config, isEmpty } = await loadConfig(projectDir);
+
+  if (options.show) {
+    showCurrentConfig(config);
+    return;
+  }
+
+  if (options.test) {
+    await testConnection(config);
+    return;
+  }
+
+  await interactiveSetup(projectDir, config, isEmpty);
+}
+
+function showCurrentConfig(config) {
+  const ai = config.ai || {};
+  const engine = new AIEngine(ai);
+  const info = engine.getProviderInfo();
+
+  logger.header("QABot \u2014 AI Configuration");
+  logger.blank();
+  logger.table(
+    ["Setting", "Value"],
+    [
+      ["Provider", info.provider || "none"],
+      ["Model", info.model || "-"],
+      ["Base URL", info.baseUrl || "(default)"],
+      ["API Key", info.hasApiKey ? "\u2713 configured" : "\u2717 missing"],
+    ],
+  );
+  logger.blank();
+}
+
+async function testConnection(config) {
+  const ai = config.ai || {};
+  const engine = new AIEngine(ai);
+
+  if (!engine.isAvailable()) {
+    logger.error("AI is not configured. Run `qabot auth` to set up.");
+    return;
+  }
+
+  logger.info(`Testing connection to ${chalk.bold(engine.provider)}...`);
+
+  try {
+    const response = await engine.complete("Reply with exactly: QABOT_OK");
+    if (response.includes("QABOT_OK")) {
+      logger.success(
+        `Connection successful! Provider: ${engine.provider}, Model: ${engine.model}`,
+      );
+    } else {
+      logger.success(
+        `Got response from ${engine.provider} (model may not follow simple instructions exactly)`,
+      );
+      logger.dim(`Response: ${response.slice(0, 100)}`);
+    }
+  } catch (err) {
+    logger.error(`Connection failed: ${err.message}`);
+  }
+}
+
+async function interactiveSetup(projectDir, config, isEmpty) {
+  const enquirer = new Enquirer();
+
+  logger.header("QABot \u2014 AI Provider Setup");
+  logger.blank();
+
+  const providerChoices = [
+    { name: "openai", message: "OpenAI        (GPT-4o, GPT-4-turbo)" },
+    { name: "anthropic", message: "Anthropic     (Claude 4, Claude Sonnet)" },
+    { name: "gemini", message: "Google Gemini (Gemini 2.5 Flash/Pro)" },
+    { name: "deepseek", message: "DeepSeek      (DeepSeek-V3, DeepSeek-Chat)" },
+    { name: "groq", message: "Groq          (LLaMA 3.3, Mixtral)" },
+    { name: "ollama", message: "Ollama        (Local models, no API key)" },
+    {
+      name: "proxy",
+      message: "Custom Proxy  (Any OpenAI-compatible endpoint)",
+    },
+  ];
+
+  const { provider } = await enquirer.prompt({
+    type: "select",
+    name: "provider",
+    message: "Select AI provider",
+    choices: providerChoices,
+  });
+
+  const defaults = AI_PROVIDER_DEFAULTS[provider] || {};
+  const aiConfig = { provider };
+
+  if (provider === "proxy") {
+    const proxyAnswers = await enquirer.prompt([
+      {
+        type: "input",
+        name: "baseUrl",
+        message:
+          "Proxy URL (full endpoint, e.g. https://my-proxy.com/v1/chat/completions)",
+        validate: (v) =>
+          v.startsWith("http")
+            ? true
+            : "Must be a valid URL starting with http",
+      },
+      {
+        type: "input",
+        name: "apiKey",
+        message: "API Key (leave empty if not required)",
+      },
+      {
+        type: "input",
+        name: "model",
+        message: "Model name (leave empty for proxy default)",
+      },
+      {
+        type: "select",
+        name: "authMethod",
+        message: "Authentication method",
+        choices: [
+          {
+            name: "bearer",
+            message: "Bearer Token  (Authorization: Bearer <key>)",
+          },
+          { name: "x-api-key", message: "X-API-Key     (x-api-key: <key>)" },
+          { name: "custom", message: "Custom Header" },
+          { name: "none", message: "No Auth" },
+        ],
+      },
+    ]);
+
+    aiConfig.baseUrl = proxyAnswers.baseUrl;
+    if (proxyAnswers.model) aiConfig.model = proxyAnswers.model;
+
+    if (proxyAnswers.authMethod === "bearer") {
+      aiConfig.authHeader = "Authorization";
+      aiConfig.authPrefix = "Bearer ";
+    } else if (proxyAnswers.authMethod === "x-api-key") {
+      aiConfig.authHeader = "x-api-key";
+      aiConfig.authPrefix = "";
+    } else if (proxyAnswers.authMethod === "custom") {
+      const { customHeader } = await enquirer.prompt({
+        type: "input",
+        name: "customHeader",
+        message: "Custom header name (e.g. X-Custom-Auth)",
+      });
+      aiConfig.authHeader = customHeader;
+      aiConfig.authPrefix = "";
+    } else {
+      aiConfig.authHeader = null;
+    }
+
+    if (proxyAnswers.apiKey) {
+      aiConfig.apiKeyEnv = "PROXY_API_KEY";
+      logger.blank();
+      logger.warn("Store your API key as an environment variable:");
+      logger.dim(`  export PROXY_API_KEY="${proxyAnswers.apiKey}"`);
+      logger.dim("  Or add to .env file: PROXY_API_KEY=your-key");
+    }
+  } else if (provider === "ollama") {
+    const { baseUrl, model } = await enquirer.prompt([
+      {
+        type: "input",
+        name: "baseUrl",
+        message: "Ollama URL",
+        initial: defaults.baseUrl,
+      },
+      {
+        type: "input",
+        name: "model",
+        message: "Model name",
+        initial: defaults.model,
+      },
+    ]);
+    aiConfig.baseUrl = baseUrl;
+    aiConfig.model = model;
+  } else {
+    const envMap = {
+      openai: "OPENAI_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      gemini: "GEMINI_API_KEY",
+      deepseek: "DEEPSEEK_API_KEY",
+      groq: "GROQ_API_KEY",
+    };
+
+    const envName = envMap[provider];
+
+    const answers = await enquirer.prompt([
+      {
+        type: "input",
+        name: "model",
+        message: "Model name",
+        initial: defaults.model,
+      },
+      {
+        type: "password",
+        name: "apiKey",
+        message: `API Key (${envName})`,
+      },
+    ]);
+
+    aiConfig.model = answers.model;
+    aiConfig.apiKeyEnv = envName;
+
+    if (answers.apiKey) {
+      logger.blank();
+      logger.warn("Store your API key as an environment variable:");
+      logger.dim(`  export ${envName}="${answers.apiKey}"`);
+      logger.dim(`  Or add to .env file: ${envName}=your-key`);
+    }
+  }
+
+  config.ai = aiConfig;
+
+  if (isEmpty) {
+    logger.blank();
+    logger.warn(
+      "No qabot.config.js found. Run `qabot init` first, then `qabot auth`.",
+    );
+    logger.blank();
+    logger.info("Or manually add to qabot.config.js:");
+    logger.dim(`  ai: ${JSON.stringify(aiConfig, null, 4)}`);
+    return;
+  }
+
+  await writeConfig(projectDir, config);
+  logger.blank();
+  logger.success("AI configuration saved to qabot.config.js");
+  logger.blank();
+  logger.info("Test your setup:");
+  logger.dim("  qabot auth --test");
+  logger.blank();
+  logger.info("Generate tests:");
+  logger.dim("  qabot generate <feature>");
+  logger.blank();
+}

package/src/cli/commands/generate.js

@@ -33,9 +33,19 @@ async function runGenerate(feature, options) {
 
   const ai = new AIEngine(aiConfig);
   if (!ai.isAvailable()) {
-    logger.error("AI is not configured. Set your API key:");
-    logger.dim(`  export ${aiConfig.apiKeyEnv || "OPENAI_API_KEY"}=your-key`);
-    logger.dim("  Or update qabot.config.js ai.provider setting.");
+    logger.error("AI is not configured.");
+    logger.blank();
+    logger.info("Quick setup:");
+    logger.dim("  qabot auth                    # Interactive provider setup");
+    logger.blank();
+    logger.info("Or set manually:");
+    logger.dim(
+      "  export OPENAI_API_KEY=sk-...  # Then set ai.provider in qabot.config.js",
+    );
+    logger.blank();
+    logger.info(
+      "Supported: openai, anthropic, gemini, deepseek, groq, ollama, proxy",
+    );
     return;
   }
 

package/src/core/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.1.0";
+export const VERSION = "0.2.0";
 export const TOOL_NAME = "qabot";
 
 export const PROJECT_TYPES = [
@@ -20,7 +20,61 @@ export const RUNNERS = [
   "xunit",
   "dotnet-test",
 ];
-export const AI_PROVIDERS = ["openai", "anthropic", "ollama", "none"];
+export const AI_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "gemini",
+  "deepseek",
+  "groq",
+  "ollama",
+  "proxy",
+  "none",
+];
+
+export const AI_PROVIDER_DEFAULTS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-4o",
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+  },
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    model: "claude-sonnet-4-20250514",
+    authHeader: "x-api-key",
+    authPrefix: "",
+  },
+  gemini: {
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    model: "gemini-2.5-flash",
+    authHeader: "x-goog-api-key",
+    authPrefix: "",
+  },
+  deepseek: {
+    baseUrl: "https://api.deepseek.com/v1",
+    model: "deepseek-chat",
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+  },
+  groq: {
+    baseUrl: "https://api.groq.com/openai/v1",
+    model: "llama-3.3-70b-versatile",
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+  },
+  ollama: {
+    baseUrl: "http://localhost:11434",
+    model: "llama3",
+    authHeader: null,
+    authPrefix: "",
+  },
+  proxy: {
+    baseUrl: "",
+    model: "",
+    authHeader: "Authorization",
+    authPrefix: "Bearer ",
+  },
+};
 export const LAYERS = ["unit", "integration", "e2e"];
 export const PRIORITIES = ["P0", "P1", "P2", "P3"];
 
@@ -39,7 +93,14 @@ export const DEFAULT_CONFIG = {
     history: true,
     formats: ["html", "json"],
   },
-  ai: { provider: "none", model: "gpt-4o", apiKeyEnv: "OPENAI_API_KEY" },
+  ai: {
+    provider: "none",
+    model: "gpt-4o",
+    apiKeyEnv: "OPENAI_API_KEY",
+    baseUrl: null,
+    authHeader: null,
+    authPrefix: null,
+  },
   useCases: { dir: "./docs/use-cases", formats: ["md", "feature", "txt"] },
 };