kernelbot 1.0.23 → 1.0.25

package/bin/kernel.js

@@ -9,7 +9,7 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import chalk from 'chalk';
-import { loadConfig, loadConfigInteractive } from '../src/utils/config.js';
+import { loadConfig, loadConfigInteractive, changeBrainModel } from '../src/utils/config.js';
 import { createLogger, getLogger } from '../src/utils/logger.js';
 import {
   showLogo,
@@ -21,16 +21,23 @@ import { createAuditLogger } from '../src/security/audit.js';
 import { ConversationManager } from '../src/conversation.js';
 import { Agent } from '../src/agent.js';
 import { startBot } from '../src/bot.js';
-import Anthropic from '@anthropic-ai/sdk';
+import { createProvider, PROVIDERS } from '../src/providers/index.js';
 
-function showMenu() {
+function showMenu(config) {
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerName = providerDef ? providerDef.name : config.brain.provider;
+  const modelId = config.brain.model;
+
+  console.log('');
+  console.log(chalk.dim(`  Current brain: ${providerName} / ${modelId}`));
   console.log('');
   console.log(chalk.bold('  What would you like to do?\n'));
   console.log(`  ${chalk.cyan('1.')} Start bot`);
   console.log(`  ${chalk.cyan('2.')} Check connections`);
   console.log(`  ${chalk.cyan('3.')} View logs`);
   console.log(`  ${chalk.cyan('4.')} View audit logs`);
-  console.log(`  ${chalk.cyan('5.')} Exit`);
+  console.log(`  ${chalk.cyan('5.')} Change brain model`);
+  console.log(`  ${chalk.cyan('6.')} Exit`);
   console.log('');
 }
 
@@ -70,21 +77,21 @@ function viewLog(filename) {
 }
 
 async function runCheck(config) {
-  await showStartupCheck('ANTHROPIC_API_KEY', async () => {
-    if (!config.anthropic.api_key) throw new Error('Not set');
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerLabel = providerDef ? providerDef.name : config.brain.provider;
+  const envKeyLabel = providerDef ? providerDef.envKey : 'API_KEY';
+
+  await showStartupCheck(envKeyLabel, async () => {
+    if (!config.brain.api_key) throw new Error('Not set');
   });
 
   await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
     if (!config.telegram.bot_token) throw new Error('Not set');
   });
 
-  await showStartupCheck('Anthropic API connection', async () => {
-    const client = new Anthropic({ apiKey: config.anthropic.api_key });
-    await client.messages.create({
-      model: config.anthropic.model,
-      max_tokens: 16,
-      messages: [{ role: 'user', content: 'ping' }],
-    });
+  await showStartupCheck(`${providerLabel} API connection`, async () => {
+    const provider = createProvider(config);
+    await provider.ping();
   });
 
   await showStartupCheck('Telegram Bot API', async () => {
@@ -102,16 +109,15 @@ async function startBotFlow(config) {
   createAuditLogger();
   const logger = getLogger();
 
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerLabel = providerDef ? providerDef.name : config.brain.provider;
+
   const checks = [];
 
   checks.push(
-    await showStartupCheck('Anthropic API', async () => {
-      const client = new Anthropic({ apiKey: config.anthropic.api_key });
-      await client.messages.create({
-        model: config.anthropic.model,
-        max_tokens: 16,
-        messages: [{ role: 'user', content: 'ping' }],
-      });
+    await showStartupCheck(`${providerLabel} API`, async () => {
+      const provider = createProvider(config);
+      await provider.ping();
     }),
   );
 
@@ -148,7 +154,7 @@ async function main() {
 
   let running = true;
   while (running) {
-    showMenu();
+    showMenu(config);
     const choice = await ask(rl, chalk.cyan('  > '));
 
     switch (choice.trim()) {
@@ -168,6 +174,9 @@ async function main() {
         viewLog('kernel-audit.log');
         break;
       case '5':
+        await changeBrainModel(config, rl);
+        break;
+      case '6':
         running = false;
         break;
       default:

package/config.example.yaml

@@ -5,7 +5,8 @@ bot:
   name: KernelBot
   description: AI engineering agent with full OS control
 
-anthropic:
+brain:
+  provider: anthropic    # anthropic | openai | google | groq
   model: claude-sonnet-4-20250514
   max_tokens: 8192
   temperature: 0.3
@@ -20,6 +21,11 @@ github:
   default_branch: main
   # default_org: my-org
 
+jira:
+  # base_url: https://yourcompany.atlassian.net  # or self-hosted JIRA server URL
+  # email: you@company.com                       # JIRA account email (Cloud) or username (Server)
+  # api_token: your-api-token                    # API token from https://id.atlassian.net/manage-profile/security/api-tokens
+
 telegram:
   # List Telegram user IDs allowed to interact. Empty = allow all (dev mode).
   allowed_users: []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -15,6 +15,9 @@
     "agent",
     "telegram",
     "anthropic",
+    "openai",
+    "gemini",
+    "groq",
     "tools"
   ],
   "repository": {
@@ -24,7 +27,7 @@
   "bugs": {
     "url": "https://github.com/KernelCode/KernelBot/issues"
   },
-  "homepage": "https://github.com/KernelCode/KernelBot#readme",
+  "homepage": "https://kernelbot.io",
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
@@ -37,6 +40,7 @@
     "gradient-string": "^3.0.0",
     "js-yaml": "^4.1.0",
     "node-telegram-bot-api": "^0.66.0",
+    "openai": "^4.82.0",
     "ora": "^8.1.1",
     "puppeteer": "^24.37.3",
     "simple-git": "^3.31.1",

package/src/agent.js

@@ -1,4 +1,4 @@
-import Anthropic from '@anthropic-ai/sdk';
+import { createProvider } from './providers/index.js';
 import { toolDefinitions, executeTool, checkConfirmation } from './tools/index.js';
 import { getSystemPrompt } from './prompts/system.js';
 import { getLogger } from './utils/logger.js';
@@ -8,7 +8,7 @@ export class Agent {
   constructor({ config, conversationManager }) {
     this.config = config;
     this.conversationManager = conversationManager;
-    this.client = new Anthropic({ apiKey: config.anthropic.api_key });
+    this.provider = createProvider(config);
     this.systemPrompt = getSystemPrompt(config);
     this._pending = new Map(); // chatId -> pending state
   }
@@ -33,7 +33,7 @@ export class Agent {
       }
     }
 
-    const { max_tool_depth } = this.config.anthropic;
+    const { max_tool_depth } = this.config.brain;
 
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
@@ -160,7 +160,7 @@ export class Agent {
     }
 
     pending.messages.push({ role: 'user', content: pending.toolResults });
-    const { max_tool_depth } = this.config.anthropic;
+    const { max_tool_depth } = this.config.brain;
     return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth);
   }
 
@@ -203,56 +203,44 @@ export class Agent {
 
   async _runLoop(chatId, messages, user, startDepth, maxDepth) {
     const logger = getLogger();
-    const { model, max_tokens, temperature } = this.config.anthropic;
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.debug(`Agent loop iteration ${depth + 1}/${maxDepth}`);
 
-      const response = await this.client.messages.create({
-        model,
-        max_tokens,
-        temperature,
+      const response = await this.provider.chat({
         system: this.systemPrompt,
-        tools: toolDefinitions,
         messages,
+        tools: toolDefinitions,
       });
 
-      if (response.stop_reason === 'end_turn') {
-        const textBlocks = response.content
-          .filter((b) => b.type === 'text')
-          .map((b) => b.text);
-        const reply = textBlocks.join('\n');
-
+      if (response.stopReason === 'end_turn') {
+        const reply = response.text || '';
         this.conversationManager.addMessage(chatId, 'assistant', reply);
         return reply;
       }
 
-      if (response.stop_reason === 'tool_use') {
-        messages.push({ role: 'assistant', content: response.content });
+      if (response.stopReason === 'tool_use') {
+        messages.push({ role: 'assistant', content: response.rawContent });
 
-        // Send Claude's thinking text to the user
-        const thinkingBlocks = response.content.filter((b) => b.type === 'text' && b.text.trim());
-        if (thinkingBlocks.length > 0) {
-          const thinking = thinkingBlocks.map((b) => b.text).join('\n');
-          logger.info(`Agent thinking: ${thinking.slice(0, 200)}`);
-          await this._sendUpdate(`💭 ${thinking}`);
+        // Send thinking text to the user
+        if (response.text && response.text.trim()) {
+          logger.info(`Agent thinking: ${response.text.slice(0, 200)}`);
+          await this._sendUpdate(`💭 ${response.text}`);
         }
 
-        const toolUseBlocks = response.content.filter((b) => b.type === 'tool_use');
         const toolResults = [];
 
-        for (let i = 0; i < toolUseBlocks.length; i++) {
-          const block = toolUseBlocks[i];
+        for (let i = 0; i < response.toolCalls.length; i++) {
+          const block = response.toolCalls[i];
+
+          // Build a block-like object for _checkPause (needs .type for remainingBlocks filter)
+          const blockObj = { type: 'tool_use', id: block.id, name: block.name, input: block.input };
 
           // Check if we need to pause (missing cred or dangerous action)
-          const pauseMsg = this._checkPause(
-            chatId,
-            block,
-            user,
-            toolResults,
-            toolUseBlocks.slice(i + 1),
-            messages,
-          );
+          const remaining = response.toolCalls.slice(i + 1).map((tc) => ({
+            type: 'tool_use', id: tc.id, name: tc.name, input: tc.input,
+          }));
+          const pauseMsg = this._checkPause(chatId, blockObj, user, toolResults, remaining, messages);
           if (pauseMsg) return pauseMsg;
 
           const summary = this._formatToolSummary(block.name, block.input);
@@ -278,14 +266,10 @@ export class Agent {
       }
 
       // Unexpected stop reason
-      logger.warn(`Unexpected stop_reason: ${response.stop_reason}`);
-      const fallbackText = response.content
-        .filter((b) => b.type === 'text')
-        .map((b) => b.text)
-        .join('\n');
-      if (fallbackText) {
-        this.conversationManager.addMessage(chatId, 'assistant', fallbackText);
-        return fallbackText;
+      logger.warn(`Unexpected stopReason: ${response.stopReason}`);
+      if (response.text) {
+        this.conversationManager.addMessage(chatId, 'assistant', response.text);
+        return response.text;
       }
       return 'Something went wrong — unexpected response from the model.';
     }

package/src/providers/anthropic.js

@@ -0,0 +1,44 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { BaseProvider } from './base.js';
+
+export class AnthropicProvider extends BaseProvider {
+  constructor(opts) {
+    super(opts);
+    this.client = new Anthropic({ apiKey: this.apiKey });
+  }
+
+  async chat({ system, messages, tools }) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      system,
+      tools,
+      messages,
+    });
+
+    const stopReason = response.stop_reason === 'end_turn' ? 'end_turn' : 'tool_use';
+
+    const textBlocks = response.content.filter((b) => b.type === 'text');
+    const text = textBlocks.map((b) => b.text).join('\n');
+
+    const toolCalls = response.content
+      .filter((b) => b.type === 'tool_use')
+      .map((b) => ({ id: b.id, name: b.name, input: b.input }));
+
+    return {
+      stopReason,
+      text,
+      toolCalls,
+      rawContent: response.content,
+    };
+  }
+
+  async ping() {
+    await this.client.messages.create({
+      model: this.model,
+      max_tokens: 16,
+      messages: [{ role: 'user', content: 'ping' }],
+    });
+  }
+}

package/src/providers/base.js

@@ -0,0 +1,30 @@
+/**
+ * Abstract provider interface.
+ * Every provider must implement chat() and ping().
+ */
+
+export class BaseProvider {
+  constructor({ model, maxTokens, temperature, apiKey }) {
+    this.model = model;
+    this.maxTokens = maxTokens;
+    this.temperature = temperature;
+    this.apiKey = apiKey;
+  }
+
+  /**
+   * Send a chat completion request.
+   * @param {object} opts
+   * @param {string} opts.system - System prompt
+   * @param {Array} opts.messages - Anthropic-format messages
+   * @param {Array} opts.tools - Anthropic-format tool definitions
+   * @returns {Promise<{stopReason: 'end_turn'|'tool_use', text: string, toolCalls: Array<{id,name,input}>, rawContent: Array}>}
+   */
+  async chat({ system, messages, tools }) {
+    throw new Error('chat() not implemented');
+  }
+
+  /** Quick connectivity test — throws on failure. */
+  async ping() {
+    throw new Error('ping() not implemented');
+  }
+}

package/src/providers/index.js

@@ -0,0 +1,36 @@
+import { AnthropicProvider } from './anthropic.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { PROVIDERS } from './models.js';
+
+export { PROVIDERS } from './models.js';
+
+/**
+ * Create the right provider based on config.brain.
+ * @param {object} config - Full app config (must have config.brain)
+ * @returns {BaseProvider}
+ */
+export function createProvider(config) {
+  const { provider, model, max_tokens, temperature, api_key } = config.brain;
+
+  const providerDef = PROVIDERS[provider];
+  if (!providerDef) {
+    throw new Error(`Unknown provider: ${provider}. Valid: ${Object.keys(PROVIDERS).join(', ')}`);
+  }
+
+  const opts = {
+    model,
+    maxTokens: max_tokens,
+    temperature,
+    apiKey: api_key,
+  };
+
+  if (provider === 'anthropic') {
+    return new AnthropicProvider(opts);
+  }
+
+  // OpenAI, Google, Groq — all use OpenAI-compatible API
+  return new OpenAICompatProvider({
+    ...opts,
+    baseUrl: providerDef.baseUrl || undefined,
+  });
+}

package/src/providers/models.js

@@ -0,0 +1,54 @@
+/**
+ * Provider & model catalog — single source of truth.
+ */
+
+export const PROVIDERS = {
+  anthropic: {
+    name: 'Anthropic (Claude)',
+    envKey: 'ANTHROPIC_API_KEY',
+    models: [
+      { id: 'claude-sonnet-4-20250514', label: 'Claude Sonnet 4' },
+      { id: 'claude-opus-4-20250514', label: 'Claude Opus 4' },
+      { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5' },
+    ],
+  },
+  openai: {
+    name: 'OpenAI (GPT)',
+    envKey: 'OPENAI_API_KEY',
+    models: [
+      { id: 'gpt-4o', label: 'GPT-4o' },
+      { id: 'gpt-4o-mini', label: 'GPT-4o Mini' },
+      { id: 'o1', label: 'o1' },
+      { id: 'o3-mini', label: 'o3-mini' },
+    ],
+  },
+  google: {
+    name: 'Google (Gemini)',
+    envKey: 'GOOGLE_API_KEY',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    models: [
+      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
+      { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    ],
+  },
+  groq: {
+    name: 'Groq',
+    envKey: 'GROQ_API_KEY',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    models: [
+      { id: 'llama-3.3-70b-versatile', label: 'Llama 3.3 70B' },
+      { id: 'llama-3.1-8b-instant', label: 'Llama 3.1 8B' },
+      { id: 'mixtral-8x7b-32768', label: 'Mixtral 8x7B' },
+    ],
+  },
+};
+
+/** Models that don't support system prompts or temperature (reasoning models). */
+export const REASONING_MODELS = new Set(['o1', 'o3-mini']);
+
+export function getProviderForModel(modelId) {
+  for (const [key, provider] of Object.entries(PROVIDERS)) {
+    if (provider.models.some((m) => m.id === modelId)) return key;
+  }
+  return null;
+}

package/src/providers/openai-compat.js

@@ -0,0 +1,163 @@
+import OpenAI from 'openai';
+import { BaseProvider } from './base.js';
+import { REASONING_MODELS } from './models.js';
+
+/**
+ * OpenAI-compatible provider — works with OpenAI, Groq, and Google Gemini
+ * via configurable baseURL.
+ */
+export class OpenAICompatProvider extends BaseProvider {
+  constructor(opts) {
+    super(opts);
+    this.client = new OpenAI({
+      apiKey: this.apiKey,
+      ...(opts.baseUrl && { baseURL: opts.baseUrl }),
+    });
+    this.isReasoningModel = REASONING_MODELS.has(this.model);
+  }
+
+  // ── Format conversion helpers ──
+
+  /** Anthropic tool defs → OpenAI function tool defs */
+  _convertTools(tools) {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map((t) => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema,
+      },
+    }));
+  }
+
+  /** Anthropic messages → OpenAI messages */
+  _convertMessages(system, messages) {
+    const out = [];
+
+    // System prompt as first message (skip for reasoning models)
+    if (system && !this.isReasoningModel) {
+      const systemText = Array.isArray(system)
+        ? system.map((b) => b.text).join('\n')
+        : system;
+      out.push({ role: 'system', content: systemText });
+    }
+
+    for (const msg of messages) {
+      if (msg.role === 'user') {
+        // Could be a string, content blocks, or tool_result array
+        if (typeof msg.content === 'string') {
+          out.push({ role: 'user', content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          // Check if it's tool results
+          if (msg.content[0]?.type === 'tool_result') {
+            for (const tr of msg.content) {
+              out.push({
+                role: 'tool',
+                tool_call_id: tr.tool_use_id,
+                content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content),
+              });
+            }
+          } else {
+            // Text content blocks
+            const text = msg.content
+              .filter((b) => b.type === 'text')
+              .map((b) => b.text)
+              .join('\n');
+            out.push({ role: 'user', content: text || '' });
+          }
+        }
+      } else if (msg.role === 'assistant') {
+        // Convert Anthropic content blocks → OpenAI format
+        if (typeof msg.content === 'string') {
+          out.push({ role: 'assistant', content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter((b) => b.type === 'text');
+          const toolParts = msg.content.filter((b) => b.type === 'tool_use');
+
+          const assistantMsg = {
+            role: 'assistant',
+            content: textParts.map((b) => b.text).join('\n') || null,
+          };
+
+          if (toolParts.length > 0) {
+            assistantMsg.tool_calls = toolParts.map((b) => ({
+              id: b.id,
+              type: 'function',
+              function: {
+                name: b.name,
+                arguments: JSON.stringify(b.input),
+              },
+            }));
+          }
+
+          out.push(assistantMsg);
+        }
+      }
+    }
+
+    return out;
+  }
+
+  /** OpenAI response → normalized format with rawContent in Anthropic format */
+  _normalizeResponse(response) {
+    const choice = response.choices[0];
+    const finishReason = choice.finish_reason;
+
+    const stopReason = finishReason === 'tool_calls' ? 'tool_use' : 'end_turn';
+
+    const text = choice.message.content || '';
+
+    const toolCalls = (choice.message.tool_calls || []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      input: JSON.parse(tc.function.arguments),
+    }));
+
+    // Build rawContent in Anthropic format for message history consistency
+    const rawContent = [];
+    if (text) {
+      rawContent.push({ type: 'text', text });
+    }
+    for (const tc of toolCalls) {
+      rawContent.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
+    }
+
+    return { stopReason, text, toolCalls, rawContent };
+  }
+
+  // ── Public API ──
+
+  async chat({ system, messages, tools }) {
+    const params = {
+      model: this.model,
+      messages: this._convertMessages(system, messages),
+    };
+
+    if (!this.isReasoningModel) {
+      params.temperature = this.temperature;
+    }
+
+    params.max_tokens = this.maxTokens;
+
+    const convertedTools = this._convertTools(tools);
+    if (convertedTools) {
+      params.tools = convertedTools;
+    }
+
+    const response = await this.client.chat.completions.create(params);
+    return this._normalizeResponse(response);
+  }
+
+  async ping() {
+    const params = {
+      model: this.model,
+      max_tokens: 16,
+      messages: [{ role: 'user', content: 'ping' }],
+    };
+    if (!this.isReasoningModel) {
+      params.temperature = 0;
+    }
+    await this.client.chat.completions.create(params);
+  }
+}

package/src/tools/index.js

@@ -7,6 +7,7 @@ import { definitions as gitDefinitions, handlers as gitHandlers } from './git.js
 import { definitions as githubDefinitions, handlers as githubHandlers } from './github.js';
 import { definitions as codingDefinitions, handlers as codingHandlers } from './coding.js';
 import { definitions as browserDefinitions, handlers as browserHandlers } from './browser.js';
+import { definitions as jiraDefinitions, handlers as jiraHandlers } from './jira.js';
 import { logToolCall } from '../security/audit.js';
 import { requiresConfirmation } from '../security/confirm.js';
 
@@ -20,6 +21,7 @@ export const toolDefinitions = [
   ...githubDefinitions,
   ...codingDefinitions,
   ...browserDefinitions,
+  ...jiraDefinitions,
 ];
 
 const handlerMap = {
@@ -32,6 +34,7 @@ const handlerMap = {
   ...githubHandlers,
   ...codingHandlers,
   ...browserHandlers,
+  ...jiraHandlers,
 };
 
 export function checkConfirmation(name, params, config) {