kernelbot 1.0.25 → 1.0.28

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', 'update_user_persona'],
+  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: ['web_search', '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: ['search', 'find', 'look up', '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];
+}

package/src/tools/index.js

@@ -8,6 +8,7 @@ import { definitions as githubDefinitions, handlers as githubHandlers } from './
 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 { definitions as personaDefinitions, handlers as personaHandlers } from './persona.js';
 import { logToolCall } from '../security/audit.js';
 import { requiresConfirmation } from '../security/confirm.js';
 
@@ -22,6 +23,7 @@ export const toolDefinitions = [
   ...codingDefinitions,
   ...browserDefinitions,
   ...jiraDefinitions,
+  ...personaDefinitions,
 ];
 
 const handlerMap = {
@@ -35,6 +37,7 @@ const handlerMap = {
   ...codingHandlers,
   ...browserHandlers,
   ...jiraHandlers,
+  ...personaHandlers,
 };
 
 export function checkConfirmation(name, params, config) {

package/src/tools/orchestrator-tools.js

@@ -0,0 +1,371 @@
+import { WORKER_TYPES, getToolsForWorker, getToolNamesForWorkerType } from '../swarm/worker-registry.js';
+import { getMissingCredential } from '../utils/config.js';
+import { getLogger } from '../utils/logger.js';
+
+const workerTypeEnum = Object.keys(WORKER_TYPES);
+
+/**
+ * Tool definitions for the orchestrator's 3 meta-tools.
+ */
+export const orchestratorToolDefinitions = [
+  {
+    name: 'dispatch_task',
+    description: `Dispatch a task to a specialized background worker. Available worker types: ${workerTypeEnum.join(', ')}. The worker runs in the background and you'll be notified when it completes.`,
+    input_schema: {
+      type: 'object',
+      properties: {
+        worker_type: {
+          type: 'string',
+          enum: workerTypeEnum,
+          description: 'The type of worker to dispatch the task to.',
+        },
+        task: {
+          type: 'string',
+          description: 'A clear, detailed description of what the worker should do.',
+        },
+      },
+      required: ['worker_type', 'task'],
+    },
+  },
+  {
+    name: 'list_jobs',
+    description: 'List all jobs for the current chat with their status, type, and summary.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'cancel_job',
+    description: 'Cancel a running or queued job by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        job_id: {
+          type: 'string',
+          description: 'The ID of the job to cancel.',
+        },
+      },
+      required: ['job_id'],
+    },
+  },
+  {
+    name: 'create_automation',
+    description: 'Create a recurring automation that runs on a schedule. The task description will be executed as a standalone prompt each time it fires.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Short name for the automation (e.g. "Server Health Check").',
+        },
+        description: {
+          type: 'string',
+          description: 'Detailed task prompt that will be executed each time. Must be standalone and self-contained.',
+        },
+        schedule_type: {
+          type: 'string',
+          enum: ['cron', 'interval', 'random'],
+          description: 'Schedule type: cron (fixed times), interval (every N minutes), random (human-like random intervals).',
+        },
+        cron_expression: {
+          type: 'string',
+          description: 'Cron expression for schedule_type=cron (e.g. "0 9 * * *" for 9am daily). 5 fields: minute hour dayOfMonth month dayOfWeek.',
+        },
+        interval_minutes: {
+          type: 'number',
+          description: 'Interval in minutes for schedule_type=interval (minimum 5).',
+        },
+        min_minutes: {
+          type: 'number',
+          description: 'Minimum interval in minutes for schedule_type=random.',
+        },
+        max_minutes: {
+          type: 'number',
+          description: 'Maximum interval in minutes for schedule_type=random.',
+        },
+      },
+      required: ['name', 'description', 'schedule_type'],
+    },
+  },
+  {
+    name: 'list_automations',
+    description: 'List all automations for the current chat with their status, schedule, and next run time.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'update_automation',
+    description: 'Update an existing automation — change its name, description, schedule, or enable/disable it.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        automation_id: {
+          type: 'string',
+          description: 'The ID of the automation to update.',
+        },
+        enabled: {
+          type: 'boolean',
+          description: 'Enable or disable the automation.',
+        },
+        name: {
+          type: 'string',
+          description: 'New name for the automation.',
+        },
+        description: {
+          type: 'string',
+          description: 'New task prompt for the automation.',
+        },
+        schedule_type: {
+          type: 'string',
+          enum: ['cron', 'interval', 'random'],
+          description: 'New schedule type.',
+        },
+        cron_expression: { type: 'string' },
+        interval_minutes: { type: 'number' },
+        min_minutes: { type: 'number' },
+        max_minutes: { type: 'number' },
+      },
+      required: ['automation_id'],
+    },
+  },
+  {
+    name: 'delete_automation',
+    description: 'Permanently delete an automation by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        automation_id: {
+          type: 'string',
+          description: 'The ID of the automation to delete.',
+        },
+      },
+      required: ['automation_id'],
+    },
+  },
+];
+
+/**
+ * Execute an orchestrator meta-tool.
+ * The dispatch_task handler is async and fire-and-forget — it returns immediately.
+ *
+ * @param {string} name - Tool name
+ * @param {object} input - Tool input
+ * @param {object} context - { chatId, jobManager, config, spawnWorker }
+ * @returns {object} Tool result
+ */
+export async function executeOrchestratorTool(name, input, context) {
+  const logger = getLogger();
+  const { chatId, jobManager, config, spawnWorker, automationManager } = context;
+
+  switch (name) {
+    case 'dispatch_task': {
+      const { worker_type, task } = input;
+      logger.info(`[dispatch_task] Request: type=${worker_type}, task="${task.slice(0, 120)}"`);
+
+      // Validate worker type
+      if (!WORKER_TYPES[worker_type]) {
+        logger.warn(`[dispatch_task] Invalid worker type: ${worker_type}`);
+        return { error: `Unknown worker type: ${worker_type}. Valid: ${workerTypeEnum.join(', ')}` };
+      }
+
+      // Check concurrent job limit
+      const running = jobManager.getRunningJobsForChat(chatId);
+      const maxConcurrent = config.swarm?.max_concurrent_jobs || 3;
+      logger.debug(`[dispatch_task] Running jobs: ${running.length}/${maxConcurrent} for chat ${chatId}`);
+      if (running.length >= maxConcurrent) {
+        logger.warn(`[dispatch_task] Rejected — concurrent limit reached: ${running.length}/${maxConcurrent} jobs for chat ${chatId}`);
+        return { error: `Maximum concurrent jobs (${maxConcurrent}) reached. Wait for a job to finish or cancel one.` };
+      }
+
+      // Pre-check credentials for the worker's tools
+      const toolNames = getToolNamesForWorkerType(worker_type);
+      for (const toolName of toolNames) {
+        const missing = getMissingCredential(toolName, config);
+        if (missing) {
+          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${missing.envKey}`);
+          return {
+            error: `Missing credential for ${worker_type} worker: ${missing.label} (${missing.envKey}). Ask the user to provide it.`,
+          };
+        }
+      }
+
+      // Create and spawn the job
+      const job = jobManager.createJob(chatId, worker_type, task);
+      const workerConfig = WORKER_TYPES[worker_type];
+
+      logger.info(`[dispatch_task] Dispatching job ${job.id} — ${workerConfig.emoji} ${workerConfig.label}: "${task.slice(0, 100)}"`);
+
+      // Fire and forget — spawnWorker handles lifecycle
+      spawnWorker(job).catch((err) => {
+        logger.error(`[dispatch_task] Worker spawn error for job ${job.id}: ${err.message}`);
+        if (!job.isTerminal) {
+          jobManager.failJob(job.id, err.message);
+        }
+      });
+
+      return {
+        job_id: job.id,
+        worker_type,
+        status: 'dispatched',
+        message: `${workerConfig.emoji} ${workerConfig.label} started.`,
+      };
+    }
+
+    case 'list_jobs': {
+      const jobs = jobManager.getJobsForChat(chatId);
+      logger.info(`[list_jobs] Chat ${chatId} — ${jobs.length} jobs found`);
+      if (jobs.length > 0) {
+        logger.debug(`[list_jobs] Jobs: ${jobs.slice(0, 5).map(j => `${j.id}[${j.status}]`).join(', ')}${jobs.length > 5 ? '...' : ''}`);
+      }
+      if (jobs.length === 0) {
+        return { message: 'No jobs for this chat.' };
+      }
+      return {
+        jobs: jobs.slice(0, 20).map((j) => ({
+          id: j.id,
+          worker_type: j.workerType,
+          status: j.status,
+          task: j.task.slice(0, 100),
+          duration: j.duration,
+          summary: j.toSummary(),
+        })),
+      };
+    }
+
+    case 'cancel_job': {
+      const { job_id } = input;
+      logger.info(`[cancel_job] Request to cancel job ${job_id} in chat ${chatId}`);
+      const job = jobManager.cancelJob(job_id);
+      if (!job) {
+        logger.warn(`[cancel_job] Job ${job_id} not found or already finished`);
+        return { error: `Job ${job_id} not found or already finished.` };
+      }
+      logger.info(`[cancel_job] Successfully cancelled job ${job_id} [${job.workerType}]`);
+      return {
+        job_id: job.id,
+        status: 'cancelled',
+        message: `Cancelled ${WORKER_TYPES[job.workerType]?.emoji || ''} ${job.workerType} worker.`,
+      };
+    }
+
+    case 'create_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { name: autoName, description, schedule_type, cron_expression, interval_minutes, min_minutes, max_minutes } = input;
+      logger.info(`[create_automation] Request: name="${autoName}", type=${schedule_type}`);
+
+      let schedule;
+      switch (schedule_type) {
+        case 'cron':
+          schedule = { type: 'cron', expression: cron_expression };
+          break;
+        case 'interval':
+          schedule = { type: 'interval', minutes: interval_minutes };
+          break;
+        case 'random':
+          schedule = { type: 'random', minMinutes: min_minutes, maxMinutes: max_minutes };
+          break;
+        default:
+          return { error: `Unknown schedule type: ${schedule_type}` };
+      }
+
+      try {
+        const auto = automationManager.create(chatId, { name: autoName, description, schedule });
+        return {
+          automation_id: auto.id,
+          name: auto.name,
+          schedule: auto.schedule,
+          next_run: auto.nextRun ? new Date(auto.nextRun).toLocaleString() : null,
+          message: `Automation "${auto.name}" created and armed.`,
+        };
+      } catch (err) {
+        logger.warn(`[create_automation] Failed: ${err.message}`);
+        return { error: err.message };
+      }
+    }
+
+    case 'list_automations': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const autos = automationManager.listForChat(chatId);
+      logger.info(`[list_automations] Chat ${chatId} — ${autos.length} automation(s)`);
+
+      if (autos.length === 0) {
+        return { message: 'No automations for this chat.' };
+      }
+
+      return {
+        automations: autos.map((a) => ({
+          id: a.id,
+          name: a.name,
+          description: a.description.slice(0, 100),
+          schedule: a.schedule,
+          enabled: a.enabled,
+          next_run: a.nextRun ? new Date(a.nextRun).toLocaleString() : null,
+          run_count: a.runCount,
+          last_error: a.lastError,
+          summary: a.toSummary(),
+        })),
+      };
+    }
+
+    case 'update_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { automation_id, enabled, name: newName, description: newDesc, schedule_type: newSchedType, cron_expression: newCron, interval_minutes: newInterval, min_minutes: newMin, max_minutes: newMax } = input;
+      logger.info(`[update_automation] Request: id=${automation_id}`);
+
+      const changes = {};
+      if (enabled !== undefined) changes.enabled = enabled;
+      if (newName !== undefined) changes.name = newName;
+      if (newDesc !== undefined) changes.description = newDesc;
+
+      if (newSchedType !== undefined) {
+        switch (newSchedType) {
+          case 'cron':
+            changes.schedule = { type: 'cron', expression: newCron };
+            break;
+          case 'interval':
+            changes.schedule = { type: 'interval', minutes: newInterval };
+            break;
+          case 'random':
+            changes.schedule = { type: 'random', minMinutes: newMin, maxMinutes: newMax };
+            break;
+        }
+      }
+
+      try {
+        const auto = automationManager.update(automation_id, changes);
+        if (!auto) return { error: `Automation ${automation_id} not found.` };
+        return {
+          automation_id: auto.id,
+          name: auto.name,
+          enabled: auto.enabled,
+          schedule: auto.schedule,
+          next_run: auto.nextRun ? new Date(auto.nextRun).toLocaleString() : null,
+          message: `Automation "${auto.name}" updated.`,
+        };
+      } catch (err) {
+        logger.warn(`[update_automation] Failed: ${err.message}`);
+        return { error: err.message };
+      }
+    }
+
+    case 'delete_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { automation_id } = input;
+      logger.info(`[delete_automation] Request: id=${automation_id}`);
+
+      const deleted = automationManager.delete(automation_id);
+      if (!deleted) return { error: `Automation ${automation_id} not found.` };
+      return { automation_id, status: 'deleted', message: `Automation deleted.` };
+    }
+
+    default:
+      return { error: `Unknown orchestrator tool: ${name}` };
+  }
+}

package/src/tools/persona.js

@@ -0,0 +1,32 @@
+export const definitions = [
+  {
+    name: 'update_user_persona',
+    description:
+      'Update the stored persona/profile for the current user. ' +
+      'Pass the COMPLETE updated persona document as markdown. ' +
+      'Before calling this, mentally merge any new information into the existing persona — ' +
+      'do not blindly append. Only call when you discover genuinely new, meaningful information ' +
+      '(expertise, preferences, projects, communication style).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'The full updated persona markdown document.',
+        },
+      },
+      required: ['content'],
+    },
+  },
+];
+
+export const handlers = {
+  async update_user_persona({ content }, context) {
+    const { personaManager, user } = context;
+    if (!personaManager) return { error: 'Persona manager not available.' };
+    if (!user?.id) return { error: 'User ID not available.' };
+
+    personaManager.save(user.id, content);
+    return { success: true, message: 'User persona updated.' };
+  },
+};

package/src/utils/config.js

@@ -12,15 +12,26 @@ const DEFAULTS = {
     name: 'KernelBot',
     description: 'AI engineering agent with full OS control',
   },
+  orchestrator: {
+    model: 'claude-opus-4-6',
+    max_tokens: 2048,
+    temperature: 0.3,
+    max_tool_depth: 5,
+  },
   brain: {
     provider: 'anthropic',
     model: 'claude-sonnet-4-20250514',
-    max_tokens: 8192,
+    max_tokens: 4096,
     temperature: 0.3,
-    max_tool_depth: 25,
+  },
+  swarm: {
+    max_concurrent_jobs: 3,
+    job_timeout_seconds: 300,
+    cleanup_interval_minutes: 30,
   },
   telegram: {
     allowed_users: [],
+    batch_window_ms: 3000,
   },
   claude_code: {
     model: 'claude-opus-4-6',
@@ -46,6 +57,7 @@ const DEFAULTS = {
   },
   conversation: {
     max_history: 50,
+    recent_window: 10,
   },
 };
 
@@ -182,30 +194,50 @@ export function saveProviderToYaml(providerKey, modelId) {
  * Full interactive flow: change brain model + optionally enter API key.
  */
 export async function changeBrainModel(config, rl) {
+  const { createProvider } = await import('../providers/index.js');
   const { providerKey, modelId } = await promptProviderSelection(rl);
 
   const providerDef = PROVIDERS[providerKey];
+
+  // Resolve API key
+  const envKey = providerDef.envKey;
+  let apiKey = process.env[envKey];
+  if (!apiKey) {
+    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
+    if (!key.trim()) {
+      console.log(chalk.yellow('\n  No API key provided. Brain not changed.\n'));
+      return config;
+    }
+    apiKey = key.trim();
+  }
+
+  // Validate the new provider before saving anything
+  console.log(chalk.dim(`\n  Verifying ${providerDef.name} / ${modelId}...`));
+  const testConfig = { ...config, brain: { ...config.brain, provider: providerKey, model: modelId, api_key: apiKey } };
+  try {
+    const testProvider = createProvider(testConfig);
+    await testProvider.ping();
+  } catch (err) {
+    console.log(chalk.red(`\n  ✖ Verification failed: ${err.message}`));
+    console.log(chalk.yellow(`  Brain not changed. Keeping current model.\n`));
+    return config;
+  }
+
+  // Validation passed — save everything
   const savedPath = saveProviderToYaml(providerKey, modelId);
-  console.log(chalk.dim(`\n  Saved to ${savedPath}`));
+  console.log(chalk.dim(`  Saved to ${savedPath}`));
 
-  // Update live config
   config.brain.provider = providerKey;
   config.brain.model = modelId;
+  config.brain.api_key = apiKey;
 
-  // Check if we have the API key for this provider
-  const envKey = providerDef.envKey;
-  const currentKey = process.env[envKey];
-  if (!currentKey) {
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
-    if (key.trim()) {
-      saveCredential(config, envKey, key.trim());
-      config.brain.api_key = key.trim();
-      console.log(chalk.dim('  Saved.\n'));
-    }
-  } else {
-    config.brain.api_key = currentKey;
+  // Save the key if it was newly entered
+  if (!process.env[envKey]) {
+    saveCredential(config, envKey, apiKey);
+    console.log(chalk.dim('  API key saved.\n'));
   }
 
+  console.log(chalk.green(`  ✔ Brain switched to ${providerDef.name} / ${modelId}\n`));
   return config;
 }
 
@@ -297,6 +329,11 @@ export function loadConfig() {
 
   const config = deepMerge(DEFAULTS, fileConfig);
 
+  // Orchestrator always uses Anthropic — resolve its API key
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.orchestrator.api_key = process.env.ANTHROPIC_API_KEY;
+  }
+
   // Overlay env vars for brain API key based on provider
   const providerDef = PROVIDERS[config.brain.provider];
   if (providerDef && process.env[providerDef.envKey]) {