@kernel.chat/kbot 3.63.0 → 3.64.0

package/dist/agent.js

@@ -17,6 +17,7 @@ import { getMatrixSystemPrompt } from './matrix.js';
 import { buildFullLearningContext, findPattern, recordPattern, cacheSolution, updateProfile, classifyTask, extractKeywords, learnFromExchange, updateProjectMemory, shouldAutoTrain, selfTrain, } from './learning.js';
 import { getMemoryPrompt, addTurn, getPreviousMessages, getHistory } from './memory.js';
 import { getDreamPrompt, dreamAfterSession } from './dream.js';
+import { notifyTurn, startMemoryScanner, stopMemoryScanner } from './memory-scanner.js';
 import { autoCompact, compressToolResult } from './context-manager.js';
 import { learnedRoute, recordRoute } from './learned-router.js';
 import { buildCacheablePrompt, createPromptSections } from './prompt-cache.js';
@@ -747,7 +748,9 @@ export async function runAgent(message, options = {}) {
         const localResult = await tryLocalFirst(message);
         if (localResult !== null) {
             addTurn({ role: 'user', content: message }, memSession);
+            notifyTurn({ role: 'user', content: message }, memSession);
             addTurn({ role: 'assistant', content: localResult }, memSession);
+            notifyTurn({ role: 'assistant', content: localResult }, memSession);
             ui.onInfo('(handled locally — 0 tokens used)');
             return { content: localResult, agent: 'local', model: 'none', toolCalls: 0 };
         }
@@ -776,7 +779,9 @@ export async function runAgent(message, options = {}) {
             }, { autoApprove: false, onApproval: async () => true });
             const summary = formatPlanSummary(plan);
             addTurn({ role: 'user', content: message }, memSession);
+            notifyTurn({ role: 'user', content: message }, memSession);
             addTurn({ role: 'assistant', content: summary }, memSession);
+            notifyTurn({ role: 'assistant', content: summary }, memSession);
             return {
                 content: summary,
                 agent: options.agent || 'coder',
@@ -998,6 +1003,8 @@ Always quote file paths that contain spaces. Never reference internal system nam
         model: options.model || 'auto',
         message: originalMessage.slice(0, 200),
     });
+    // Start passive memory scanner for this session
+    startMemoryScanner();
     // ── Gödel limits: detect undecidable loops and hand off to human ──
     const loopDetector = new LoopDetector({
         maxToolRepeats: 5,
@@ -1293,7 +1300,9 @@ Always quote file paths that contain spaces. Never reference internal system nam
                     catch { /* self-eval errors are non-critical */ }
                 }
                 addTurn({ role: 'user', content: originalMessage }, memSession);
+                notifyTurn({ role: 'user', content: originalMessage }, memSession);
                 addTurn({ role: 'assistant', content }, memSession);
+                notifyTurn({ role: 'assistant', content }, memSession);
                 // ── Recursive Learning: record what worked (async — non-blocking) ──
                 const totalTokens = lastResponse.usage
                     ? (lastResponse.usage.input_tokens || 0) + (lastResponse.usage.output_tokens || 0)
@@ -1604,6 +1613,8 @@ Always quote file paths that contain spaces. Never reference internal system nam
         reason: 'loop_exhausted',
     });
     telemetry.destroy().catch(() => { });
+    // ── Memory Scanner: stop and persist session stats ──
+    stopMemoryScanner();
     // ── Dream Engine: consolidate session memories (non-blocking, $0 via Ollama) ──
     dreamAfterSession(sessionId);
     const content = lastResponse?.content || 'Reached maximum tool iterations.';

package/dist/buddy.d.ts

@@ -0,0 +1,33 @@
+export type BuddySpecies = 'fox' | 'owl' | 'cat' | 'robot' | 'ghost' | 'mushroom' | 'octopus' | 'dragon';
+export type BuddyMood = 'idle' | 'thinking' | 'success' | 'error' | 'learning';
+export interface BuddyState {
+    species: BuddySpecies;
+    name: string;
+    mood: BuddyMood;
+}
+/** Get the buddy's current state (species, name, mood) */
+export declare function getBuddy(): BuddyState;
+/** Set the buddy's mood */
+export declare function setBuddyMood(mood: BuddyMood): void;
+/** Get the ASCII sprite for the buddy in the given mood (defaults to current) */
+export declare function getBuddySprite(mood?: BuddyMood): string[];
+/** Get a random greeting for the buddy */
+export declare function getBuddyGreeting(): string;
+/** Rename the buddy (persisted to ~/.kbot/buddy.json) */
+export declare function renameBuddy(newName: string): void;
+/**
+ * Format the buddy with a speech bubble and status message.
+ * Returns a multi-line string ready for terminal output.
+ *
+ *   .----------------.
+ *   | Status message  |
+ *   '----------------'
+ *     /\   /\
+ *    ( o . o )
+ *     > ^ <
+ *    /|   |\
+ *   (_|   |_)
+ *   ~ Patch the fox ~
+ */
+export declare function formatBuddyStatus(message?: string): string;
+//# sourceMappingURL=buddy.d.ts.map

package/dist/buddy.js

@@ -0,0 +1,468 @@
+// kbot Buddy System — Terminal companion sprites
+//
+// Deterministic companion assignment based on config path hash.
+// Same user always gets the same buddy. Mood changes based on session activity.
+// Pure ASCII art, max 5 lines tall, 15 chars wide. Tamagotchi energy.
+//
+// Persists buddy name to ~/.kbot/buddy.json
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+// ── Paths ──
+const KBOT_DIR = join(homedir(), '.kbot');
+const BUDDY_FILE = join(KBOT_DIR, 'buddy.json');
+const CONFIG_PATH = join(KBOT_DIR, 'config.json');
+// ── Species list (order matters — index = hash result) ──
+const SPECIES = [
+    'fox', 'owl', 'cat', 'robot', 'ghost', 'mushroom', 'octopus', 'dragon',
+];
+// ── Default names per species ──
+const DEFAULT_NAMES = {
+    fox: 'Patch',
+    owl: 'Hoot',
+    cat: 'Pixel',
+    robot: 'Bolt',
+    ghost: 'Wisp',
+    mushroom: 'Spore',
+    octopus: 'Ink',
+    dragon: 'Ember',
+};
+// ── ASCII Sprites ──
+// Each sprite is an array of strings (lines). Max 5 lines, max 15 chars wide.
+// Pure ASCII only — no unicode box drawing.
+const SPRITES = {
+    fox: {
+        idle: [
+            '  /\\   /\\  ',
+            ' ( o . o ) ',
+            '  > ^ <   ',
+            ' /|   |\\  ',
+            '(_|   |_) ',
+        ],
+        thinking: [
+            '  /\\   /\\  ',
+            ' ( o . o ) ',
+            '  > ~ <  ..',
+            ' /|   |\\   ',
+            '(_|   |_)  ',
+        ],
+        success: [
+            '  /\\   /\\  ',
+            ' ( ^ . ^ ) ',
+            '  > w <   ',
+            ' \\|   |/  ',
+            '  |   |   ',
+        ],
+        error: [
+            '  /\\   /\\  ',
+            ' ( ; . ; ) ',
+            '  > n <   ',
+            ' /|   |\\  ',
+            '(_|   |_) ',
+        ],
+        learning: [
+            '  /\\   /\\  ',
+            ' ( o . o ) ',
+            '  > - < |] ',
+            ' /|   |\\   ',
+            '(_|   |_)  ',
+        ],
+    },
+    owl: {
+        idle: [
+            '  {o,o}  ',
+            '  /)__)  ',
+            ' -"--"-- ',
+            '  |  |   ',
+            '  ^  ^   ',
+        ],
+        thinking: [
+            '  {o,o}  ',
+            '  /)__)..',
+            ' -"--"-- ',
+            '  |  |   ',
+            '  ^  ^   ',
+        ],
+        success: [
+            '  {^,^}  ',
+            '  /)__)  ',
+            ' -"--"-- ',
+            ' \\|  |/  ',
+            '  ^  ^   ',
+        ],
+        error: [
+            '  {;,;}  ',
+            '  /)__)  ',
+            ' -"--"-- ',
+            '  |  |   ',
+            '  ^  ^   ',
+        ],
+        learning: [
+            '  {o,o}  ',
+            '  /)__)|]',
+            ' -"--"-- ',
+            '  |  |   ',
+            '  ^  ^   ',
+        ],
+    },
+    cat: {
+        idle: [
+            ' /\\_/\\   ',
+            '( o.o )  ',
+            ' > ^ <   ',
+            ' |   |   ',
+            '  ~ ~    ',
+        ],
+        thinking: [
+            ' /\\_/\\   ',
+            '( o.o )..',
+            ' > ^ <   ',
+            ' |   |   ',
+            '  ~ ~    ',
+        ],
+        success: [
+            ' /\\_/\\   ',
+            '( ^.^ )  ',
+            ' > w <   ',
+            ' \\   /   ',
+            '  ~ ~    ',
+        ],
+        error: [
+            ' /\\_/\\   ',
+            '( ;.; )  ',
+            ' > n <   ',
+            ' |   |   ',
+            '  ~ ~    ',
+        ],
+        learning: [
+            ' /\\_/\\   ',
+            '( o.o )  ',
+            ' > - <|] ',
+            ' |   |   ',
+            '  ~ ~    ',
+        ],
+    },
+    robot: {
+        idle: [
+            ' [=====] ',
+            ' |[o o]| ',
+            ' |  _  | ',
+            ' |_____| ',
+            '  || ||  ',
+        ],
+        thinking: [
+            ' [=====] ',
+            ' |[o o]|.',
+            ' |  _  |.',
+            ' |_____| ',
+            '  || ||  ',
+        ],
+        success: [
+            ' [=====] ',
+            ' |[^ ^]| ',
+            ' | \\_/ | ',
+            ' |_____| ',
+            ' \\|| ||/ ',
+        ],
+        error: [
+            ' [=====] ',
+            ' |[x x]| ',
+            ' |  ~  | ',
+            ' |_____| ',
+            '  || ||  ',
+        ],
+        learning: [
+            ' [=====] ',
+            ' |[o o]| ',
+            ' |  _  | ',
+            ' |_____|]',
+            '  || ||  ',
+        ],
+    },
+    ghost: {
+        idle: [
+            '  .---.  ',
+            ' / o o \\ ',
+            '|   o   |',
+            ' |     | ',
+            '  ~~W~~  ',
+        ],
+        thinking: [
+            '  .---.  ',
+            ' / o o \\..',
+            '|   o   |',
+            ' |     | ',
+            '  ~~W~~  ',
+        ],
+        success: [
+            '  .---.  ',
+            ' / ^ ^ \\ ',
+            '|   v   |',
+            ' |     | ',
+            '  ~~W~~  ',
+        ],
+        error: [
+            '  .---.  ',
+            ' / ; ; \\ ',
+            '|   ~   |',
+            ' |     | ',
+            '  ~~W~~  ',
+        ],
+        learning: [
+            '  .---.  ',
+            ' / o o \\ ',
+            '|   o  |]',
+            ' |     | ',
+            '  ~~W~~  ',
+        ],
+    },
+    mushroom: {
+        idle: [
+            '  .-^-.  ',
+            ' / o o \\ ',
+            '|_______|',
+            '   | |   ',
+            '   |_|   ',
+        ],
+        thinking: [
+            '  .-^-.  ',
+            ' / o o \\..',
+            '|_______|',
+            '   | |   ',
+            '   |_|   ',
+        ],
+        success: [
+            '  .-^-.  ',
+            ' / ^ ^ \\ ',
+            '|_______|',
+            '  \\| |/  ',
+            '   |_|   ',
+        ],
+        error: [
+            '  .-^-.  ',
+            ' / ; ; \\ ',
+            '|_______|',
+            '   | |   ',
+            '   |_|   ',
+        ],
+        learning: [
+            '  .-^-.  ',
+            ' / o o \\ ',
+            '|______|]',
+            '   | |   ',
+            '   |_|   ',
+        ],
+    },
+    octopus: {
+        idle: [
+            '  .---.  ',
+            ' / o o \\ ',
+            '|  ---  |',
+            ' \\/\\/\\/\\/ ',
+            '  ~ ~ ~  ',
+        ],
+        thinking: [
+            '  .---.  ',
+            ' / o o \\..',
+            '|  ---  |',
+            ' \\/\\/\\/\\/ ',
+            '  ~ ~ ~  ',
+        ],
+        success: [
+            '  .---.  ',
+            ' / ^ ^ \\ ',
+            '|  \\_/  |',
+            ' \\/\\/\\/\\/ ',
+            ' \\~ ~ ~/ ',
+        ],
+        error: [
+            '  .---.  ',
+            ' / ; ; \\ ',
+            '|  ~~~  |',
+            ' \\/\\/\\/\\/ ',
+            '  ~ ~ ~  ',
+        ],
+        learning: [
+            '  .---.  ',
+            ' / o o \\ ',
+            '|  --- |]',
+            ' \\/\\/\\/\\/ ',
+            '  ~ ~ ~  ',
+        ],
+    },
+    dragon: {
+        idle: [
+            '  /\\_    ',
+            ' / o >   ',
+            '|  --/\\  ',
+            ' \\/\\/    ',
+            '  ^^     ',
+        ],
+        thinking: [
+            '  /\\_    ',
+            ' / o > ..',
+            '|  --/\\  ',
+            ' \\/\\/    ',
+            '  ^^     ',
+        ],
+        success: [
+            '  /\\_    ',
+            ' / ^ >*  ',
+            '|  --/\\  ',
+            ' \\/\\/ ~  ',
+            '  ^^     ',
+        ],
+        error: [
+            '  /\\_    ',
+            ' / ; >   ',
+            '|  --/\\  ',
+            ' \\/\\/    ',
+            '  ^^     ',
+        ],
+        learning: [
+            '  /\\_    ',
+            ' / o >   ',
+            '|  --/|] ',
+            ' \\/\\/    ',
+            '  ^^     ',
+        ],
+    },
+};
+// ── Greetings per species ──
+const GREETINGS = {
+    fox: ['Yip! Ready to dig in.', 'What are we hunting today?', 'Tail wagging. Lets go.'],
+    owl: ['Hoo! I see everything.', 'Wise choice opening kbot.', 'Night shift begins.'],
+    cat: ['Mrow. Fine, lets work.', 'I was napping, but ok.', 'Keyboard is warm. Go.'],
+    robot: ['Systems online.', 'All circuits nominal.', 'Beep boop. Ready.'],
+    ghost: ['Boo... I mean, hi!', 'Haunting your terminal.', 'Floating by to help.'],
+    mushroom: ['Sprouting up!', 'Growing ideas today.', 'Rooted and ready.'],
+    octopus: ['All arms on deck!', 'Eight ways to help.', 'Tentacles ready.'],
+    dragon: ['*tiny flame*', 'Wings stretched. Go.', 'Guarding your code.'],
+};
+// ── Mood messages ──
+const MOOD_MESSAGES = {
+    idle: ['Just hanging out.', 'Waiting for action.', 'Idle but alert.'],
+    thinking: ['Hmm, thinking...', 'Processing...', 'Working on it...'],
+    success: ['Nailed it!', 'That worked!', 'Nice one!'],
+    error: ['Uh oh...', 'That stings.', 'Something broke.'],
+    learning: ['Studying patterns...', 'Learning something.', 'Getting smarter.'],
+};
+// ── State ──
+let currentMood = 'idle';
+let cachedSpecies = null;
+let cachedName = null;
+// ── Config persistence ──
+function ensureDir() {
+    if (!existsSync(KBOT_DIR))
+        mkdirSync(KBOT_DIR, { recursive: true });
+}
+function loadBuddyConfig() {
+    if (!existsSync(BUDDY_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(BUDDY_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveBuddyConfig(config) {
+    ensureDir();
+    writeFileSync(BUDDY_FILE, JSON.stringify(config, null, 2));
+}
+// ── Species assignment (deterministic) ──
+function hashConfigPath() {
+    const hash = createHash('sha256').update(CONFIG_PATH).digest();
+    // Use first 4 bytes as uint32, mod by species count
+    return hash.readUInt32BE(0) % SPECIES.length;
+}
+function resolveSpecies() {
+    if (cachedSpecies)
+        return cachedSpecies;
+    cachedSpecies = SPECIES[hashConfigPath()];
+    return cachedSpecies;
+}
+function resolveName() {
+    if (cachedName)
+        return cachedName;
+    const config = loadBuddyConfig();
+    cachedName = config.name || DEFAULT_NAMES[resolveSpecies()];
+    return cachedName;
+}
+// ── Public API ──
+/** Get the buddy's current state (species, name, mood) */
+export function getBuddy() {
+    return {
+        species: resolveSpecies(),
+        name: resolveName(),
+        mood: currentMood,
+    };
+}
+/** Set the buddy's mood */
+export function setBuddyMood(mood) {
+    currentMood = mood;
+}
+/** Get the ASCII sprite for the buddy in the given mood (defaults to current) */
+export function getBuddySprite(mood) {
+    const m = mood ?? currentMood;
+    const species = resolveSpecies();
+    return SPRITES[species][m];
+}
+/** Get a random greeting for the buddy */
+export function getBuddyGreeting() {
+    const species = resolveSpecies();
+    const greetings = GREETINGS[species];
+    const idx = Math.floor(Math.random() * greetings.length);
+    return greetings[idx];
+}
+/** Rename the buddy (persisted to ~/.kbot/buddy.json) */
+export function renameBuddy(newName) {
+    const config = loadBuddyConfig();
+    config.name = newName.trim();
+    saveBuddyConfig(config);
+    cachedName = config.name;
+}
+/** Pick a random message for the current mood */
+function moodMessage() {
+    const msgs = MOOD_MESSAGES[currentMood];
+    return msgs[Math.floor(Math.random() * msgs.length)];
+}
+/**
+ * Format the buddy with a speech bubble and status message.
+ * Returns a multi-line string ready for terminal output.
+ *
+ *   .----------------.
+ *   | Status message  |
+ *   '----------------'
+ *     /\   /\
+ *    ( o . o )
+ *     > ^ <
+ *    /|   |\
+ *   (_|   |_)
+ *   ~ Patch the fox ~
+ */
+export function formatBuddyStatus(message) {
+    const name = resolveName();
+    const species = resolveSpecies();
+    const sprite = getBuddySprite();
+    const text = message || moodMessage();
+    // Build speech bubble
+    const inner = ` ${text} `;
+    const width = inner.length;
+    const top = '.' + '-'.repeat(width) + '.';
+    const mid = '|' + inner + '|';
+    const bot = "'" + '-'.repeat(width) + "'";
+    const lines = [];
+    lines.push(`  ${top}`);
+    lines.push(`  ${mid}`);
+    lines.push(`  ${bot}`);
+    // Sprite lines
+    for (const line of sprite) {
+        lines.push(`  ${line}`);
+    }
+    // Name tag
+    lines.push(`  ~ ${name} the ${species} ~`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=buddy.js.map

package/dist/memory-scanner.d.ts

@@ -0,0 +1,60 @@
+import { type ConversationTurn } from './memory.js';
+export type MemorySignalKind = 'correction' | 'preference' | 'project_fact' | 'emotional';
+export interface DetectedMemory {
+    /** What kind of signal was detected */
+    kind: MemorySignalKind;
+    /** The extracted memory content to save */
+    content: string;
+    /** The key to use for memory_save */
+    key: string;
+    /** Category for memory_save (fact | preference | pattern | solution) */
+    category: 'fact' | 'preference' | 'pattern' | 'solution';
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Which turn triggered the detection */
+    turnIndex: number;
+    /** Timestamp of detection */
+    detectedAt: string;
+}
+export interface ScannerStats {
+    /** Whether the scanner is currently active */
+    enabled: boolean;
+    /** Total turns observed this session */
+    turnsObserved: number;
+    /** Total scans performed */
+    scansPerformed: number;
+    /** Total moments detected */
+    momentsDetected: number;
+    /** Total memories saved */
+    memoriesSaved: number;
+    /** Breakdown by kind */
+    byKind: Record<MemorySignalKind, number>;
+    /** Recent detections (last 10) */
+    recentDetections: DetectedMemory[];
+    /** Session start time */
+    sessionStart: string;
+}
+interface ScannerState {
+    /** Cumulative stats across sessions */
+    totalScans: number;
+    totalDetections: number;
+    totalSaved: number;
+    /** Last scan timestamp */
+    lastScan: string | null;
+    /** Per-kind cumulative counts */
+    cumulativeByKind: Record<MemorySignalKind, number>;
+}
+/** Notify the scanner that a turn was added. Call after addTurn(). */
+export declare function notifyTurn(turn: ConversationTurn, sessionId?: string): void;
+/** Start the memory scanner for the current session */
+export declare function startMemoryScanner(): void;
+/** Stop the memory scanner and persist stats */
+export declare function stopMemoryScanner(): void;
+/** Get current scanner stats */
+export declare function getMemoryScannerStats(): ScannerStats;
+/** Check if the scanner is currently enabled */
+export declare function isScannerEnabled(): boolean;
+/** Get cumulative stats from disk (across all sessions) */
+export declare function getCumulativeScannerStats(): ScannerState;
+export {};
+//# sourceMappingURL=memory-scanner.d.ts.map