kernelbot 1.0.28 → 1.0.32

package/src/claude-auth.js

@@ -0,0 +1,93 @@
+import { spawn } from 'child_process';
+import { getLogger } from './utils/logger.js';
+
+/**
+ * Run `claude auth status` and return parsed output.
+ */
+export function getClaudeAuthStatus() {
+  const logger = getLogger();
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['auth', 'status'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      const output = (stdout || stderr).trim();
+      logger.debug(`claude auth status (code ${code}): ${output.slice(0, 300)}`);
+      resolve({ code, output });
+    });
+
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        resolve({ code: -1, output: 'Claude Code CLI not found. Install with: npm i -g @anthropic-ai/claude-code' });
+      } else {
+        resolve({ code: -1, output: err.message });
+      }
+    });
+
+    // Timeout after 10s
+    setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ code: -1, output: 'Timed out checking auth status' });
+    }, 10_000);
+  });
+}
+
+/**
+ * Run `claude auth logout`.
+ */
+export function claudeLogout() {
+  const logger = getLogger();
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['auth', 'logout'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      const output = (stdout || stderr).trim();
+      logger.info(`claude auth logout (code ${code}): ${output.slice(0, 300)}`);
+      resolve({ code, output });
+    });
+
+    child.on('error', (err) => {
+      resolve({ code: -1, output: err.message });
+    });
+
+    setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ code: -1, output: 'Timed out during logout' });
+    }, 10_000);
+  });
+}
+
+/**
+ * Return the current Claude Code auth mode from config.
+ */
+export function getClaudeCodeAuthMode(config) {
+  const mode = config.claude_code?.auth_mode || 'system';
+  const info = { mode };
+
+  if (mode === 'api_key') {
+    const key = config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY || '';
+    info.credential = key ? `${key.slice(0, 8)}...${key.slice(-4)}` : '(not set)';
+  } else if (mode === 'oauth_token') {
+    const token = config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN || '';
+    info.credential = token ? `${token.slice(0, 8)}...${token.slice(-4)}` : '(not set)';
+  } else {
+    info.credential = 'Using host system login';
+  }
+
+  return info;
+}

package/src/coder.js

@@ -135,17 +135,43 @@ function processEvent(line, onOutput, logger) {
 
 export class ClaudeCodeSpawner {
   constructor(config) {
+    this.config = 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;
+    this.timeout = (config.claude_code?.timeout_seconds || 86400) * 1000;
   }
 
-  async run({ workingDirectory, prompt, maxTurns, onOutput }) {
+  _buildSpawnEnv() {
+    const authMode = this.config.claude_code?.auth_mode || 'system';
+    const env = { ...process.env, IS_SANDBOX: '1' };
+
+    if (authMode === 'api_key') {
+      const key = this.config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY;
+      if (key) {
+        env.ANTHROPIC_API_KEY = key;
+        delete env.CLAUDE_CODE_OAUTH_TOKEN;
+      }
+    } else if (authMode === 'oauth_token') {
+      const token = this.config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      if (token) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = token;
+        // Remove ANTHROPIC_API_KEY so it doesn't override subscription auth
+        delete env.ANTHROPIC_API_KEY;
+      }
+    }
+    // authMode === 'system' — pass env as-is
+
+    return env;
+  }
+
+  async run({ workingDirectory, prompt, maxTurns, onOutput, signal }) {
     const logger = getLogger();
     const turns = maxTurns || this.maxTurns;
 
     ensureClaudeCodeSetup();
 
+    // Read model dynamically from config (supports hot-reload via switchClaudeCodeModel)
+    const model = this.config.claude_code?.model || null;
+
     const args = [
       '-p', prompt,
       '--max-turns', String(turns),
@@ -153,8 +179,8 @@ export class ClaudeCodeSpawner {
       '--verbose',
       '--dangerously-skip-permissions',
     ];
-    if (this.model) {
-      args.push('--model', this.model);
+    if (model) {
+      args.push('--model', model);
     }
 
     const cmd = `claude ${args.map((a) => a.includes(' ') ? `"${a}"` : a).join(' ')}`;
@@ -219,10 +245,24 @@ export class ClaudeCodeSpawner {
     return new Promise((resolve, reject) => {
       const child = spawn('claude', args, {
         cwd: workingDirectory,
-        env: { ...process.env, IS_SANDBOX: '1' },
+        env: this._buildSpawnEnv(),
         stdio: ['ignore', 'pipe', 'pipe'],
       });
 
+      // Wire abort signal to kill the child process
+      let abortHandler = null;
+      if (signal) {
+        if (signal.aborted) {
+          child.kill('SIGTERM');
+        } else {
+          abortHandler = () => {
+            logger.info('Claude Code: abort signal received — killing child process');
+            child.kill('SIGTERM');
+          };
+          signal.addEventListener('abort', abortHandler, { once: true });
+        }
+      }
+
       let fullOutput = '';
       let stderr = '';
       let buffer = '';
@@ -268,6 +308,7 @@ export class ClaudeCodeSpawner {
 
       child.on('close', async (code) => {
         clearTimeout(timer);
+        if (abortHandler && signal) signal.removeEventListener('abort', abortHandler);
 
         if (buffer.trim()) {
           fullOutput += buffer.trim();
@@ -312,6 +353,7 @@ export class ClaudeCodeSpawner {
 
       child.on('error', (err) => {
         clearTimeout(timer);
+        if (abortHandler && signal) signal.removeEventListener('abort', abortHandler);
         if (err.code === 'ENOENT') {
           reject(new Error('Claude Code CLI not found. Install with: npm i -g @anthropic-ai/claude-code'));
         } else {

package/src/life/codebase.js

@@ -0,0 +1,388 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { createHash } from 'crypto';
+import { getLogger } from '../utils/logger.js';
+
+const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
+const CODEBASE_DIR = join(LIFE_DIR, 'codebase');
+const SUMMARIES_FILE = join(CODEBASE_DIR, 'file-summaries.json');
+const ARCHITECTURE_FILE = join(CODEBASE_DIR, 'architecture.md');
+
+// Files to always skip during scanning
+const SKIP_PATTERNS = [
+  'node_modules', '.git', 'package-lock.json', 'yarn.lock',
+  '.env', '.DS_Store', 'dist/', 'build/', 'coverage/',
+];
+
+export class CodebaseKnowledge {
+  constructor({ config } = {}) {
+    this.config = config || {};
+    this._projectRoot = null;
+    this._summaries = {};
+    this._agent = null;
+
+    mkdirSync(CODEBASE_DIR, { recursive: true });
+    this._summaries = this._loadSummaries();
+  }
+
+  /** Set the agent reference (called after agent is created). */
+  setAgent(agent) {
+    this._agent = agent;
+  }
+
+  /** Set/detect project root. */
+  setProjectRoot(root) {
+    this._projectRoot = root;
+  }
+
+  getProjectRoot() {
+    if (this._projectRoot) return this._projectRoot;
+    // Try to detect from git
+    try {
+      this._projectRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+    } catch {
+      this._projectRoot = process.cwd();
+    }
+    return this._projectRoot;
+  }
+
+  // ── Persistence ───────────────────────────────────────────────
+
+  _loadSummaries() {
+    if (existsSync(SUMMARIES_FILE)) {
+      try {
+        return JSON.parse(readFileSync(SUMMARIES_FILE, 'utf-8'));
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+
+  _saveSummaries() {
+    writeFileSync(SUMMARIES_FILE, JSON.stringify(this._summaries, null, 2), 'utf-8');
+  }
+
+  _saveArchitecture(content) {
+    writeFileSync(ARCHITECTURE_FILE, content, 'utf-8');
+  }
+
+  // ── File Hashing ──────────────────────────────────────────────
+
+  _hashFile(filePath) {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      return createHash('md5').update(content).digest('hex').slice(0, 12);
+    } catch {
+      return null;
+    }
+  }
+
+  _lineCount(filePath) {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      return content.split('\n').length;
+    } catch {
+      return 0;
+    }
+  }
+
+  // ── Scanning ──────────────────────────────────────────────────
+
+  /**
+   * Scan a single file using the LLM to generate a summary.
+   * Requires this._agent to be set.
+   */
+  async scanFile(filePath) {
+    const logger = getLogger();
+    const root = this.getProjectRoot();
+    const fullPath = filePath.startsWith('/') ? filePath : join(root, filePath);
+    const relativePath = filePath.startsWith('/') ? filePath.replace(root + '/', '') : filePath;
+
+    // Check if file should be skipped
+    if (SKIP_PATTERNS.some(p => relativePath.includes(p))) return null;
+
+    const hash = this._hashFile(fullPath);
+    if (!hash) return null;
+
+    // Skip if already scanned and unchanged
+    const existing = this._summaries[relativePath];
+    if (existing && existing.lastHash === hash) return existing;
+
+    // Read file content
+    let content;
+    try {
+      content = readFileSync(fullPath, 'utf-8');
+    } catch {
+      return null;
+    }
+
+    // Truncate very large files
+    const maxChars = 8000;
+    const truncated = content.length > maxChars
+      ? content.slice(0, maxChars) + '\n... (truncated)'
+      : content;
+
+    // Use LLM to summarize if agent is available
+    let summary;
+    if (this._agent) {
+      try {
+        const prompt = `Analyze this source file and respond with ONLY a JSON object (no markdown, no code blocks):
+{
+  "summary": "one-paragraph description of what this file does",
+  "exports": ["list", "of", "exported", "names"],
+  "dependencies": ["list", "of", "local", "imports"]
+}
+
+File: ${relativePath}
+\`\`\`
+${truncated}
+\`\`\``;
+
+        const response = await this._agent.orchestratorProvider.chat({
+          system: 'You are a code analysis assistant. Respond with only valid JSON, no markdown formatting.',
+          messages: [{ role: 'user', content: prompt }],
+        });
+
+        const text = (response.text || '').trim();
+        // Try to parse JSON from the response
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          const parsed = JSON.parse(jsonMatch[0]);
+          summary = {
+            summary: parsed.summary || 'No summary generated',
+            exports: parsed.exports || [],
+            dependencies: parsed.dependencies || [],
+          };
+        }
+      } catch (err) {
+        logger.debug(`[Codebase] LLM scan failed for ${relativePath}: ${err.message}`);
+      }
+    }
+
+    // Fallback: basic static analysis
+    if (!summary) {
+      summary = this._staticAnalysis(content, relativePath);
+    }
+
+    const entry = {
+      ...summary,
+      lineCount: this._lineCount(fullPath),
+      lastHash: hash,
+      lastScanned: Date.now(),
+    };
+
+    this._summaries[relativePath] = entry;
+    this._saveSummaries();
+    logger.debug(`[Codebase] Scanned: ${relativePath}`);
+    return entry;
+  }
+
+  /**
+   * Scan only files that have changed since last scan (git-based).
+   */
+  async scanChanged() {
+    const logger = getLogger();
+    const root = this.getProjectRoot();
+
+    let changedFiles = [];
+    try {
+      // Get all tracked files that differ from what we've scanned
+      const allFiles = execSync('git ls-files --full-name', {
+        cwd: root,
+        encoding: 'utf-8',
+      }).trim().split('\n').filter(Boolean);
+
+      // Filter to source files
+      changedFiles = allFiles.filter(f =>
+        (f.endsWith('.js') || f.endsWith('.mjs') || f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.md')) &&
+        !SKIP_PATTERNS.some(p => f.includes(p))
+      );
+
+      // Only scan files whose hash has changed
+      changedFiles = changedFiles.filter(f => {
+        const fullPath = join(root, f);
+        const hash = this._hashFile(fullPath);
+        const existing = this._summaries[f];
+        return !existing || existing.lastHash !== hash;
+      });
+    } catch (err) {
+      logger.warn(`[Codebase] Git scan failed: ${err.message}`);
+      return 0;
+    }
+
+    logger.info(`[Codebase] Scanning ${changedFiles.length} changed files...`);
+    let scanned = 0;
+
+    for (const file of changedFiles) {
+      try {
+        await this.scanFile(file);
+        scanned++;
+      } catch (err) {
+        logger.debug(`[Codebase] Failed to scan ${file}: ${err.message}`);
+      }
+    }
+
+    logger.info(`[Codebase] Scan complete: ${scanned} files updated`);
+    return scanned;
+  }
+
+  /**
+   * Full scan of all source files. Heavy operation — use sparingly.
+   */
+  async scanAll() {
+    const logger = getLogger();
+    const root = this.getProjectRoot();
+
+    let allFiles = [];
+    try {
+      allFiles = execSync('git ls-files --full-name', {
+        cwd: root,
+        encoding: 'utf-8',
+      }).trim().split('\n').filter(Boolean);
+
+      allFiles = allFiles.filter(f =>
+        (f.endsWith('.js') || f.endsWith('.mjs') || f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.md')) &&
+        !SKIP_PATTERNS.some(p => f.includes(p))
+      );
+    } catch (err) {
+      logger.warn(`[Codebase] Git ls-files failed: ${err.message}`);
+      return 0;
+    }
+
+    logger.info(`[Codebase] Full scan: ${allFiles.length} files...`);
+    let scanned = 0;
+
+    for (const file of allFiles) {
+      try {
+        await this.scanFile(file);
+        scanned++;
+      } catch (err) {
+        logger.debug(`[Codebase] Failed to scan ${file}: ${err.message}`);
+      }
+    }
+
+    logger.info(`[Codebase] Full scan complete: ${scanned} files`);
+    return scanned;
+  }
+
+  // ── Queries ───────────────────────────────────────────────────
+
+  getFileSummary(path) {
+    return this._summaries[path] || null;
+  }
+
+  getAllSummaries() {
+    return { ...this._summaries };
+  }
+
+  getArchitecture() {
+    if (existsSync(ARCHITECTURE_FILE)) {
+      try {
+        return readFileSync(ARCHITECTURE_FILE, 'utf-8');
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Find files relevant to a proposed change description.
+   * Returns file paths sorted by relevance.
+   */
+  getRelevantFiles(description) {
+    const descLower = description.toLowerCase();
+    const keywords = descLower.split(/\W+/).filter(w => w.length > 2);
+
+    const scored = Object.entries(this._summaries).map(([path, info]) => {
+      let score = 0;
+      const text = `${path} ${info.summary || ''}`.toLowerCase();
+
+      for (const keyword of keywords) {
+        if (text.includes(keyword)) score++;
+      }
+
+      return { path, score, summary: info.summary };
+    });
+
+    return scored
+      .filter(s => s.score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 15);
+  }
+
+  /**
+   * Regenerate the architecture overview from all summaries.
+   */
+  async updateArchitecture() {
+    const logger = getLogger();
+    const entries = Object.entries(this._summaries);
+    if (entries.length === 0) return;
+
+    // Group by directory
+    const byDir = {};
+    for (const [path, info] of entries) {
+      const dir = path.includes('/') ? path.split('/').slice(0, -1).join('/') : '.';
+      if (!byDir[dir]) byDir[dir] = [];
+      byDir[dir].push({ path, ...info });
+    }
+
+    // Build a compact summary for LLM
+    const summaryText = Object.entries(byDir)
+      .map(([dir, files]) => {
+        const fileLines = files
+          .map(f => `  - ${f.path}: ${(f.summary || 'no summary').slice(0, 120)}`)
+          .join('\n');
+        return `### ${dir}/\n${fileLines}`;
+      })
+      .join('\n\n');
+
+    if (this._agent) {
+      try {
+        const prompt = `Based on these file summaries, write a concise architecture overview document in Markdown. Include: project structure, key components, data flow, and patterns used.
+
+${summaryText}`;
+
+        const response = await this._agent.orchestratorProvider.chat({
+          system: 'You are a software architect. Write clear, concise architecture documentation.',
+          messages: [{ role: 'user', content: prompt }],
+        });
+
+        if (response.text) {
+          this._saveArchitecture(response.text);
+          logger.info(`[Codebase] Architecture doc updated (${response.text.length} chars)`);
+        }
+      } catch (err) {
+        logger.warn(`[Codebase] Architecture update failed: ${err.message}`);
+      }
+    } else {
+      // Fallback: just dump the summaries
+      const doc = `# KERNEL Architecture\n\n_Auto-generated on ${new Date().toISOString()}_\n\n${summaryText}`;
+      this._saveArchitecture(doc);
+    }
+  }
+
+  // ── Static Analysis Fallback ──────────────────────────────────
+
+  _staticAnalysis(content, filePath) {
+    const exports = [];
+    const dependencies = [];
+
+    // Extract exports
+    const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:class|function|const|let|var)\s+(\w+)/g);
+    for (const m of exportMatches) exports.push(m[1]);
+
+    // Extract local imports
+    const importMatches = content.matchAll(/from\s+['"](\.[^'"]+)['"]/g);
+    for (const m of importMatches) dependencies.push(m[1]);
+
+    // Simple summary based on file path
+    let summary = `Source file at ${filePath}`;
+    if (exports.length > 0) summary += ` — exports: ${exports.join(', ')}`;
+
+    return { summary, exports, dependencies };
+  }
+}