kernelbot 1.0.14 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",

package/src/coder.js

@@ -1,20 +1,96 @@
 import { spawn } from 'child_process';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 import { getLogger } from './utils/logger.js';
 
+function ensureClaudeCodeSetup() {
+  const logger = getLogger();
+  const claudeJson = join(homedir(), '.claude.json');
+  const claudeDir = join(homedir(), '.claude');
+
+  // Create ~/.claude/ directory if missing
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+    logger.info('Created ~/.claude/ directory');
+  }
+
+  // Create ~/.claude.json with onboarding completed if missing
+  if (!existsSync(claudeJson)) {
+    const defaults = {
+      hasCompletedOnboarding: true,
+      theme: 'dark',
+      shiftEnterKeyBindingInstalled: true,
+    };
+    writeFileSync(claudeJson, JSON.stringify(defaults, null, 2));
+    logger.info('Created ~/.claude.json with default settings (skipping setup wizard)');
+  }
+}
+
+function parseStreamEvent(line, onOutput, logger) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return; // skip non-JSON lines
+  }
+
+  // Assistant text message
+  if (event.type === 'message' && event.role === 'assistant') {
+    const texts = (event.content || [])
+      .filter((b) => b.type === 'text' && b.text?.trim())
+      .map((b) => b.text.trim());
+    if (texts.length > 0) {
+      const msg = texts.join('\n');
+      logger.info(`Claude Code: ${msg.slice(0, 200)}`);
+      if (onOutput) onOutput(`💬 *Claude Code:*\n${msg}`).catch(() => {});
+    }
+  }
+
+  // Tool use
+  if (event.type === 'tool_use') {
+    const name = event.name || 'unknown';
+    const input = event.input || {};
+    const summary = input.command || input.file_path || input.pattern || input.query || JSON.stringify(input).slice(0, 100);
+    logger.info(`Claude Code tool: ${name}: ${String(summary).slice(0, 150)}`);
+    if (onOutput) onOutput(`🔨 \`${name}: ${String(summary).slice(0, 150)}\``).catch(() => {});
+  }
+
+  // Result
+  if (event.type === 'result') {
+    const status = event.status || 'done';
+    const duration = event.duration_ms ? `${(event.duration_ms / 1000).toFixed(1)}s` : '';
+    logger.info(`Claude Code finished: ${status} ${duration}`);
+    if (onOutput) onOutput(`✅ Claude Code finished (${status}${duration ? ` in ${duration}` : ''})`).catch(() => {});
+  }
+}
+
 export class ClaudeCodeSpawner {
   constructor(config) {
     this.maxTurns = config.claude_code?.max_turns || 50;
     this.timeout = (config.claude_code?.timeout_seconds || 600) * 1000;
+    this.model = config.claude_code?.model || null;
   }
 
   async run({ workingDirectory, prompt, maxTurns, onOutput }) {
     const logger = getLogger();
     const turns = maxTurns || this.maxTurns;
 
+    // Auto-setup Claude Code if not configured
+    ensureClaudeCodeSetup();
+
     logger.info(`Spawning Claude Code in ${workingDirectory}`);
 
     return new Promise((resolve, reject) => {
-      const args = ['-p', prompt, '--max-turns', String(turns), '--output-format', 'text'];
+      const args = [
+        '-p', prompt,
+        '--max-turns', String(turns),
+        '--output-format', 'stream-json',
+        '--dangerously-skip-permissions',
+      ];
+      if (this.model) {
+        args.push('--model', this.model);
+      }
 
       const child = spawn('claude', args, {
         cwd: workingDirectory,
@@ -22,25 +98,33 @@ export class ClaudeCodeSpawner {
         stdio: ['ignore', 'pipe', 'pipe'],
       });
 
-      let stdout = '';
+      let fullOutput = '';
       let stderr = '';
       let buffer = '';
+      let resultText = '';
 
       child.stdout.on('data', (data) => {
-        const chunk = data.toString();
-        stdout += chunk;
-        buffer += chunk;
+        buffer += data.toString();
 
-        // Stream output in meaningful chunks (split on newlines)
+        // Process complete JSON lines
         const lines = buffer.split('\n');
-        buffer = lines.pop(); // keep incomplete line in buffer
-
-        if (lines.length > 0 && onOutput) {
-          const text = lines.join('\n').trim();
-          if (text) {
-            logger.info(`Claude Code output: ${text.slice(0, 200)}`);
-            onOutput(text).catch(() => {});
-          }
+        buffer = lines.pop(); // keep incomplete line
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+
+          fullOutput += trimmed + '\n';
+
+          // Extract final result text
+          try {
+            const event = JSON.parse(trimmed);
+            if (event.type === 'result' && event.result) {
+              resultText = event.result;
+            }
+          } catch {}
+
+          parseStreamEvent(trimmed, onOutput, logger);
         }
       });
 
@@ -56,16 +140,23 @@ export class ClaudeCodeSpawner {
       child.on('close', (code) => {
         clearTimeout(timer);
 
-        // Flush remaining buffer
-        if (buffer.trim() && onOutput) {
-          onOutput(buffer.trim()).catch(() => {});
+        // Process remaining buffer
+        if (buffer.trim()) {
+          fullOutput += buffer.trim();
+          try {
+            const event = JSON.parse(buffer.trim());
+            if (event.type === 'result' && event.result) {
+              resultText = event.result;
+            }
+          } catch {}
+          parseStreamEvent(buffer.trim(), onOutput, logger);
         }
 
-        if (code !== 0 && !stdout) {
+        if (code !== 0 && !fullOutput) {
           reject(new Error(`Claude Code exited with code ${code}: ${stderr}`));
         } else {
           resolve({
-            output: stdout.trim(),
+            output: resultText || fullOutput.trim(),
             stderr: stderr.trim(),
             exitCode: code,
           });

package/src/prompts/system.js

@@ -10,12 +10,15 @@ 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
+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
 
+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

package/src/tools/coding.js

@@ -41,9 +41,7 @@ export const handlers = {
         workingDirectory: params.working_directory,
         prompt: params.prompt,
         maxTurns: params.max_turns,
-        onOutput: context.onUpdate
-          ? (text) => context.onUpdate(`📟 \`Claude Code:\`\n${text}`)
-          : null,
+        onOutput: context.onUpdate || null,
       });
       return { success: true, output: result.output };
     } catch (err) {

package/src/utils/config.js

@@ -21,6 +21,7 @@ const DEFAULTS = {
     allowed_users: [],
   },
   claude_code: {
+    model: 'claude-opus-4-6',
     max_turns: 50,
     timeout_seconds: 600,
     workspace_dir: null, // defaults to ~/.kernelbot/workspaces