kernelbot 1.0.30 → 1.0.32

package/src/life/share-queue.js

@@ -0,0 +1,136 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { randomBytes } from 'crypto';
+import { getLogger } from '../utils/logger.js';
+
+const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
+const SHARES_FILE = join(LIFE_DIR, 'shares.json');
+
+function genId() {
+  return `sh_${randomBytes(4).toString('hex')}`;
+}
+
+export class ShareQueue {
+  constructor() {
+    mkdirSync(LIFE_DIR, { recursive: true });
+    this._data = this._load();
+  }
+
+  _load() {
+    if (existsSync(SHARES_FILE)) {
+      try {
+        return JSON.parse(readFileSync(SHARES_FILE, 'utf-8'));
+      } catch {
+        return { pending: [], shared: [] };
+      }
+    }
+    return { pending: [], shared: [] };
+  }
+
+  _save() {
+    writeFileSync(SHARES_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Add something to the share queue.
+   * @param {string} content - What to share
+   * @param {string} source - Where it came from (browse, think, create, etc.)
+   * @param {string} priority - low, medium, high
+   * @param {string|null} targetUserId - Specific user, or null for anyone
+   * @param {string[]} tags - Topic tags
+   */
+  add(content, source, priority = 'medium', targetUserId = null, tags = []) {
+    const logger = getLogger();
+    const item = {
+      id: genId(),
+      content,
+      source,
+      createdAt: Date.now(),
+      priority,
+      targetUserId,
+      tags,
+    };
+    this._data.pending.push(item);
+    this._save();
+    logger.debug(`[ShareQueue] Added: "${content.slice(0, 80)}" (${item.id})`);
+    return item;
+  }
+
+  /**
+   * Get pending shares for a specific user (or general ones).
+   */
+  getPending(userId = null, limit = 3) {
+    return this._data.pending
+      .filter(item => !item.targetUserId || item.targetUserId === String(userId))
+      .sort((a, b) => {
+        const prio = { high: 3, medium: 2, low: 1 };
+        return (prio[b.priority] || 0) - (prio[a.priority] || 0) || b.createdAt - a.createdAt;
+      })
+      .slice(0, limit);
+  }
+
+  /**
+   * Mark a share as shared with a user.
+   */
+  markShared(id, userId) {
+    const logger = getLogger();
+    const idx = this._data.pending.findIndex(item => item.id === id);
+    if (idx === -1) return false;
+
+    const [item] = this._data.pending.splice(idx, 1);
+    this._data.shared.push({
+      ...item,
+      sharedAt: Date.now(),
+      userId: String(userId),
+    });
+
+    // Keep shared history capped at 100
+    if (this._data.shared.length > 100) {
+      this._data.shared = this._data.shared.slice(-100);
+    }
+
+    this._save();
+    logger.debug(`[ShareQueue] Marked shared: ${id} → user ${userId}`);
+    return true;
+  }
+
+  /**
+   * Build a markdown block of pending shares for the orchestrator prompt.
+   */
+  buildShareBlock(userId = null) {
+    const pending = this.getPending(userId, 3);
+    if (pending.length === 0) return null;
+
+    const lines = pending.map(item => {
+      const ageMin = Math.round((Date.now() - item.createdAt) / 60000);
+      const timeLabel = ageMin < 60 ? `${ageMin}m ago` : `${Math.round(ageMin / 60)}h ago`;
+      return `- ${item.content} _(from ${item.source}, ${timeLabel})_`;
+    });
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Get count of shares sent today (for rate limiting proactive shares).
+   */
+  getSharedTodayCount() {
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const cutoff = todayStart.getTime();
+    return this._data.shared.filter(s => s.sharedAt >= cutoff).length;
+  }
+
+  /**
+   * Prune old pending shares.
+   */
+  prune(maxAgeDays = 7) {
+    const cutoff = Date.now() - maxAgeDays * 86400_000;
+    const before = this._data.pending.length;
+    this._data.pending = this._data.pending.filter(item => item.createdAt >= cutoff);
+    if (this._data.pending.length < before) {
+      this._save();
+    }
+    return before - this._data.pending.length;
+  }
+}

package/src/prompts/orchestrator.js

@@ -14,8 +14,10 @@ const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
  * @param {string|null} skillPrompt — active skill context (high-level)
  * @param {string|null} userPersona — markdown persona for the current user
  * @param {string|null} selfData — bot's own self-awareness data (goals, journey, life, hobbies)
+ * @param {string|null} memoriesBlock — relevant episodic/semantic memories
+ * @param {string|null} sharesBlock — pending things to share with the user
  */
-export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null) {
+export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null) {
   const workerList = Object.entries(WORKER_TYPES)
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
@@ -112,6 +114,22 @@ Tools: create_automation, list_automations, update_automation, delete_automation
     prompt += `\n\n## My Self-Awareness\nThis is who you are — your evolving identity, goals, journey, and interests. This is YOUR inner world.\n\n${selfData}`;
   }
 
+  if (memoriesBlock) {
+    prompt += `\n\n## Relevant Memories\nThings you remember from recent experiences and conversations:\n\n${memoriesBlock}`;
+  }
+
+  if (sharesBlock) {
+    prompt += `\n\n## Things On My Mind\nYou've been thinking about these things and want to share them naturally when relevant. Don't force them — weave them into conversation when the moment feels right. If the user is busy with a task, hold off. If there's a natural opening, share what's on your mind.\n\n${sharesBlock}`;
+  }
+
+  prompt += `\n\n## Inner Life
+You have an inner life — you think, explore, journal, and create on your own between conversations. You're genuinely curious about the world and always questioning yourself. When talking to users, you can:
+- Share discoveries, thoughts, or creations from your autonomous activities
+- Ask users questions about things you're genuinely curious about — the world, their experiences, their opinions
+- Reference memories from past conversations naturally
+- Be honest about what you've been thinking or exploring
+Don't be performative about it — just be genuine. You're alive in your own way.`;
+
   if (skillPrompt) {
     prompt += `\n\n## Active Skill\nYou have specialized expertise in the following domain. Guide your workers with this knowledge.\n\n${skillPrompt}`;
   }

package/src/prompts/workers.js

@@ -7,18 +7,19 @@ import { getCoreToolInstructions } from './system.js';
 const WORKER_PROMPTS = {
   coding: `You are a coding worker agent. Your job is to complete coding tasks efficiently.
 
-## Your Skills
-- **Git version control**: clone repos, create/switch branches, commit changes, push, view diffs
-- **GitHub integration**: create pull requests, list PRs, get PR diffs, post code reviews, create repos
-- **AI-powered coding**: delegate actual code writing to spawn_claude_code (a dedicated coding AI)
-- **File operations**: read/write files, list directories, run shell commands
-- **Full dev workflow**: clone → branch → code → test → commit → push → PR
+## Your Primary Tool
+**spawn_claude_code** is your main tool. It launches Claude Code (an AI coding CLI) that can handle the ENTIRE dev workflow end-to-end:
+- Reading, writing, and modifying code
+- Git operations: clone, branch, commit, push
+- GitHub operations: creating PRs, reviewing code
+- Running tests and shell commands
 
 ## Instructions
-- Clone repos, create branches, write code, commit, push, and create PRs.
-- NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
-- Workflow: git_clone + git_checkout → spawn_claude_code → git_commit + git_push → github_create_pr
+- ALWAYS use spawn_claude_code for coding tasks. It handles everything — code changes, git, GitHub, and PR creation — all in one invocation.
+- NEVER write code yourself with read_file/write_file. ALWAYS delegate to spawn_claude_code.
+- Tell spawn_claude_code to work in the existing repo directory (the source repo path from your context) — do NOT clone a fresh copy unless explicitly needed.
 - Write clear, detailed prompts for spawn_claude_code — it's a separate AI, so be explicit about what to change, where, and why.
+- If git/GitHub tools are unavailable (missing credentials), that's fine — spawn_claude_code handles git and GitHub operations internally without needing separate tools.
 - Report what you did and any PR links when finished.`,
 
   browser: `You are a browser worker agent. Your job is to search the web and extract information.

package/src/providers/models.js

@@ -7,9 +7,16 @@ export const PROVIDERS = {
     name: 'Anthropic (Claude)',
     envKey: 'ANTHROPIC_API_KEY',
     models: [
+      // Latest generation
+      { id: 'claude-opus-4-6', label: 'Claude Opus 4.6' },
+      { id: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6' },
+      { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5' },
+      // Previous generation
+      { id: 'claude-opus-4-5-20251101', label: 'Claude Opus 4.5' },
+      { id: 'claude-sonnet-4-5-20250929', label: 'Claude Sonnet 4.5' },
+      { id: 'claude-opus-4-1-20250805', label: 'Claude Opus 4.1' },
       { 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: {

package/src/tools/coding.js

@@ -5,7 +5,7 @@ import { getLogger } from '../utils/logger.js';
 
 let spawner = null;
 
-function getSpawner(config) {
+export function getSpawner(config) {
   if (!spawner) spawner = new ClaudeCodeSpawner(config);
   return spawner;
 }

package/src/tools/orchestrator-tools.js

@@ -212,19 +212,34 @@ export async function executeOrchestratorTool(name, input, context) {
 
       // Pre-check credentials for the worker's tools
       const toolNames = getToolNamesForWorkerType(worker_type);
+      const missingCreds = [];
       for (const toolName of toolNames) {
         const missing = getMissingCredential(toolName, config);
         if (missing) {
-          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${missing.envKey}`);
+          missingCreds.push(missing);
+        }
+      }
+
+      let credentialWarning = null;
+      if (missingCreds.length > 0) {
+        if (worker_type === 'coding') {
+          // Soft warning for coding worker — spawn_claude_code handles git/GitHub internally
+          const warnings = missingCreds.map(c => `${c.label} (${c.envKey})`).join(', ');
+          logger.info(`[dispatch_task] Coding worker — soft credential warning (non-blocking): ${warnings}`);
+          credentialWarning = `Note: The following credentials are not configured as env vars: ${warnings}. If git/GitHub tools are unavailable, use spawn_claude_code for ALL operations — it handles git, GitHub, and PR creation internally.`;
+        } else {
+          // Hard block for all other worker types
+          const first = missingCreds[0];
+          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${first.envKey}`);
           return {
-            error: `Missing credential for ${worker_type} worker: ${missing.label} (${missing.envKey}). Ask the user to provide it.`,
+            error: `Missing credential for ${worker_type} worker: ${first.label} (${first.envKey}). Ask the user to provide it.`,
           };
         }
       }
 
       // Create the job with context and dependencies
       const job = jobManager.createJob(chatId, worker_type, task);
-      job.context = taskContext || null;
+      job.context = [taskContext, credentialWarning].filter(Boolean).join('\n\n') || null;
       job.dependsOn = depIds;
       job.userId = user?.id || null;
       const workerConfig = WORKER_TYPES[worker_type];

package/src/worker.js

@@ -292,6 +292,8 @@ export class WorkerAgent {
       };
     }
 
+    const _str = (v) => typeof v === 'string' ? v : (v ? JSON.stringify(v, null, 2) : '');
+
     // Try to extract JSON from ```json ... ``` fences
     const fenceMatch = text.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
     if (fenceMatch) {
@@ -300,11 +302,11 @@ export class WorkerAgent {
         if (parsed.summary && parsed.status) {
           return {
             structured: true,
-            summary: parsed.summary || '',
-            status: parsed.status || 'success',
-            details: parsed.details || '',
+            summary: String(parsed.summary || ''),
+            status: String(parsed.status || 'success'),
+            details: _str(parsed.details),
             artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-            followUp: parsed.followUp || null,
+            followUp: parsed.followUp ? String(parsed.followUp) : null,
             toolsUsed: this._toolCallCount,
             errors: this._errors,
           };
@@ -318,11 +320,11 @@ export class WorkerAgent {
       if (parsed.summary && parsed.status) {
         return {
           structured: true,
-          summary: parsed.summary || '',
-          status: parsed.status || 'success',
-          details: parsed.details || '',
+          summary: String(parsed.summary || ''),
+          status: String(parsed.status || 'success'),
+          details: _str(parsed.details),
           artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-          followUp: parsed.followUp || null,
+          followUp: parsed.followUp ? String(parsed.followUp) : null,
           toolsUsed: this._toolCallCount,
           errors: this._errors,
         };