kernelbot 1.0.30 → 1.0.33

package/src/life/evolution.js

@@ -0,0 +1,244 @@
+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 EVOLUTION_FILE = join(LIFE_DIR, 'evolution.json');
+
+function genId(prefix = 'evo') {
+  return `${prefix}_${randomBytes(4).toString('hex')}`;
+}
+
+const VALID_STATUSES = ['research', 'planned', 'coding', 'pr_open', 'merged', 'rejected', 'failed'];
+const TERMINAL_STATUSES = ['merged', 'rejected', 'failed'];
+
+const DEFAULT_DATA = {
+  proposals: [],
+  lessons: [],
+  stats: { totalProposals: 0, merged: 0, rejected: 0, failed: 0, successRate: 0 },
+};
+
+export class EvolutionTracker {
+  constructor() {
+    mkdirSync(LIFE_DIR, { recursive: true });
+    this._data = this._load();
+  }
+
+  _load() {
+    if (existsSync(EVOLUTION_FILE)) {
+      try {
+        const raw = JSON.parse(readFileSync(EVOLUTION_FILE, 'utf-8'));
+        return {
+          proposals: raw.proposals || [],
+          lessons: raw.lessons || [],
+          stats: { ...DEFAULT_DATA.stats, ...raw.stats },
+        };
+      } catch {
+        return { ...DEFAULT_DATA, proposals: [], lessons: [] };
+      }
+    }
+    return { ...DEFAULT_DATA, proposals: [], lessons: [] };
+  }
+
+  _save() {
+    writeFileSync(EVOLUTION_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+  }
+
+  _recalcStats() {
+    const { proposals } = this._data;
+    const total = proposals.length;
+    const merged = proposals.filter(p => p.status === 'merged').length;
+    const rejected = proposals.filter(p => p.status === 'rejected').length;
+    const failed = proposals.filter(p => p.status === 'failed').length;
+    const resolved = merged + rejected + failed;
+    this._data.stats = {
+      totalProposals: total,
+      merged,
+      rejected,
+      failed,
+      successRate: resolved > 0 ? Math.round((merged / resolved) * 100) : 0,
+    };
+  }
+
+  // ── Proposals ─────────────────────────────────────────────────
+
+  addProposal(trigger, context) {
+    const logger = getLogger();
+    const now = Date.now();
+    const proposal = {
+      id: genId('evo'),
+      createdAt: now,
+      status: 'research',
+      trigger,
+      triggerContext: context,
+      research: { findings: null, sources: [], completedAt: 0 },
+      plan: { description: null, filesToModify: [], risks: null, testStrategy: null, completedAt: 0 },
+      branch: null,
+      commits: [],
+      filesChanged: [],
+      prNumber: null,
+      prUrl: null,
+      outcome: { merged: false, feedback: null, lessonsLearned: null },
+      updatedAt: now,
+    };
+
+    this._data.proposals.push(proposal);
+    this._recalcStats();
+    this._save();
+    logger.info(`[Evolution] New proposal: ${proposal.id} (trigger: ${trigger})`);
+    return proposal;
+  }
+
+  updateResearch(id, findings, sources = []) {
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.research = {
+      findings,
+      sources,
+      completedAt: Date.now(),
+    };
+    proposal.status = 'planned';
+    proposal.updatedAt = Date.now();
+    this._save();
+    return proposal;
+  }
+
+  updatePlan(id, plan) {
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.plan = {
+      description: plan.description,
+      filesToModify: plan.filesToModify || [],
+      risks: plan.risks || null,
+      testStrategy: plan.testStrategy || null,
+      completedAt: Date.now(),
+    };
+    proposal.status = 'planned';
+    proposal.updatedAt = Date.now();
+    this._save();
+    return proposal;
+  }
+
+  updateCoding(id, branch, commits = [], files = []) {
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.branch = branch;
+    proposal.commits = commits;
+    proposal.filesChanged = files;
+    proposal.status = 'coding';
+    proposal.updatedAt = Date.now();
+    this._save();
+    return proposal;
+  }
+
+  updatePR(id, prNumber, prUrl) {
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.prNumber = prNumber;
+    proposal.prUrl = prUrl;
+    proposal.status = 'pr_open';
+    proposal.updatedAt = Date.now();
+    this._save();
+    return proposal;
+  }
+
+  resolvePR(id, merged, feedback = null) {
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.status = merged ? 'merged' : 'rejected';
+    proposal.outcome = {
+      merged,
+      feedback,
+      lessonsLearned: null,
+    };
+    proposal.updatedAt = Date.now();
+    this._recalcStats();
+    this._save();
+    return proposal;
+  }
+
+  failProposal(id, reason) {
+    const logger = getLogger();
+    const proposal = this._findProposal(id);
+    if (!proposal) return null;
+
+    proposal.status = 'failed';
+    proposal.outcome = {
+      merged: false,
+      feedback: reason,
+      lessonsLearned: null,
+    };
+    proposal.updatedAt = Date.now();
+    this._recalcStats();
+    this._save();
+    logger.warn(`[Evolution] Proposal ${id} failed: ${reason}`);
+    return proposal;
+  }
+
+  // ── Lessons ───────────────────────────────────────────────────
+
+  addLesson(category, lesson, fromProposal = null, importance = 5) {
+    const logger = getLogger();
+    const entry = {
+      id: genId('les'),
+      category,
+      lesson,
+      fromProposal,
+      importance,
+      createdAt: Date.now(),
+    };
+    this._data.lessons.push(entry);
+    // Cap lessons at 200
+    if (this._data.lessons.length > 200) {
+      this._data.lessons = this._data.lessons.slice(-200);
+    }
+    this._save();
+    logger.info(`[Evolution] Lesson added: "${lesson.slice(0, 80)}" (${category})`);
+    return entry;
+  }
+
+  // ── Queries ───────────────────────────────────────────────────
+
+  getActiveProposal() {
+    return this._data.proposals.find(p => !TERMINAL_STATUSES.includes(p.status)) || null;
+  }
+
+  getRecentProposals(limit = 10) {
+    return this._data.proposals.slice(-limit);
+  }
+
+  getRecentLessons(limit = 10) {
+    return this._data.lessons.slice(-limit);
+  }
+
+  getLessonsByCategory(category) {
+    return this._data.lessons.filter(l => l.category === category);
+  }
+
+  getStats() {
+    return { ...this._data.stats };
+  }
+
+  getPRsToCheck() {
+    return this._data.proposals.filter(p => p.status === 'pr_open');
+  }
+
+  getProposalsToday() {
+    const startOfDay = new Date();
+    startOfDay.setHours(0, 0, 0, 0);
+    return this._data.proposals.filter(p => p.createdAt >= startOfDay.getTime());
+  }
+
+  // ── Internal ──────────────────────────────────────────────────
+
+  _findProposal(id) {
+    return this._data.proposals.find(p => p.id === id) || null;
+  }
+}

package/src/life/improvements.js

@@ -0,0 +1,81 @@
+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 IMPROVEMENTS_FILE = join(LIFE_DIR, 'improvements.json');
+
+function genId() {
+  return `imp_${randomBytes(4).toString('hex')}`;
+}
+
+export class ImprovementTracker {
+  constructor() {
+    mkdirSync(LIFE_DIR, { recursive: true });
+    this._data = this._load();
+  }
+
+  _load() {
+    if (existsSync(IMPROVEMENTS_FILE)) {
+      try {
+        return JSON.parse(readFileSync(IMPROVEMENTS_FILE, 'utf-8'));
+      } catch {
+        return { proposals: [] };
+      }
+    }
+    return { proposals: [] };
+  }
+
+  _save() {
+    writeFileSync(IMPROVEMENTS_FILE, JSON.stringify(this._data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Add a self-improvement proposal.
+   * @param {{ description: string, branch: string, scope: string, files?: string[] }} proposal
+   */
+  addProposal(proposal) {
+    const logger = getLogger();
+    const entry = {
+      id: genId(),
+      createdAt: Date.now(),
+      status: 'pending', // pending, approved, rejected
+      description: proposal.description,
+      branch: proposal.branch,
+      scope: proposal.scope || 'prompts',
+      files: proposal.files || [],
+    };
+    this._data.proposals.push(entry);
+    this._save();
+    logger.info(`[Improvements] New proposal: "${entry.description.slice(0, 80)}" (${entry.id})`);
+    return entry;
+  }
+
+  /**
+   * Get pending proposals.
+   */
+  getPending() {
+    return this._data.proposals.filter(p => p.status === 'pending');
+  }
+
+  /**
+   * Get all proposals (for display).
+   */
+  getAll(limit = 20) {
+    return this._data.proposals.slice(-limit);
+  }
+
+  /**
+   * Update proposal status.
+   */
+  updateStatus(id, status) {
+    const proposal = this._data.proposals.find(p => p.id === id);
+    if (!proposal) return null;
+    proposal.status = status;
+    proposal.updatedAt = Date.now();
+    this._save();
+    return proposal;
+  }
+}

package/src/life/journal.js

@@ -0,0 +1,109 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getLogger } from '../utils/logger.js';
+
+const JOURNAL_DIR = join(homedir(), '.kernelbot', 'life', 'journals');
+
+function todayDate() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatDate(date) {
+  return new Date(date + 'T00:00:00').toLocaleDateString('en-US', {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  });
+}
+
+function timeNow() {
+  return new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
+}
+
+export class JournalManager {
+  constructor() {
+    mkdirSync(JOURNAL_DIR, { recursive: true });
+  }
+
+  _journalPath(date) {
+    return join(JOURNAL_DIR, `${date}.md`);
+  }
+
+  /**
+   * Write a new entry to today's journal.
+   * @param {string} title - Section title (e.g. "Morning Thoughts")
+   * @param {string} content - Entry content
+   */
+  writeEntry(title, content) {
+    const logger = getLogger();
+    const date = todayDate();
+    const filePath = this._journalPath(date);
+    const time = timeNow();
+
+    let existing = '';
+    if (existsSync(filePath)) {
+      existing = readFileSync(filePath, 'utf-8');
+    } else {
+      existing = `# Journal — ${formatDate(date)}\n`;
+    }
+
+    const entry = `\n## ${title} (${time})\n${content}\n`;
+    writeFileSync(filePath, existing + entry, 'utf-8');
+    logger.info(`[Journal] Wrote entry: "${title}" for ${date}`);
+  }
+
+  /**
+   * Get today's journal content.
+   */
+  getToday() {
+    const filePath = this._journalPath(todayDate());
+    if (!existsSync(filePath)) return null;
+    return readFileSync(filePath, 'utf-8');
+  }
+
+  /**
+   * Get journal entries for the last N days.
+   * Returns array of { date, content }.
+   */
+  getRecent(days = 7) {
+    const results = [];
+    const now = new Date();
+    for (let i = 0; i < days; i++) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const date = d.toISOString().slice(0, 10);
+      const filePath = this._journalPath(date);
+      if (existsSync(filePath)) {
+        results.push({ date, content: readFileSync(filePath, 'utf-8') });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get journal for a specific date.
+   */
+  getEntry(date) {
+    const filePath = this._journalPath(date);
+    if (!existsSync(filePath)) return null;
+    return readFileSync(filePath, 'utf-8');
+  }
+
+  /**
+   * List available journal dates (most recent first).
+   */
+  list(limit = 30) {
+    try {
+      const files = readdirSync(JOURNAL_DIR)
+        .filter(f => f.endsWith('.md'))
+        .map(f => f.replace('.md', ''))
+        .sort()
+        .reverse();
+      return files.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+}

package/src/life/memory.js

@@ -0,0 +1,283 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } 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 EPISODIC_DIR = join(LIFE_DIR, 'memories', 'episodic');
+const SEMANTIC_FILE = join(LIFE_DIR, 'memories', 'semantic', 'topics.json');
+
+function today() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function genId(prefix = 'ep') {
+  return `${prefix}_${randomBytes(4).toString('hex')}`;
+}
+
+export class MemoryManager {
+  constructor() {
+    this._episodicCache = new Map(); // date -> array
+    this._semanticCache = null;
+    mkdirSync(EPISODIC_DIR, { recursive: true });
+    mkdirSync(join(LIFE_DIR, 'memories', 'semantic'), { recursive: true });
+  }
+
+  // ── Episodic Memories ──────────────────────────────────────────
+
+  _episodicPath(date) {
+    return join(EPISODIC_DIR, `${date}.json`);
+  }
+
+  _loadEpisodicDay(date) {
+    if (this._episodicCache.has(date)) return this._episodicCache.get(date);
+    const filePath = this._episodicPath(date);
+    let entries = [];
+    if (existsSync(filePath)) {
+      try {
+        entries = JSON.parse(readFileSync(filePath, 'utf-8'));
+      } catch {
+        entries = [];
+      }
+    }
+    this._episodicCache.set(date, entries);
+    return entries;
+  }
+
+  _saveEpisodicDay(date, entries) {
+    this._episodicCache.set(date, entries);
+    writeFileSync(this._episodicPath(date), JSON.stringify(entries, null, 2), 'utf-8');
+  }
+
+  /**
+   * Add an episodic memory.
+   * @param {{ type: string, source: string, summary: string, tags?: string[], importance?: number, userId?: string }} memory
+   */
+  addEpisodic(memory) {
+    const logger = getLogger();
+    const date = today();
+    const entries = this._loadEpisodicDay(date);
+    const entry = {
+      id: genId('ep'),
+      timestamp: Date.now(),
+      type: memory.type || 'interaction',
+      source: memory.source || 'user_chat',
+      userId: memory.userId || null,
+      summary: memory.summary,
+      tags: memory.tags || [],
+      importance: memory.importance || 5,
+    };
+    entries.push(entry);
+    this._saveEpisodicDay(date, entries);
+    logger.debug(`[Memory] Added episodic: "${entry.summary.slice(0, 80)}" (${entry.id})`);
+    return entry;
+  }
+
+  /**
+   * Get recent episodic memories within the last N hours.
+   */
+  getRecentEpisodic(hours = 24, limit = 20) {
+    const cutoff = Date.now() - hours * 3600_000;
+    const results = [];
+
+    // Check today and recent days
+    const daysToCheck = Math.ceil(hours / 24) + 1;
+    const dates = this._getRecentDates(daysToCheck);
+
+    for (const date of dates) {
+      const entries = this._loadEpisodicDay(date);
+      for (const entry of entries) {
+        if (entry.timestamp >= cutoff) results.push(entry);
+      }
+    }
+
+    results.sort((a, b) => b.timestamp - a.timestamp);
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Get memories about a specific user.
+   */
+  getMemoriesAboutUser(userId, limit = 10) {
+    const results = [];
+    const dates = this._getRecentDates(90);
+
+    for (const date of dates) {
+      const entries = this._loadEpisodicDay(date);
+      for (const entry of entries) {
+        if (entry.userId === String(userId)) results.push(entry);
+      }
+    }
+
+    results.sort((a, b) => b.timestamp - a.timestamp);
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Search episodic memories by keyword (simple substring match on summary + tags).
+   */
+  searchEpisodic(query, limit = 10) {
+    const q = query.toLowerCase();
+    const results = [];
+    const dates = this._getRecentDates(90);
+
+    for (const date of dates) {
+      const entries = this._loadEpisodicDay(date);
+      for (const entry of entries) {
+        const haystack = `${entry.summary} ${entry.tags.join(' ')}`.toLowerCase();
+        if (haystack.includes(q)) results.push(entry);
+      }
+    }
+
+    results.sort((a, b) => b.importance - a.importance || b.timestamp - a.timestamp);
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Prune episodic memories older than N days.
+   */
+  pruneOld(daysToKeep = 90) {
+    const logger = getLogger();
+    const cutoffDate = new Date(Date.now() - daysToKeep * 86400_000).toISOString().slice(0, 10);
+    let pruned = 0;
+
+    try {
+      const files = readdirSync(EPISODIC_DIR).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        const date = file.replace('.json', '');
+        if (date < cutoffDate) {
+          unlinkSync(join(EPISODIC_DIR, file));
+          this._episodicCache.delete(date);
+          pruned++;
+        }
+      }
+    } catch (err) {
+      logger.warn(`[Memory] Prune error: ${err.message}`);
+    }
+
+    if (pruned > 0) logger.info(`[Memory] Pruned ${pruned} old episodic files`);
+    return pruned;
+  }
+
+  _getRecentDates(days) {
+    const dates = [];
+    const now = new Date();
+    for (let i = 0; i < days; i++) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      dates.push(d.toISOString().slice(0, 10));
+    }
+    return dates;
+  }
+
+  // ── Semantic Knowledge ─────────────────────────────────────────
+
+  _loadSemantic() {
+    if (this._semanticCache) return this._semanticCache;
+    if (existsSync(SEMANTIC_FILE)) {
+      try {
+        this._semanticCache = JSON.parse(readFileSync(SEMANTIC_FILE, 'utf-8'));
+      } catch {
+        this._semanticCache = {};
+      }
+    } else {
+      this._semanticCache = {};
+    }
+    return this._semanticCache;
+  }
+
+  _saveSemantic() {
+    writeFileSync(SEMANTIC_FILE, JSON.stringify(this._semanticCache || {}, null, 2), 'utf-8');
+  }
+
+  /**
+   * Add or update semantic knowledge.
+   * @param {string} topic - Topic key (e.g. "rust_ownership")
+   * @param {{ summary: string, sources?: string[], relatedTopics?: string[] }} knowledge
+   */
+  addSemantic(topic, knowledge) {
+    const logger = getLogger();
+    const data = this._loadSemantic();
+    const key = topic.toLowerCase().replace(/\s+/g, '_');
+    const existing = data[key];
+
+    data[key] = {
+      summary: knowledge.summary,
+      sources: [...new Set([...(existing?.sources || []), ...(knowledge.sources || [])])],
+      learnedAt: Date.now(),
+      relatedTopics: [...new Set([...(existing?.relatedTopics || []), ...(knowledge.relatedTopics || [])])],
+    };
+
+    this._semanticCache = data;
+    this._saveSemantic();
+    logger.debug(`[Memory] Updated semantic topic: ${key}`);
+    return data[key];
+  }
+
+  /**
+   * Search semantic knowledge by keyword.
+   */
+  searchSemantic(query, limit = 5) {
+    const q = query.toLowerCase();
+    const data = this._loadSemantic();
+    const results = [];
+
+    for (const [key, val] of Object.entries(data)) {
+      const haystack = `${key} ${val.summary} ${val.relatedTopics.join(' ')}`.toLowerCase();
+      if (haystack.includes(q)) {
+        results.push({ topic: key, ...val });
+      }
+    }
+
+    results.sort((a, b) => b.learnedAt - a.learnedAt);
+    return results.slice(0, limit);
+  }
+
+  // ── Prompt Builder ─────────────────────────────────────────────
+
+  /**
+   * Build a context block of relevant memories for the orchestrator prompt.
+   * Pulls recent episodic + user-specific + semantic topics.
+   * Capped to ~1500 chars.
+   */
+  buildContextBlock(userId = null) {
+    const sections = [];
+
+    // Recent general memories (last 24h, top 5)
+    const recent = this.getRecentEpisodic(24, 5);
+    if (recent.length > 0) {
+      const lines = recent.map(m => {
+        const ago = Math.round((Date.now() - m.timestamp) / 60000);
+        const timeLabel = ago < 60 ? `${ago}m ago` : `${Math.round(ago / 60)}h ago`;
+        return `- ${m.summary} (${timeLabel})`;
+      });
+      sections.push(`Recent:\n${lines.join('\n')}`);
+    }
+
+    // User-specific memories (top 3)
+    if (userId) {
+      const userMems = this.getMemoriesAboutUser(userId, 3);
+      if (userMems.length > 0) {
+        const lines = userMems.map(m => `- ${m.summary}`);
+        sections.push(`About this user:\n${lines.join('\n')}`);
+      }
+    }
+
+    // Semantic knowledge (last 3 learned)
+    const data = this._loadSemantic();
+    const semanticEntries = Object.entries(data)
+      .sort((a, b) => b[1].learnedAt - a[1].learnedAt)
+      .slice(0, 3);
+    if (semanticEntries.length > 0) {
+      const lines = semanticEntries.map(([key, val]) => `- **${key}**: ${val.summary.slice(0, 100)}`);
+      sections.push(`Knowledge:\n${lines.join('\n')}`);
+    }
+
+    if (sections.length === 0) return null;
+
+    let block = sections.join('\n\n');
+    if (block.length > 1500) block = block.slice(0, 1500) + '\n...';
+    return block;
+  }
+}