@kernel.chat/kbot 3.62.0 → 3.64.0

package/dist/tools/dream-tools.js

@@ -0,0 +1,159 @@
+// kbot Dream Tools — Agent-accessible memory consolidation
+//
+// Exposes the dream engine to kbot's tool system so agents can:
+//   - Trigger consolidation on demand
+//   - Query the dream journal for insights
+//   - Check dream system status
+//   - Search dreams by keyword
+//   - Reinforce insights that are still relevant
+import { registerTool } from './index.js';
+import { dream, getDreamStatus, getDreamPrompt, searchDreams, reinforceInsight } from '../dream.js';
+export function registerDreamTools() {
+    // ── dream_now ──
+    // Trigger a full dream cycle: consolidate, reinforce, age
+    registerTool({
+        name: 'dream_now',
+        description: 'Run a dream cycle — consolidate session memories into durable insights using local AI. Ages old memories, extracts new patterns, reinforces confirmed knowledge. Uses Ollama ($0 cost). Call this at session end or when the user says "dream" or "consolidate".',
+        parameters: {
+            session_id: {
+                type: 'string',
+                description: 'Session ID to consolidate (default: "default")',
+                required: false,
+                default: 'default',
+            },
+        },
+        tier: 'free',
+        timeout: 120_000, // 2 min — Ollama can be slow on first run
+        execute: async (args) => {
+            const sessionId = args.session_id || 'default';
+            const result = await dream(sessionId);
+            if (!result.success && result.error) {
+                return `Dream cycle (partial): ${result.error}\n` +
+                    `Archived: ${result.archived} aged-out insights\n` +
+                    `Duration: ${result.duration}ms`;
+            }
+            const lines = [
+                `Dream cycle #${result.cycle} complete`,
+                `  New insights: ${result.newInsights}`,
+                `  Reinforced: ${result.reinforced} existing insights`,
+                `  Archived: ${result.archived} aged-out insights`,
+                `  Duration: ${result.duration}ms`,
+            ];
+            if (result.newInsights === 0) {
+                lines.push('  (Session may have been too short or trivial for new insights)');
+            }
+            return lines.join('\n');
+        },
+    });
+    // ── dream_status ──
+    // Check the dream system's current state
+    registerTool({
+        name: 'dream_status',
+        description: 'Show dream engine status — cycle count, active insights, archive size, last dream timestamp. Use this to check if the dream system is healthy and working.',
+        parameters: {},
+        tier: 'free',
+        execute: async () => {
+            const { state, insights, archiveCount } = getDreamStatus();
+            const categoryBreakdown = {};
+            for (const i of insights) {
+                categoryBreakdown[i.category] = (categoryBreakdown[i.category] || 0) + 1;
+            }
+            const avgRelevance = insights.length > 0
+                ? Math.round(insights.reduce((sum, i) => sum + i.relevance, 0) / insights.length * 100)
+                : 0;
+            const lines = [
+                'Dream Engine Status',
+                '═══════════════════',
+                `Cycles completed: ${state.cycles}`,
+                `Last dream: ${state.lastDream || 'never'}`,
+                `Active insights: ${state.activeInsights}`,
+                `Total created: ${state.totalInsights}`,
+                `Total archived: ${state.totalArchived}`,
+                `Archive files: ${archiveCount}`,
+                `Average relevance: ${avgRelevance}%`,
+                '',
+                'Category breakdown:',
+                ...Object.entries(categoryBreakdown).map(([cat, count]) => `  ${cat}: ${count}`),
+            ];
+            if (insights.length > 0) {
+                lines.push('', 'Top 5 insights:');
+                for (const i of insights.slice(0, 5)) {
+                    lines.push(`  [${Math.round(i.relevance * 100)}%] [${i.category}] ${i.content}`);
+                }
+            }
+            return lines.join('\n');
+        },
+    });
+    // ── dream_journal ──
+    // Get dream insights formatted for system prompt injection
+    registerTool({
+        name: 'dream_journal',
+        description: 'Retrieve the dream journal — consolidated insights from past sessions, ranked by relevance. Use this to understand accumulated knowledge about the user and their projects.',
+        parameters: {
+            max_insights: {
+                type: 'number',
+                description: 'Maximum insights to return (default: 15)',
+                required: false,
+                default: 15,
+            },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const max = args.max_insights || 15;
+            const prompt = getDreamPrompt(max);
+            return prompt || 'Dream journal is empty — no consolidation cycles have run yet. Use dream_now to start.';
+        },
+    });
+    // ── dream_search ──
+    // Search dreams by keyword
+    registerTool({
+        name: 'dream_search',
+        description: 'Search dream insights by keyword. Returns matching insights sorted by relevance.',
+        parameters: {
+            query: {
+                type: 'string',
+                description: 'Search query (keywords)',
+                required: true,
+            },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const query = args.query;
+            if (!query)
+                return 'Error: query is required';
+            const results = searchDreams(query);
+            if (results.length === 0)
+                return `No dream insights match "${query}"`;
+            const lines = [`Dream search: "${query}" — ${results.length} results`, ''];
+            for (const i of results.slice(0, 10)) {
+                lines.push(`[${i.id}] [${Math.round(i.relevance * 100)}%] [${i.category}] ${i.content}`);
+                lines.push(`  Keywords: ${i.keywords.join(', ')} | Sessions: ${i.sessions} | Created: ${i.created.split('T')[0]}`);
+            }
+            return lines.join('\n');
+        },
+    });
+    // ── dream_reinforce ──
+    // Manually boost an insight's relevance
+    registerTool({
+        name: 'dream_reinforce',
+        description: 'Reinforce a dream insight — boost its relevance when the user confirms it is still accurate/useful. Prevents important insights from aging out.',
+        parameters: {
+            insight_id: {
+                type: 'string',
+                description: 'The dream insight ID to reinforce',
+                required: true,
+            },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const id = args.insight_id;
+            if (!id)
+                return 'Error: insight_id is required';
+            const success = reinforceInsight(id);
+            return success
+                ? `Reinforced insight ${id} — relevance boosted, decay clock reset.`
+                : `Insight ${id} not found.`;
+        },
+    });
+} // end registerDreamTools
+//# sourceMappingURL=dream-tools.js.map

package/dist/tools/index.js

@@ -298,6 +298,10 @@ const LAZY_MODULE_IMPORTS = [
     { path: './hacker-toolkit.js', registerFn: 'registerHackerToolkitTools' },
     { path: './dj-set-builder.js', registerFn: 'registerDjSetBuilderTools' },
     { path: './serum2-preset.js', registerFn: 'registerSerum2PresetTools' },
+    { path: './dream-tools.js', registerFn: 'registerDreamTools' },
+    { path: './memory-scanner-tools.js', registerFn: 'registerMemoryScannerTools' },
+    { path: './buddy-tools.js', registerFn: 'registerBuddyTools' },
+    { path: './voice-input-tools.js', registerFn: 'registerVoiceInputTools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

package/dist/tools/memory-scanner-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerMemoryScannerTools(): void;
+//# sourceMappingURL=memory-scanner-tools.d.ts.map

package/dist/tools/memory-scanner-tools.js

@@ -0,0 +1,87 @@
+// kbot Memory Scanner Tools — Agent-accessible controls for the passive scanner
+//
+// Two tools:
+//   - memory_scan_status: Show scanner stats (moments detected, memories saved, etc.)
+//   - memory_scan_toggle: Enable/disable the passive scanner
+import { registerTool } from './index.js';
+import { getMemoryScannerStats, getCumulativeScannerStats, startMemoryScanner, stopMemoryScanner, isScannerEnabled, } from '../memory-scanner.js';
+export function registerMemoryScannerTools() {
+    // ── memory_scan_status ──
+    registerTool({
+        name: 'memory_scan_status',
+        description: 'Show memory scanner status — how many turns observed, scans performed, memory-worthy moments detected, memories saved, and breakdown by signal kind (corrections, preferences, project facts, emotional). Includes cumulative stats across all sessions.',
+        parameters: {},
+        tier: 'free',
+        timeout: 5_000,
+        async execute() {
+            const stats = getMemoryScannerStats();
+            const cumulative = getCumulativeScannerStats();
+            const lines = [
+                'Memory Scanner Status',
+                '═════════════════════',
+                `State: ${stats.enabled ? 'ACTIVE' : 'PAUSED'}`,
+                `Session start: ${stats.sessionStart.split('T')[0]} ${stats.sessionStart.split('T')[1]?.slice(0, 8) || ''}`,
+                '',
+                '── This Session ──',
+                `Turns observed: ${stats.turnsObserved}`,
+                `Scans performed: ${stats.scansPerformed}`,
+                `Moments detected: ${stats.momentsDetected}`,
+                `Memories saved: ${stats.memoriesSaved}`,
+                '',
+                'Signal breakdown:',
+                `  Corrections:   ${stats.byKind.correction}`,
+                `  Preferences:   ${stats.byKind.preference}`,
+                `  Project facts: ${stats.byKind.project_fact}`,
+                `  Emotional:     ${stats.byKind.emotional}`,
+            ];
+            if (stats.recentDetections.length > 0) {
+                lines.push('', 'Recent detections:');
+                for (const d of stats.recentDetections.slice(-5)) {
+                    const time = d.detectedAt.split('T')[1]?.slice(0, 8) || '';
+                    lines.push(`  [${time}] [${d.kind}] (${Math.round(d.confidence * 100)}%) ${d.content.slice(0, 100)}${d.content.length > 100 ? '...' : ''}`);
+                }
+            }
+            lines.push('', '── Cumulative (all sessions) ──', `Total scans: ${cumulative.totalScans + stats.scansPerformed}`, `Total detections: ${cumulative.totalDetections + stats.momentsDetected}`, `Total saved: ${cumulative.totalSaved + stats.memoriesSaved}`, `Last scan: ${cumulative.lastScan || 'this session'}`, '', 'Cumulative by kind:', `  Corrections:   ${(cumulative.cumulativeByKind.correction || 0) + stats.byKind.correction}`, `  Preferences:   ${(cumulative.cumulativeByKind.preference || 0) + stats.byKind.preference}`, `  Project facts: ${(cumulative.cumulativeByKind.project_fact || 0) + stats.byKind.project_fact}`, `  Emotional:     ${(cumulative.cumulativeByKind.emotional || 0) + stats.byKind.emotional}`);
+            return lines.join('\n');
+        },
+    });
+    // ── memory_scan_toggle ──
+    registerTool({
+        name: 'memory_scan_toggle',
+        description: 'Enable or disable the passive memory scanner. When enabled, the scanner watches conversation turns and auto-saves memory-worthy moments (corrections, preferences, project facts, emotional reactions). Disabling it stops detection but preserves already-saved memories.',
+        parameters: {
+            action: {
+                type: 'string',
+                description: '"enable" to start scanning, "disable" to stop, or "status" to check current state',
+                required: true,
+            },
+        },
+        tier: 'free',
+        timeout: 5_000,
+        async execute(args) {
+            const action = String(args.action || '').toLowerCase().trim();
+            if (action === 'enable' || action === 'on' || action === 'start') {
+                if (isScannerEnabled()) {
+                    return 'Memory scanner is already active.';
+                }
+                startMemoryScanner();
+                return 'Memory scanner enabled. Now passively watching for memory-worthy moments in conversation.';
+            }
+            if (action === 'disable' || action === 'off' || action === 'stop') {
+                if (!isScannerEnabled()) {
+                    return 'Memory scanner is already paused.';
+                }
+                const stats = getMemoryScannerStats();
+                stopMemoryScanner();
+                return `Memory scanner paused. Session summary: ${stats.momentsDetected} moments detected, ${stats.memoriesSaved} memories saved.`;
+            }
+            if (action === 'status') {
+                const active = isScannerEnabled();
+                const stats = getMemoryScannerStats();
+                return `Scanner is ${active ? 'ACTIVE' : 'PAUSED'}. This session: ${stats.turnsObserved} turns observed, ${stats.memoriesSaved} memories saved.`;
+            }
+            return 'Invalid action. Use "enable", "disable", or "status".';
+        },
+    });
+} // end registerMemoryScannerTools
+//# sourceMappingURL=memory-scanner-tools.js.map

package/dist/tools/voice-input-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerVoiceInputTools(): void;
+//# sourceMappingURL=voice-input-tools.d.ts.map

package/dist/tools/voice-input-tools.js

@@ -0,0 +1,132 @@
+// kbot Voice Input Tools — Agent-accessible push-to-talk transcription
+//
+// Exposes local voice input to kbot's tool system so agents can:
+//   - Listen and transcribe speech via push-to-talk
+//   - Check voice input availability (mic, whisper model, recorder)
+//
+// Fully local — no cloud APIs. Uses whisper.cpp or Ollama whisper.
+import { registerTool } from './index.js';
+import { getVoiceInput, checkVoiceInputStatus } from '../voice-input.js';
+export function registerVoiceInputTools() {
+    // ── voice_listen ──
+    // Start listening and return transcribed text
+    registerTool({
+        name: 'voice_listen',
+        description: 'Listen via microphone and transcribe speech to text using local whisper. Push-to-talk: records until silence is detected (up to max duration), then transcribes locally at $0 cost. Requires sox (rec) and whisper.cpp or Ollama whisper model. Returns the transcribed text.',
+        parameters: {
+            model: {
+                type: 'string',
+                description: 'Whisper model size: tiny, base, small, medium, large (default: base). Larger = more accurate but slower.',
+                required: false,
+                default: 'base',
+            },
+            language: {
+                type: 'string',
+                description: 'Language code for transcription (default: en). Examples: en, es, fr, de, ja, zh',
+                required: false,
+                default: 'en',
+            },
+            max_seconds: {
+                type: 'number',
+                description: 'Maximum recording duration in seconds (default: 15). Recording auto-stops on silence.',
+                required: false,
+                default: 15,
+            },
+            silence_threshold: {
+                type: 'string',
+                description: 'Silence detection threshold as percentage for sox (default: 1.5). Lower = more sensitive.',
+                required: false,
+                default: '1.5',
+            },
+        },
+        tier: 'free',
+        timeout: 180_000, // 3 min — recording (up to 15s) + transcription (up to 2 min)
+        execute: async (args) => {
+            const model = args.model || 'base';
+            const language = args.language || 'en';
+            const maxSeconds = args.max_seconds || 15;
+            const silenceThreshold = args.silence_threshold || '1.5';
+            // Validate model
+            const validModels = ['tiny', 'base', 'small', 'medium', 'large'];
+            if (!validModels.includes(model)) {
+                return `Error: invalid model "${model}". Choose from: ${validModels.join(', ')}`;
+            }
+            try {
+                const result = await getVoiceInput({
+                    model: model,
+                    language,
+                    maxRecordSeconds: maxSeconds,
+                    silenceThreshold,
+                });
+                const lines = [
+                    `Transcription: ${result.text}`,
+                    '',
+                    `  Backend: ${result.source}`,
+                    `  Duration: ${result.durationMs}ms`,
+                    `  Language: ${language}`,
+                    `  Model: ${model}`,
+                ];
+                return lines.join('\n');
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                // If it's a setup issue, include helpful guidance
+                if (message.includes('No audio recorder') || message.includes('No transcription engine')) {
+                    const status = await checkVoiceInputStatus();
+                    const guidance = [
+                        `Error: ${message}`,
+                        '',
+                        'Setup suggestions:',
+                        ...status.suggestions.map(s => `  - ${s}`),
+                    ];
+                    return guidance.join('\n');
+                }
+                return `Error: ${message}`;
+            }
+        },
+    });
+    // ── voice_status ──
+    // Check if voice input is available (mic permissions, whisper model)
+    registerTool({
+        name: 'voice_status',
+        description: 'Check voice input readiness — reports whether a microphone recorder (sox/arecord) and transcription engine (whisper.cpp/Ollama whisper) are available. Lists any issues and installation suggestions. Call this before voice_listen to diagnose problems.',
+        parameters: {},
+        tier: 'free',
+        execute: async () => {
+            const status = await checkVoiceInputStatus();
+            const lines = [
+                'Voice Input Status',
+                '══════════════════',
+                `Available: ${status.available ? 'YES' : 'NO'}`,
+                '',
+                'Recorder:',
+                `  Backend: ${status.recorder === 'none' ? 'NOT FOUND' : status.recorder}`,
+                ...(status.recorder === 'rec' ? ['  (sox rec — silence detection, auto-stop)'] : []),
+                ...(status.recorder === 'arecord' ? ['  (ALSA arecord — fixed duration)'] : []),
+                '',
+                'Transcription:',
+                `  Backend: ${status.transcriber === 'none' ? 'NOT FOUND' : status.transcriber}`,
+                ...(status.whisperCliPath ? [`  Whisper CLI: ${status.whisperCliPath}`] : []),
+                `  Ollama reachable: ${status.ollamaReachable ? 'yes' : 'no'}`,
+                `  Ollama whisper model: ${status.ollamaHasWhisper ? 'yes' : 'no'}`,
+            ];
+            if (status.issues.length > 0) {
+                lines.push('', 'Issues:');
+                for (const issue of status.issues) {
+                    lines.push(`  ! ${issue}`);
+                }
+            }
+            if (status.suggestions.length > 0) {
+                lines.push('', 'Suggestions:');
+                for (const suggestion of status.suggestions) {
+                    lines.push(`  - ${suggestion}`);
+                }
+            }
+            if (status.available) {
+                lines.push('', 'Ready to use. Call voice_listen to start recording.');
+            }
+            return lines.join('\n');
+        },
+    });
+} // end registerVoiceInputTools
+//# sourceMappingURL=voice-input-tools.js.map

package/dist/voice-input.d.ts

@@ -0,0 +1,53 @@
+export type WhisperModel = 'tiny' | 'base' | 'small' | 'medium' | 'large';
+export type TranscriptionBackend = 'whisper-cli' | 'ollama' | 'none';
+export type RecorderBackend = 'rec' | 'arecord' | 'none';
+export interface VoiceInputOptions {
+    /** Whisper model size (default: 'base') */
+    model?: WhisperModel;
+    /** Language code for transcription (default: 'en') */
+    language?: string;
+    /** Max recording duration in seconds (default: 15) */
+    maxRecordSeconds?: number;
+    /** Silence threshold for sox-based recording stop, as a percentage (default: '1.5') */
+    silenceThreshold?: string;
+    /** Ollama host URL (default: OLLAMA_HOST env or 'http://localhost:11434') */
+    ollamaHost?: string;
+    /** Ollama whisper model name (default: 'whisper') */
+    ollamaWhisperModel?: string;
+}
+export interface VoiceInputStatus {
+    available: boolean;
+    recorder: RecorderBackend;
+    transcriber: TranscriptionBackend;
+    whisperCliPath: string | null;
+    ollamaReachable: boolean;
+    ollamaHasWhisper: boolean;
+    issues: string[];
+    suggestions: string[];
+}
+export interface TranscriptionResult {
+    text: string;
+    source: TranscriptionBackend;
+    durationMs: number;
+    audioFile: string | null;
+}
+/**
+ * Check voice input system status — microphone, transcription engine, models.
+ * Call this to diagnose issues before recording.
+ */
+export declare function checkVoiceInputStatus(options?: Pick<VoiceInputOptions, 'ollamaHost' | 'ollamaWhisperModel'>): Promise<VoiceInputStatus>;
+/**
+ * Record audio from the microphone and transcribe it locally.
+ * Returns the transcribed text.
+ *
+ * This is the main entry point — call this for push-to-talk.
+ *
+ * @throws Error if no recorder or transcriber is available
+ */
+export declare function getVoiceInput(options?: VoiceInputOptions): Promise<TranscriptionResult>;
+/**
+ * Quick check: can voice input work right now?
+ * Returns true if both a recorder and transcriber are available.
+ */
+export declare function isVoiceInputAvailable(options?: Pick<VoiceInputOptions, 'ollamaHost' | 'ollamaWhisperModel'>): Promise<boolean>;
+//# sourceMappingURL=voice-input.d.ts.map