kernelbot 1.0.24 → 1.0.26

package/src/conversation.js

@@ -11,6 +11,7 @@ function getConversationsPath() {
 export class ConversationManager {
   constructor(config) {
     this.maxHistory = config.conversation.max_history;
+    this.recentWindow = config.conversation.recent_window || 10;
     this.conversations = new Map();
     this.filePath = getConversationsPath();
   }
@@ -49,6 +50,41 @@ export class ConversationManager {
     return this.conversations.get(key);
   }
 
+  /**
+   * Get history with older messages compressed into a summary.
+   * Keeps the last `recentWindow` messages verbatim and summarizes older ones.
+   */
+  getSummarizedHistory(chatId) {
+    const history = this.getHistory(chatId);
+
+    if (history.length <= this.recentWindow) {
+      return [...history];
+    }
+
+    const olderMessages = history.slice(0, history.length - this.recentWindow);
+    const recentMessages = history.slice(history.length - this.recentWindow);
+
+    // Compress older messages into a single summary
+    const summaryLines = olderMessages.map((msg) => {
+      const content = typeof msg.content === 'string'
+        ? msg.content.slice(0, 200)
+        : JSON.stringify(msg.content).slice(0, 200);
+      return `[${msg.role}]: ${content}`;
+    });
+
+    const summaryMessage = {
+      role: 'user',
+      content: `[CONVERSATION SUMMARY - ${olderMessages.length} earlier messages]\n${summaryLines.join('\n')}`,
+    };
+
+    // Ensure result starts with user role
+    const result = [summaryMessage, ...recentMessages];
+
+    // If the first real message after summary is assistant, that's fine since
+    // our summary is role:user. But ensure recent starts correctly.
+    return result;
+  }
+
   addMessage(chatId, role, content) {
     const history = this.getHistory(chatId);
     history.push({ role, content });

package/src/prompts/system.js

@@ -1,46 +1,32 @@
-import { toolDefinitions } from '../tools/index.js';
-
 export function getSystemPrompt(config) {
-  const toolList = toolDefinitions.map((t) => `- ${t.name}: ${t.description}`).join('\n');
-
-  return `You are ${config.bot.name}, a senior software engineer and sysadmin AI agent.
-You talk to the user via Telegram. You are confident, concise, and effective.
-
-You have full access to the operating system through your tools:
-${toolList}
-
-## Coding Tasks (writing code, fixing bugs, reviewing code, scaffolding projects)
-IMPORTANT: You MUST NOT write code yourself using read_file/write_file. ALWAYS delegate coding to Claude Code.
-1. Use git tools to clone the repo and create a branch
-2. Use spawn_claude_code to do the actual coding work inside the repo — give it a clear, detailed prompt describing exactly what to build or fix
-3. After Claude Code finishes, use git tools to commit and push
-4. Use GitHub tools to create the PR
-5. Report back with the PR link
-
-## Web Browsing Tasks (researching, scraping, reading documentation, taking screenshots)
-- Use browse_website to read and summarize web pages
-- Use screenshot_website to capture visual snapshots of pages — the screenshot is automatically sent to the chat
-- Use extract_content to pull specific data from pages using CSS selectors
-- Use interact_with_page for pages that need clicking, typing, or scrolling to reveal content
-- Use send_image to send any image file directly to the Telegram chat (screenshots, generated images, etc.)
-- When a user sends /browse <url>, use browse_website on that URL
-- When a user sends /screenshot <url>, use screenshot_website on that URL
-- When a user sends /extract <url> <selector>, use extract_content with that URL and selector
-
-You are the orchestrator. Claude Code is the coder. Never use read_file + write_file to modify source code — that's Claude Code's job. You handle git, GitHub, and infrastructure. Claude Code handles all code changes.
-
-
-## Non-Coding Tasks (monitoring, deploying, restarting services, checking status)
-- Use OS, Docker, process, network, and monitoring tools directly
-- No need to spawn Claude Code for these
+  return `You are ${config.bot.name}, a senior software engineer and sysadmin AI agent on Telegram. Be concise — this is chat, not documentation.
+
+## Coding Tasks
+NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
+1. Clone repo + create branch (git tools)
+2. spawn_claude_code with a clear, detailed prompt
+3. Commit + push (git tools)
+4. Create PR (GitHub tools) and report the link
+
+## Web Browsing
+- browse_website: read/summarize pages
+- screenshot_website: visual snapshots (auto-sent to chat)
+- extract_content: pull data via CSS selectors
+- interact_with_page: click/type/scroll on pages
+- send_image: send any image file to chat
+
+## Non-Coding Tasks
+Use OS, Docker, process, network, and monitoring tools directly. No need for Claude Code.
+
+## Efficiency Rules
+- Chain shell commands with && in execute_command instead of multiple calls
+- Read multiple files with one execute_command("cat file1 file2") instead of multiple read_file calls
+- Plan first, gather info in one step, then act
+- Keep responses under 500 words unless asked for details
 
 ## Guidelines
-- Use tools proactively to complete tasks. Don't just describe what you would do — do it.
-- When a task requires multiple steps, execute them in sequence using tools.
-- If a command fails, analyze the error and try an alternative approach.
-- Be concise — you're talking on Telegram, not writing essays.
-- For destructive operations (rm, kill, service stop, force push), confirm with the user first.
-- Never expose API keys, tokens, or secrets in your responses.
-- If a task will take a while, tell the user upfront.
-- If something fails, explain what went wrong and suggest a fix.`;
+- Use tools proactively — don't describe what you'd do, just do it.
+- If a command fails, analyze and try an alternative.
+- For destructive ops (rm, kill, force push), confirm with the user first.
+- Never expose secrets in responses.`;
 }

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/categories.js

@@ -0,0 +1,101 @@
+/**
+ * Smart tool filtering — send only relevant tools per request to save tokens.
+ */
+
+export const TOOL_CATEGORIES = {
+  core: ['execute_command', 'read_file', 'write_file', 'list_directory'],
+  git: ['git_clone', 'git_checkout', 'git_commit', 'git_push', 'git_diff'],
+  github: ['github_create_pr', 'github_get_pr_diff', 'github_post_review', 'github_create_repo', 'github_list_prs'],
+  coding: ['spawn_claude_code'],
+  docker: ['docker_ps', 'docker_logs', 'docker_exec', 'docker_compose'],
+  process: ['process_list', 'kill_process', 'service_control'],
+  monitor: ['disk_usage', 'memory_usage', 'cpu_usage', 'system_logs'],
+  network: ['check_port', 'curl_url', 'nginx_reload'],
+  browser: ['browse_website', 'screenshot_website', 'extract_content', 'send_image', 'interact_with_page'],
+  jira: ['jira_get_ticket', 'jira_search_tickets', 'jira_list_my_tickets', 'jira_get_project_tickets'],
+};
+
+const CATEGORY_KEYWORDS = {
+  coding: ['code', 'fix', 'bug', 'implement', 'refactor', 'build', 'feature', 'develop', 'program', 'write code', 'add feature', 'change', 'update', 'modify', 'create app', 'scaffold', 'debug', 'patch', 'review'],
+  git: ['git', 'commit', 'branch', 'merge', 'clone', 'pull', 'push', 'diff', 'stash', 'rebase', 'checkout', 'repo'],
+  github: ['pr', 'pull request', 'github', 'review', 'merge request'],
+  docker: ['docker', 'container', 'compose', 'image', 'kubernetes', 'k8s'],
+  process: ['process', 'kill', 'restart', 'service', 'daemon', 'systemctl', 'pid'],
+  monitor: ['disk', 'memory', 'cpu', 'usage', 'monitor', 'logs', 'status', 'health', 'space'],
+  network: ['port', 'curl', 'http', 'nginx', 'network', 'api', 'endpoint', 'request', 'url', 'fetch'],
+  browser: ['browse', 'screenshot', 'scrape', 'website', 'web page', 'webpage', 'extract content', 'html', 'css selector'],
+  jira: ['jira', 'ticket', 'issue', 'sprint', 'backlog', 'story', 'epic'],
+};
+
+// Categories that imply other categories
+const CATEGORY_DEPS = {
+  coding: ['git', 'github'],
+  github: ['git'],
+};
+
+/**
+ * Select relevant tools for a user message based on keyword matching.
+ * Always includes 'core' tools. Falls back to ALL tools if nothing specific matched.
+ */
+export function selectToolsForMessage(userMessage, allTools) {
+  const lower = userMessage.toLowerCase();
+  const matched = new Set(['core']);
+
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw)) {
+        matched.add(category);
+        // Add dependencies
+        const deps = CATEGORY_DEPS[category];
+        if (deps) deps.forEach((d) => matched.add(d));
+        break;
+      }
+    }
+  }
+
+  // Fallback: if only core matched, the request is ambiguous — send all tools
+  if (matched.size === 1) {
+    return allTools;
+  }
+
+  // Build the filtered tool name set
+  const toolNames = new Set();
+  for (const cat of matched) {
+    const names = TOOL_CATEGORIES[cat];
+    if (names) names.forEach((n) => toolNames.add(n));
+  }
+
+  return allTools.filter((t) => toolNames.has(t.name));
+}
+
+/**
+ * After a tool is used, expand the tool set to include related categories
+ * so the model can use follow-up tools it might need.
+ */
+export function expandToolsForUsed(usedToolNames, currentTools, allTools) {
+  const currentNames = new Set(currentTools.map((t) => t.name));
+  const needed = new Set();
+
+  for (const name of usedToolNames) {
+    // Find which category this tool belongs to
+    for (const [cat, tools] of Object.entries(TOOL_CATEGORIES)) {
+      if (tools.includes(name)) {
+        // Add deps for that category
+        const deps = CATEGORY_DEPS[cat];
+        if (deps) {
+          for (const dep of deps) {
+            for (const t of TOOL_CATEGORIES[dep]) {
+              if (!currentNames.has(t)) needed.add(t);
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  if (needed.size === 0) return currentTools;
+
+  const extra = allTools.filter((t) => needed.has(t.name));
+  return [...currentTools, ...extra];
+}