@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/input/text-to-speech.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 export interface TTSConfig {
     enabled: boolean;
-    provider: 'edge-tts' | 'espeak' | 'say' | 'piper' | 'audioreader' | 'kokoro';
+    provider: 'edge-tts' | 'espeak' | 'say' | 'piper' | 'audioreader';
     voice?: string;
     rate?: string;
     volume?: string;
@@ -62,13 +62,9 @@ export declare class TextToSpeechManager extends EventEmitter {
      */
     private speakWithPiper;
     /**
-     * Speak with AudioReader (Kokoro-82M via local API)
+     * Speak with AudioReader via local API
      */
     private speakWithAudioReader;
-    /**
-     * Speak with local Kokoro TTS model (quantized ONNX hexgrad/Kokoro-82M)
-     */
-    private speakWithKokoro;
     /**
      * Play audio file using available player
      */

package/dist/input/text-to-speech.js

@@ -80,9 +80,6 @@ export class TextToSpeechManager extends EventEmitter {
      * Check if TTS is available
      */
     async isAvailable() {
-        if (this.config.provider === 'kokoro') {
-            return { available: true };
-        }
         // AudioReader uses HTTP API, not a CLI binary
         if (this.config.provider === 'audioreader') {
             try {
@@ -166,9 +163,6 @@ export class TextToSpeechManager extends EventEmitter {
                 case 'audioreader':
                     await this.speakWithAudioReader(text);
                     break;
-                case 'kokoro':
-                    await this.speakWithKokoro(text);
-                    break;
                 default:
                     await this.speakWithEdgeTTS(text, language);
             }
@@ -303,7 +297,7 @@ export class TextToSpeechManager extends EventEmitter {
         });
     }
     /**
-     * Speak with AudioReader (Kokoro-82M via local API)
+     * Speak with AudioReader via local API
      */
     async speakWithAudioReader(text) {
         const voice = this.config.voice || 'ff_siwis';
@@ -311,7 +305,7 @@ export class TextToSpeechManager extends EventEmitter {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
-                model: 'kokoro',
+                model: 'audioreader',
                 input: text,
                 voice,
                 speed: 1.0,
@@ -334,25 +328,6 @@ export class TextToSpeechManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /**
-     * Speak with local Kokoro TTS model (quantized ONNX hexgrad/Kokoro-82M)
-     */
-    async speakWithKokoro(text) {
-        const { kokoroTtsService } = await import('../utils/kokoro-tts.js');
-        const voice = this.config.voice || 'af_bella';
-        const buffer = await kokoroTtsService.generateSpeech(text, voice);
-        const audioFile = path.join(this.tempDir, `tts_${Date.now()}.wav`);
-        fs.writeFileSync(audioFile, buffer);
-        try {
-            await this.playAudio(audioFile);
-        }
-        finally {
-            try {
-                fs.unlinkSync(audioFile);
-            }
-            catch { /* ignore */ }
-        }
-    }
     /**
      * Play audio file using available player
      */

package/dist/integrations/screenpipe/screenpipe-client.d.ts

@@ -7,6 +7,11 @@
  * say / hear?" from screen+audio history — local-first, no cloud. Base URL is
  * configurable via `SCREENPIPE_URL` (default http://localhost:3030).
  *
+ * Recent screenpipe builds require a Bearer token on the local API. Pass it via
+ * `apiKey` (or `SCREENPIPE_API_KEY`) and it is attached as `Authorization:
+ * Bearer <key>` to every request. When unset, requests are sent unauthenticated
+ * exactly as before, so local no-auth instances keep working.
+ *
  * `fetchImpl` is injectable for tests.
  */
 export type ScreenpipeContentType = 'all' | 'ocr' | 'audio' | 'ui';
@@ -37,6 +42,7 @@ export interface ScreenpipeSearchResult {
 type FetchLike = (url: string, init?: {
     method?: string;
     signal?: AbortSignal;
+    headers?: Record<string, string>;
 }) => Promise<{
     ok: boolean;
     status: number;
@@ -45,10 +51,14 @@ type FetchLike = (url: string, init?: {
 export declare class ScreenpipeClient {
     readonly baseUrl: string;
     private readonly doFetch;
+    private readonly apiKey?;
     constructor(opts?: {
         baseUrl?: string;
         fetchImpl?: FetchLike;
+        apiKey?: string;
     });
+    /** Build request headers, attaching Bearer auth when an API key is configured. */
+    private buildHeaders;
     /** True if a screenpipe server answers on the health endpoint. */
     health(timeoutMs?: number): Promise<boolean>;
     /** Search captured screen/audio content. */

package/dist/integrations/screenpipe/screenpipe-client.js

@@ -1,14 +1,23 @@
 export class ScreenpipeClient {
     baseUrl;
     doFetch;
+    apiKey;
     constructor(opts = {}) {
         this.baseUrl = (opts.baseUrl || process.env['SCREENPIPE_URL'] || 'http://localhost:3030').replace(/\/$/, '');
         this.doFetch = opts.fetchImpl ?? globalThis.fetch;
+        const apiKey = opts.apiKey ?? process.env['SCREENPIPE_API_KEY'];
+        if (apiKey)
+            this.apiKey = apiKey;
+    }
+    /** Build request headers, attaching Bearer auth when an API key is configured. */
+    buildHeaders() {
+        return this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : undefined;
     }
     /** True if a screenpipe server answers on the health endpoint. */
     async health(timeoutMs = 2500) {
         try {
-            const res = await this.withTimeout((signal) => this.doFetch(`${this.baseUrl}/health`, { signal }), timeoutMs);
+            const headers = this.buildHeaders();
+            const res = await this.withTimeout((signal) => this.doFetch(`${this.baseUrl}/health`, { signal, ...(headers ? { headers } : {}) }), timeoutMs);
             return res.ok;
         }
         catch {
@@ -33,7 +42,8 @@ export class ScreenpipeClient {
         if (opts.endTime)
             params.set('end_time', opts.endTime);
         const url = `${this.baseUrl}/search?${params.toString()}`;
-        const res = await this.withTimeout((signal) => this.doFetch(url, { signal }), timeoutMs);
+        const headers = this.buildHeaders();
+        const res = await this.withTimeout((signal) => this.doFetch(url, { signal, ...(headers ? { headers } : {}) }), timeoutMs);
         if (!res.ok) {
             throw new Error(`screenpipe /search returned ${res.status}`);
         }

package/dist/integrations/tailscale.d.ts

@@ -32,6 +32,12 @@ export interface TailscaleStatus {
     /** Tailscale version */
     version: string;
 }
+export interface TailnetOllamaPeer {
+    hostname: string;
+    ip: string;
+    baseURL: string;
+    models: string[];
+}
 export declare class TailscaleManager {
     private static instance;
     private config;
@@ -47,6 +53,11 @@ export declare class TailscaleManager {
      * Get live Tailscale status from the CLI.
      */
     getStatus(): Promise<TailscaleStatus>;
+    /**
+     * Discover Ollama peers on the tailnet and return their OpenAI-compatible
+     * endpoints with the models they expose.
+     */
+    discoverOllamaPeers(): Promise<TailnetOllamaPeer[]>;
     /**
      * Start Tailscale Serve (tailnet-only HTTPS).
      */
@@ -81,4 +92,6 @@ export declare class TailscaleManager {
     generateAuthHeaders(): Record<string, string>;
     getConfig(): TailscaleConfig | null;
     setConfig(config: Partial<TailscaleConfig>): void;
+    private readStatusPayload;
+    private listOllamaModels;
 }

package/dist/integrations/tailscale.js

@@ -47,8 +47,8 @@ export class TailscaleManager {
      * Get live Tailscale status from the CLI.
      */
     async getStatus() {
-        const installed = await this.isInstalled();
-        if (!installed) {
+        const payload = await this.readStatusPayload();
+        if (!payload) {
             return {
                 installed: false,
                 running: false,
@@ -60,41 +60,51 @@ export class TailscaleManager {
                 version: '',
             };
         }
+        const status = {
+            installed: true,
+            running: !!payload.BackendState && payload.BackendState === 'Running',
+            hostname: payload.Self?.HostName || '',
+            tailnetName: payload.MagicDNSSuffix || payload.CurrentTailnet?.Name || '',
+            ip: payload.TailscaleIPs?.[0] || payload.Self?.TailscaleIPs?.[0] || '',
+            serving: this.serving,
+            serveUrl: this.getServeUrl(),
+            version: '',
+        };
+        // Get version separately (status --json doesn't always include it)
         try {
-            const { stdout } = await execFileAsync('tailscale', ['status', '--json'], { timeout: EXEC_TIMEOUT });
-            const data = JSON.parse(stdout);
-            const status = {
-                installed: true,
-                running: !!data.BackendState && data.BackendState === 'Running',
-                hostname: data.Self?.HostName || '',
-                tailnetName: data.MagicDNSSuffix || data.CurrentTailnet?.Name || '',
-                ip: data.TailscaleIPs?.[0] || data.Self?.TailscaleIPs?.[0] || '',
-                serving: this.serving,
-                serveUrl: this.getServeUrl(),
-                version: '',
-            };
-            // Get version separately (status --json doesn't always include it)
-            try {
-                const { stdout: ver } = await execFileAsync('tailscale', ['version'], { timeout: EXEC_TIMEOUT });
-                status.version = ver.trim().split('\n')[0] ?? '';
-            }
-            catch { /* non-critical */ }
-            this.cachedStatus = status;
-            return status;
+            const { stdout: ver } = await execFileAsync('tailscale', ['version'], { timeout: EXEC_TIMEOUT });
+            status.version = ver.trim().split('\n')[0] ?? '';
         }
-        catch (err) {
-            logger.debug(`Tailscale status failed: ${err instanceof Error ? err.message : String(err)}`);
-            return {
-                installed: true,
-                running: false,
-                hostname: '',
-                tailnetName: '',
-                ip: '',
-                serving: this.serving,
-                serveUrl: null,
-                version: '',
-            };
+        catch { /* non-critical */ }
+        this.cachedStatus = status;
+        return status;
+    }
+    /**
+     * Discover Ollama peers on the tailnet and return their OpenAI-compatible
+     * endpoints with the models they expose.
+     */
+    async discoverOllamaPeers() {
+        const payload = await this.readStatusPayload();
+        if (!payload)
+            return [];
+        const peers = payload.Peer ?? {};
+        const discovered = [];
+        for (const info of Object.values(peers)) {
+            if (!info?.Online)
+                continue;
+            const ip = info.TailscaleIPs?.[0]?.trim();
+            if (!ip)
+                continue;
+            const hostname = (info.HostName ?? info.DNSName ?? '').trim();
+            if (!hostname)
+                continue;
+            const baseURL = `http://${ip}:11434/v1`;
+            const models = await this.listOllamaModels(baseURL);
+            if (!models.length)
+                continue;
+            discovered.push({ hostname, ip, baseURL, models });
         }
+        return discovered;
     }
     /**
      * Start Tailscale Serve (tailnet-only HTTPS).
@@ -250,5 +260,48 @@ export class TailscaleManager {
             };
         }
     }
+    async readStatusPayload() {
+        const installed = await this.isInstalled();
+        if (!installed)
+            return null;
+        try {
+            const { stdout } = await execFileAsync('tailscale', ['status', '--json'], { timeout: EXEC_TIMEOUT });
+            return JSON.parse(stdout);
+        }
+        catch (err) {
+            logger.debug(`Tailscale status failed: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    }
+    async listOllamaModels(baseURL) {
+        const probeUrls = [`${baseURL}/models`, `${baseURL.replace(/\/v1$/, '')}/api/tags`];
+        for (const url of probeUrls) {
+            try {
+                const response = await fetch(url, { signal: AbortSignal.timeout(8_000) });
+                if (!response.ok)
+                    continue;
+                const json = await response.json();
+                const ids = (json.data ?? json.models ?? [])
+                    .map((item) => {
+                    const record = item;
+                    const id = typeof record.id === 'string'
+                        ? record.id.trim()
+                        : typeof record.model === 'string'
+                            ? record.model.trim()
+                            : typeof record.name === 'string'
+                                ? record.name.trim()
+                                : '';
+                    return id || null;
+                })
+                    .filter((value) => Boolean(value));
+                if (ids.length > 0)
+                    return ids;
+            }
+            catch {
+                // try next probe
+            }
+        }
+        return [];
+    }
 }
 //# sourceMappingURL=tailscale.js.map

package/dist/knowledge/workspace-indexer.js

@@ -52,6 +52,9 @@ class BruteForceIndex {
             this.vectors = new Map(data);
         }
     }
+    remove(id) {
+        this.vectors.delete(id);
+    }
 }
 const DEFAULT_CONFIG = {
     workspaceRoot: process.cwd(),
@@ -132,17 +135,57 @@ export class WorkspaceIndexer extends EventEmitter {
                 ignore: this.config.ignorePatterns,
                 absolute: false,
             });
+            const mtimeCachePath = path.join(path.dirname(this.config.indexPath), 'mtimes.json');
+            let mtimeCache = {};
+            try {
+                if (fs.existsSync(mtimeCachePath)) {
+                    mtimeCache = JSON.parse(await fs.readFile(mtimeCachePath, 'utf-8'));
+                }
+            }
+            catch (e) {
+                logger.warn('Failed to load mtime cache, starting fresh.');
+            }
+            const newMtimeCache = {};
+            const filesToIndex = [];
+            const currentFiles = new Set(files);
+            for (const file of files) {
+                const fullPath = path.join(this.config.workspaceRoot, file);
+                try {
+                    const stats = await fs.promises.stat(fullPath);
+                    newMtimeCache[file] = stats.mtimeMs;
+                    if (mtimeCache[file] !== stats.mtimeMs) {
+                        filesToIndex.push(file);
+                    }
+                }
+                catch (err) {
+                    // Can't stat, skip
+                }
+            }
+            const filesToRemove = new Set();
+            for (const file of filesToIndex) {
+                filesToRemove.add(file);
+            }
+            for (const entry of this.entries.values()) {
+                if (!currentFiles.has(entry.filePath)) {
+                    filesToRemove.add(entry.filePath);
+                }
+            }
+            if (filesToRemove.size > 0) {
+                for (const [id, entry] of this.entries.entries()) {
+                    if (filesToRemove.has(entry.filePath)) {
+                        this.entries.delete(id);
+                        if (this.vectorIndex instanceof BruteForceIndex) {
+                            this.vectorIndex.remove(id);
+                        }
+                        else if (this.vectorIndex && this.vectorIndex.remove) {
+                            this.vectorIndex.remove(String(id));
+                        }
+                    }
+                }
+            }
             let processedFiles = 0;
             let totalChunks = 0;
-            // TODO: In a real implementation, we should diff mtimes to only index changed files.
-            // For this PoC, we rebuild the index.
-            this.entries.clear();
-            this.nextId = 0;
-            if (this.vectorIndex.clear)
-                this.vectorIndex.clear();
-            else if (this.vectorIndex instanceof BruteForceIndex)
-                this.vectorIndex = new BruteForceIndex(384);
-            for (const file of files) {
+            for (const file of filesToIndex) {
                 const fullPath = path.join(this.config.workspaceRoot, file);
                 try {
                     const content = await fs.readFile(fullPath, 'utf-8');
@@ -178,6 +221,7 @@ export class WorkspaceIndexer extends EventEmitter {
                     // Skip unreadable files
                 }
             }
+            await fs.writeFile(mtimeCachePath, JSON.stringify(newMtimeCache, null, 2));
             await this.saveIndexMetadata();
             logger.info(`Workspace indexing complete: ${processedFiles} files, ${totalChunks} chunks.`);
             this.emit('indexing:complete', { files: processedFiles, chunks: totalChunks });

package/dist/mcp/client.js

@@ -96,6 +96,7 @@ export class MCPManager extends EventEmitter {
                 this.handleServerError(serverName, error);
             }
         }, 30000);
+        interval.unref?.();
         this.healthCheckIntervals.set(serverName, interval);
     }
     stopHealthCheck(serverName) {

package/dist/mcp/mcp-desktop-tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MCP Desktop Tools — expose Code Buddy's desktop-automation over the MCP server.
+ *
+ * This is the cross-platform equivalent of mediar-ai's Terminator MCP agent, but
+ * backed by Code Buddy's own already-validated automation stack (nut-js input +
+ * AT-SPI/accessibility snapshots + screenshots), so it works on Linux/macOS/Windows
+ * without porting a Windows-only framework.
+ *
+ * Safety model (mirrors the peer.tool / execute_code RPC opt-in pattern):
+ *  - Read-only tools are ALWAYS exposed: `desktop_screenshot`, `desktop_snapshot`.
+ *  - Control tools that actuate the real desktop (`desktop_click`, `desktop_type`,
+ *    `desktop_move_mouse`, `desktop_key`) are GATED behind
+ *    CODEBUDDY_MCP_DESKTOP_CONTROL=1 (fail-closed: not registered when unset).
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Control tools actuate the real desktop — opt-in only. */
+export declare function desktopControlEnabled(): boolean;
+/** Reset the lazily-created manager (tests). */
+export declare function resetDesktopMcpTools(): void;
+/**
+ * Register desktop-automation tools with the MCP server.
+ */
+export declare function registerDesktopTools(server: McpServer): void;

package/dist/mcp/mcp-desktop-tools.js

@@ -0,0 +1,158 @@
+/**
+ * MCP Desktop Tools — expose Code Buddy's desktop-automation over the MCP server.
+ *
+ * This is the cross-platform equivalent of mediar-ai's Terminator MCP agent, but
+ * backed by Code Buddy's own already-validated automation stack (nut-js input +
+ * AT-SPI/accessibility snapshots + screenshots), so it works on Linux/macOS/Windows
+ * without porting a Windows-only framework.
+ *
+ * Safety model (mirrors the peer.tool / execute_code RPC opt-in pattern):
+ *  - Read-only tools are ALWAYS exposed: `desktop_screenshot`, `desktop_snapshot`.
+ *  - Control tools that actuate the real desktop (`desktop_click`, `desktop_type`,
+ *    `desktop_move_mouse`, `desktop_key`) are GATED behind
+ *    CODEBUDDY_MCP_DESKTOP_CONTROL=1 (fail-closed: not registered when unset).
+ */
+import { z } from 'zod';
+import { logger } from '../utils/logger.js';
+/** Control tools actuate the real desktop — opt-in only. */
+export function desktopControlEnabled() {
+    const v = process.env['CODEBUDDY_MCP_DESKTOP_CONTROL'];
+    return v === '1' || v === 'true';
+}
+// Lazily initialize a single automation manager (native provider → mock fallback).
+let managerPromise = null;
+async function getManager() {
+    if (!managerPromise) {
+        managerPromise = (async () => {
+            const { getDesktopAutomation } = await import('../desktop-automation/index.js');
+            const mgr = getDesktopAutomation({ provider: 'native', fallbackProviders: ['nutjs', 'mock'] });
+            await mgr.initialize();
+            return mgr;
+        })().catch((err) => {
+            managerPromise = null; // allow retry on next call
+            throw err;
+        });
+    }
+    return managerPromise;
+}
+/** Reset the lazily-created manager (tests). */
+export function resetDesktopMcpTools() {
+    managerPromise = null;
+}
+function ok(text) {
+    return { content: [{ type: 'text', text }] };
+}
+function fail(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
+/**
+ * Register desktop-automation tools with the MCP server.
+ */
+export function registerDesktopTools(server) {
+    // ---- Read-only: screenshot ------------------------------------------------
+    server.tool('desktop_screenshot', 'Capture a screenshot of the desktop (fullscreen by default, or a region). Returns the saved PNG path and dimensions. Read-only.', {
+        region: z
+            .object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() })
+            .optional()
+            .describe('Optional region {x,y,width,height}; omit for fullscreen'),
+        output_path: z.string().optional().describe('Optional output PNG path'),
+    }, async (args) => {
+        try {
+            const { ScreenshotTool } = await import('../tools/screenshot-tool.js');
+            const tool = new ScreenshotTool();
+            const result = args.region
+                ? await tool.captureRegion(args.region.x, args.region.y, args.region.width, args.region.height)
+                : await tool.capture({ fullscreen: true, ...(args.output_path ? { outputPath: args.output_path } : {}) });
+            if (!result.success)
+                return fail(`Screenshot failed: ${result.error ?? 'unknown error'}`);
+            return ok(result.output ?? JSON.stringify(result.data ?? {}, null, 2));
+        }
+        catch (err) {
+            return fail(`Screenshot error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // ---- Read-only: accessibility snapshot -----------------------------------
+    server.tool('desktop_snapshot', 'Enumerate on-screen UI elements (accessibility tree) with numeric refs, roles, labels, and click coordinates. Read-only. Use the returned coordinates with desktop_click.', {
+        interactive_only: z.boolean().optional().describe('Only return interactive elements (buttons, inputs, links)'),
+        max_elements: z.number().optional().describe('Cap the number of elements returned (default 60, max 200)'),
+        window: z.string().optional().describe('Window title to scope to (default: whole desktop / focused window)'),
+    }, async (args) => {
+        try {
+            const { getSmartSnapshotManager } = await import('../desktop-automation/smart-snapshot.js');
+            const snap = await getSmartSnapshotManager().takeSnapshot({
+                ...(args.interactive_only ? { interactiveOnly: true } : {}),
+                ...(args.window ? { window: args.window } : {}),
+            });
+            const cap = Math.max(1, Math.min(200, args.max_elements ?? 60));
+            const shown = snap.elements.slice(0, cap);
+            const lines = shown.map((el) => `[${el.ref}] ${el.role} ${JSON.stringify(el.name)}${el.interactive ? ' (interactive)' : ''} @ ${Math.round(el.center.x)},${Math.round(el.center.y)} [${el.bounds.width}x${el.bounds.height}]`);
+            const header = `${snap.elements.length} element(s) on "${snap.source}" (${snap.screenSize.width}x${snap.screenSize.height}); showing ${shown.length}:`;
+            return ok(`${header}\n${lines.join('\n')}`);
+        }
+        catch (err) {
+            return fail(`Snapshot error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // ---- Control tools (opt-in, actuate the real desktop) --------------------
+    if (!desktopControlEnabled()) {
+        logger.debug('MCP desktop control tools disabled. Set CODEBUDDY_MCP_DESKTOP_CONTROL=1 to expose desktop_click/type/move_mouse/key.');
+        return;
+    }
+    server.tool('desktop_click', 'Click the mouse at screen coordinates. Requires CODEBUDDY_MCP_DESKTOP_CONTROL=1. Actuates the real desktop.', {
+        x: z.number().describe('X coordinate'),
+        y: z.number().describe('Y coordinate'),
+        button: z.enum(['left', 'right', 'middle']).optional().describe('Mouse button (default left)'),
+        double: z.boolean().optional().describe('Double-click when true'),
+    }, async (args) => {
+        try {
+            const mgr = await getManager();
+            await mgr.click(args.x, args.y, {
+                ...(args.button ? { button: args.button } : {}),
+                ...(args.double ? { clicks: 2 } : {}),
+            });
+            return ok(`Clicked ${args.button ?? 'left'}${args.double ? ' (double)' : ''} at ${args.x},${args.y}.`);
+        }
+        catch (err) {
+            return fail(`Click error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    server.tool('desktop_move_mouse', 'Move the mouse cursor to screen coordinates. Requires CODEBUDDY_MCP_DESKTOP_CONTROL=1.', { x: z.number().describe('X coordinate'), y: z.number().describe('Y coordinate') }, async (args) => {
+        try {
+            const mgr = await getManager();
+            await mgr.moveMouse(args.x, args.y);
+            return ok(`Moved mouse to ${args.x},${args.y}.`);
+        }
+        catch (err) {
+            return fail(`Move error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    server.tool('desktop_type', 'Type text at the current focus. Requires CODEBUDDY_MCP_DESKTOP_CONTROL=1. Actuates the real keyboard.', { text: z.string().describe('Text to type') }, async (args) => {
+        try {
+            const mgr = await getManager();
+            await mgr.type(args.text);
+            return ok(`Typed ${args.text.length} character(s).`);
+        }
+        catch (err) {
+            return fail(`Type error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    server.tool('desktop_key', 'Press a key (optionally with modifiers), e.g. "enter", "escape", "tab", "f5". Requires CODEBUDDY_MCP_DESKTOP_CONTROL=1.', {
+        key: z.string().describe('Key name, e.g. enter, escape, tab, a, f5'),
+        modifiers: z
+            .array(z.enum(['ctrl', 'alt', 'shift', 'meta', 'cmd', 'win']))
+            .optional()
+            .describe('Modifier keys to hold'),
+    }, async (args) => {
+        try {
+            const mgr = await getManager();
+            await mgr.keyPress(args.key, args.modifiers && args.modifiers.length > 0
+                ? { modifiers: args.modifiers }
+                : undefined);
+            return ok(`Pressed ${args.modifiers?.length ? args.modifiers.join('+') + '+' : ''}${args.key}.`);
+        }
+        catch (err) {
+            return fail(`Key error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+//# sourceMappingURL=mcp-desktop-tools.js.map

package/dist/mcp/mcp-resources.js

@@ -17,9 +17,8 @@ export function registerResources(server) {
         mimeType: 'text/markdown',
     }, async () => {
         try {
-            const { loadContext, formatContextForPrompt } = await import('../context/context-files.js');
-            const context = await loadContext(process.cwd());
-            let text = formatContextForPrompt(context);
+            const { resolveProjectContext } = await import('../context/project-context.js');
+            let text = resolveProjectContext({ cwd: process.cwd() }).text;
             // Append git status
             try {
                 const { execSync } = await import('child_process');

package/dist/mcp/mcp-server.js

@@ -38,6 +38,7 @@ import * as fs from 'fs';
 import { registerAgentTools } from './mcp-agent-tools.js';
 import { registerMemoryTools } from './mcp-memory-tools.js';
 import { registerSessionTools } from './mcp-session-tools.js';
+import { registerDesktopTools } from './mcp-desktop-tools.js';
 import { registerResources } from './mcp-resources.js';
 import { registerPrompts } from './mcp-prompts.js';
 // Read version from package.json (avoid import.meta.url for ts-jest compat)
@@ -123,6 +124,7 @@ export class CodeBuddyMCPServer {
         registerAgentTools(this.mcpServer, getAgent);
         registerMemoryTools(this.mcpServer);
         registerSessionTools(this.mcpServer, getAgent);
+        registerDesktopTools(this.mcpServer);
         registerResources(this.mcpServer);
         registerPrompts(this.mcpServer);
     }

package/dist/memory/enhanced-memory.d.ts

@@ -99,6 +99,7 @@ export interface MemorySearchOptions {
     minImportance?: number;
     limit?: number;
     includeExpired?: boolean;
+    explorationFactor?: number;
 }
 export interface MemoryConfig {
     enabled: boolean;
@@ -128,6 +129,7 @@ export declare class EnhancedMemory extends EventEmitter {
     private dbRepository;
     private embeddingProvider;
     private bayesianQualifier;
+    private disposed;
     constructor(config?: Partial<MemoryConfig>);
     /**
      * Initialize memory system
@@ -278,6 +280,14 @@ export declare class EnhancedMemory extends EventEmitter {
         score: number;
         uncertainty: number;
     };
+    /**
+     * Active Learning: Retrieve memories with the highest uncertainty (BALD score)
+     * so the system can solicit user feedback and improve its relevance model.
+     */
+    getActiveLearningTargets(limit?: number, query?: string): Promise<{
+        memory: MemoryEntry;
+        baldScore: number;
+    }[]>;
 }
 export declare function getEnhancedMemory(config?: Partial<MemoryConfig>): EnhancedMemory;
 export declare function resetEnhancedMemory(): void;