@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/commands/handlers/memory-handlers.js

@@ -27,17 +27,37 @@ function formatTimeAgo(date, now = new Date()) {
     const yr = Math.floor(day / 365);
     return `${yr} year${yr === 1 ? "" : "s"} ago`;
 }
+/**
+ * Report a remember operation honestly: the persistent write is the primary
+ * result; fact reconciliation and the semantic index are secondary and their
+ * failures are shown without hiding (or overstating) the saved memory.
+ */
+async function describeRememberOutcome(write, requestedKey, scope, storeSemantic) {
+    const lines = [`✅ Remembered: "${write?.key ?? requestedKey}" in persistent ${scope} memory.`];
+    if (write?.reconciliation?.status === "failed") {
+        lines.push(`⚠️ Fact reconciliation failed (${write.reconciliation.reason ?? "unknown error"}); the memory was saved directly and existing memories were kept unchanged.`);
+    }
+    try {
+        await storeSemantic();
+        lines.push("Semantic index updated.");
+    }
+    catch (error) {
+        lines.push(`⚠️ Semantic index not updated: ${getErrorMessage(error)}`);
+    }
+    return lines.join("\n");
+}
 function clip(text, max = 180) {
     return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
 /**
  * Memory - Manage persistent memory using PersistentMemoryManager (Markdown) and EnhancedMemory (SQLite/Vector)
  */
-export async function handleMemory(args) {
+export async function handleMemory(args, context) {
     const enhancedMemory = getEnhancedMemory();
-    const persistentMemory = getMemoryManager();
+    const persistentMemory = getMemoryManager(undefined, context?.botId, context?.cwd);
     const action = args[0]?.toLowerCase() || 'list';
     try {
+        await persistentMemory.initialize();
         let content;
         switch (action) {
             case "recall":
@@ -151,14 +171,13 @@ export async function handleMemory(args) {
                         : "project";
                     const value = args.slice(2).join(" ");
                     // Store in both for redundancy and better retrieval
-                    await persistentMemory.remember(key, value, { scope, category: "custom" });
-                    await enhancedMemory.store({
+                    const write = await persistentMemory.remember(key, value, { scope, category: "custom" });
+                    content = await describeRememberOutcome(write, key, scope, () => enhancedMemory.store({
                         type: 'fact',
                         content: `${key}: ${value}`,
                         tags: [key, scope],
                         importance: 0.8
-                    });
-                    content = `✅ Remembered: "${key}" in persistent ${scope} memory and semantic index.`;
+                    }));
                 }
                 else {
                     content = `Usage: /memory remember <key> <content> [project|user]`;
@@ -231,7 +250,7 @@ export async function handleMemory(args) {
                     : undefined;
                 const rawLimit = parseInt(args[status ? 2 : 1] ?? "20", 10);
                 const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 20));
-                const candidates = getMemoryCandidateQueue(process.cwd()).list(status).slice(0, limit);
+                const candidates = getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).list(status).slice(0, limit);
                 if (candidates.length === 0) {
                     content = status ? `No ${status} memory candidates.` : "No memory candidates yet.";
                 }
@@ -268,7 +287,7 @@ export async function handleMemory(args) {
                 }
                 const reviewedBy = args.slice(2).join(" ").trim() || "user";
                 const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
-                const { candidate, write } = await getMemoryCandidateQueue(process.cwd()).accept(id, { reviewedBy });
+                const { candidate, write } = await getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).accept(id, { reviewedBy });
                 content = `✅ Accepted ${candidate.id} into ${candidate.scope} memory as "${candidate.key}".\n` +
                     `Write status: ${write.status}. Capacity: ${write.usage.used}/${write.usage.limit} chars (${write.usage.percent}%).`;
                 break;
@@ -282,7 +301,7 @@ export async function handleMemory(args) {
                 }
                 const reason = args.slice(2).join(" ").trim();
                 const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
-                const candidate = getMemoryCandidateQueue(process.cwd()).reject(id, {
+                const candidate = getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).reject(id, {
                     reviewedBy: "user",
                     ...(reason ? { reason } : {}),
                 });
@@ -319,7 +338,7 @@ export async function handleMemory(args) {
 /**
  * Remember - Quick memory store using PersistentMemoryManager and EnhancedMemory
  */
-export async function handleRemember(args) {
+export async function handleRemember(args, context) {
     if (args.length < 2) {
         return {
             handled: true,
@@ -346,20 +365,21 @@ export async function handleRemember(args) {
         : "project";
     const value = args.slice(1).join(" ");
     try {
-        const persistentMemory = getMemoryManager();
+        const persistentMemory = getMemoryManager(undefined, context?.botId, context?.cwd);
         const enhancedMemory = getEnhancedMemory();
-        await persistentMemory.remember(key, value, { scope, category: "custom" });
-        await enhancedMemory.store({
+        await persistentMemory.initialize();
+        const write = await persistentMemory.remember(key, value, { scope, category: "custom" });
+        const content = await describeRememberOutcome(write, key, scope, () => enhancedMemory.store({
             type: 'fact',
             content: `${key}: ${value}`,
             tags: [key, scope],
             importance: 0.8
-        });
+        }));
         return {
             handled: true,
             entry: {
                 type: "assistant",
-                content: `✅ Remembered: "${key}" in persistent ${scope} memory and semantic index.`,
+                content,
                 timestamp: new Date(),
             },
         };

package/dist/commands/handlers/missing-handlers.d.ts

@@ -14,7 +14,7 @@
  * - __RESTORE_CHECKPOINT__ - /restore
  */
 import type { CommandHandlerResult } from './branch-handlers.js';
-export declare function handleChangeModel(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleChangeModel(args: string[], activeModel?: string): Promise<CommandHandlerResult>;
 export declare function handleChangeMode(args: string[]): Promise<CommandHandlerResult>;
 export declare function handleClearChat(): CommandHandlerResult;
 export declare function handleColab(args: string[]): Promise<CommandHandlerResult>;
@@ -24,5 +24,5 @@ export declare function handleListCheckpoints(_args: string[]): Promise<CommandH
 export declare function handleRestoreCheckpoint(args: string[]): Promise<CommandHandlerResult>;
 export declare function handleInitGrok(args?: string[]): Promise<CommandHandlerResult>;
 export declare function handleReinitGrok(): Promise<CommandHandlerResult>;
-export declare function handleStatus(): Promise<CommandHandlerResult>;
+export declare function handleStatus(activeModel?: string): Promise<CommandHandlerResult>;
 export declare function handleNew(args: string[]): Promise<CommandHandlerResult>;

package/dist/commands/handlers/missing-handlers.js

@@ -17,14 +17,14 @@ import { handleColabCommand } from './colab-handler.js';
 // ============================================================================
 // /model - Change Model
 // ============================================================================
-export async function handleChangeModel(args) {
+export async function handleChangeModel(args, activeModel) {
     const { getSupportedModels, getModelInfo, suggestModel } = await import('../../utils/model-utils.js');
     const { getSettingsManager } = await import('../../utils/settings-manager.js');
     const modelName = args[0];
     const settingsManager = getSettingsManager();
     // If no model specified, show current model and list available models
     if (!modelName || modelName === 'list') {
-        const currentModel = process.env.GROK_MODEL || 'grok-beta';
+        const currentModel = activeModel ?? settingsManager.getCurrentModel();
         const supportedModels = getSupportedModels();
         // Group models by provider
         const modelsByProvider = {};
@@ -803,14 +803,22 @@ function formatStatusTimeAgo(date, now = new Date()) {
     const day = Math.floor(hr / 24);
     return `${day}d ago`;
 }
-export async function handleStatus() {
+export async function handleStatus(activeModel) {
     const lines = [];
     lines.push('Status Dashboard');
     lines.push('='.repeat(50));
     lines.push('');
     // Current model
-    const currentModel = process.env.GROK_MODEL || 'grok-beta';
+    const currentModel = activeModel ?? (await import('../../utils/settings-manager.js')).getSettingsManager().getCurrentModel();
     lines.push(`  Model:           ${currentModel}`);
+    try {
+        const { getThemeManager } = await import('../../themes/theme-manager.js');
+        const theme = getThemeManager().getCurrentTheme();
+        lines.push(`  Theme:           ${theme.name} (${theme.id})`);
+    }
+    catch (_err) {
+        lines.push('  Theme:           unknown');
+    }
     // Agent mode
     try {
         const { getOperatingModeManager } = await import('../../agent/operating-modes.js');

package/dist/commands/handlers/resources-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * /resources — read-only view of the explicit resource catalog (P8).
+ *
+ * Reads ~/.codebuddy/resources/catalog.json through ResourceCatalog.list():
+ * no probe, no network, no write, no dispatch. Shows endpoint REFERENCES
+ * (environment variable names), never resolved URLs or fingerprints.
+ */
+import type { CommandHandlerResult } from './branch-handlers.js';
+import { ResourceCatalog, type PublicResourceStatus } from '../../fleet/resource-catalog.js';
+export declare const RESOURCES_EMPTY_HINT: string;
+export declare function formatResourcesTable(resources: PublicResourceStatus[], now?: number): string;
+export declare function handleResources(catalog?: ResourceCatalog, now?: () => number): Promise<CommandHandlerResult>;

package/dist/commands/handlers/resources-handler.js

@@ -0,0 +1,52 @@
+/**
+ * /resources — read-only view of the explicit resource catalog (P8).
+ *
+ * Reads ~/.codebuddy/resources/catalog.json through ResourceCatalog.list():
+ * no probe, no network, no write, no dispatch. Shows endpoint REFERENCES
+ * (environment variable names), never resolved URLs or fingerprints.
+ */
+import fs from 'node:fs';
+import { publicResourceStatus, ResourceCatalog } from '../../fleet/resource-catalog.js';
+export const RESOURCES_EMPTY_HINT = 'No resource catalog yet. Declare one with `buddy resources add <file.json>` (fields: `buddy resources schema`), '
+    + 'then refresh its health explicitly with `buddy resources probe <id>`.';
+function textResult(content) {
+    return { handled: true, entry: { type: 'assistant', content, timestamp: new Date() } };
+}
+function age(from, now) {
+    if (from === null)
+        return 'never';
+    const minutes = Math.max(0, Math.round((now - from) / 60_000));
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 120)
+        return `${minutes} min ago`;
+    return `${Math.round(minutes / 60)} h ago`;
+}
+export function formatResourcesTable(resources, now = Date.now()) {
+    const lines = [`Resources (${resources.length}) — read-only, no probe`, ''];
+    for (const entry of resources) {
+        const r = entry.resource;
+        const use = r.permissions.use ? 'use' : 'no-use';
+        const probe = r.permissions.probe ? 'probe' : 'no-probe';
+        lines.push(`  ${r.id}  [${r.kind}] on ${r.hostId}`);
+        lines.push(`    state: ${entry.state} (${entry.reason}), checked ${age(entry.checkedAt, now)}`);
+        lines.push(`    capabilities: ${r.declaredCapabilities.join(', ')} · endpoint ref: ${r.endpointRef} · ${use}, ${probe}`);
+    }
+    lines.push('', 'Health is not proof of usage and load is unknown. Refresh with `buddy resources probe <id>`.');
+    return lines.join('\n');
+}
+export async function handleResources(catalog = new ResourceCatalog(), now = Date.now) {
+    let resources;
+    try {
+        resources = (await catalog.list()).map(publicResourceStatus);
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.message : 'INVALID_CATALOG';
+        return textResult(`Resource catalog unreadable (${code}). Nothing was changed; inspect ${catalog.filename}.`);
+    }
+    if (resources.length === 0) {
+        return textResult(fs.existsSync(catalog.filename) ? `The resource catalog is empty. ${RESOURCES_EMPTY_HINT.replace(/^No resource catalog yet\. /, '')}` : RESOURCES_EMPTY_HINT);
+    }
+    return textResult(formatResourcesTable(resources, now()));
+}
+//# sourceMappingURL=resources-handler.js.map

package/dist/commands/handlers/starter-handlers.d.ts

@@ -1,7 +1,7 @@
 /**
  * Starter Pack Slash Command Handler
  *
- * /starter              - List all starter packs grouped by language
+ * /starter, /starter list - List all starter packs grouped by language
  * /starter <name>       - Activate a specific starter pack (name or alias)
  * /starter search <q>   - Search starters by keyword
  */

package/dist/commands/handlers/starter-handlers.js

@@ -1,7 +1,7 @@
 /**
  * Starter Pack Slash Command Handler
  *
- * /starter              - List all starter packs grouped by language
+ * /starter, /starter list - List all starter packs grouped by language
  * /starter <name>       - Activate a specific starter pack (name or alias)
  * /starter search <q>   - Search starters by keyword
  */
@@ -25,7 +25,16 @@ const LANGUAGE_FAMILIES = {
 function formatStarterList() {
     const starters = getStarterPacks();
     if (starters.length === 0) {
-        return 'No starter packs found. Ensure bundled skills are loaded.';
+        // No starter pack ships with the package today: say where packs are found
+        // instead of implying a loading failure.
+        return [
+            'No starter packs are installed.',
+            '',
+            'Starter packs are SKILL.md skills tagged "starter", discovered in:',
+            '  .codebuddy/skills/        (this project)',
+            '  ~/.codebuddy/skills/      (user)',
+            '  the bundled skills directory shipped with Code Buddy',
+        ].join('\n');
     }
     const lines = [
         `Starter Packs (${starters.length} available)`,
@@ -82,6 +91,27 @@ export async function handleStarter(args) {
         };
     }
     const action = first.toLowerCase();
+    // /starter list — documented alias of the bare command
+    if (action === 'list' && args.length === 1) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: formatStarterList(),
+                timestamp: new Date(),
+            },
+        };
+    }
+    if (action === 'search' && args.length === 1) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: 'Usage: /starter search <query>',
+                timestamp: new Date(),
+            },
+        };
+    }
     // /starter search <query>
     if (action === 'search' && args.length > 1) {
         const query = args.slice(1).join(' ');

package/dist/commands/handlers/switch-handler.d.ts

@@ -9,7 +9,7 @@
 import type { CommandHandlerResult } from './branch-handlers.js';
 /**
  * Provider for model routing state.
- * Set from enhanced-command-handler when the agent is available.
+ * Set by the conversation-loop dispatcher from the live agent.
  */
 export interface SwitchModelProvider {
     /** Get list of available model names */

package/dist/commands/handlers/switch-handler.js

@@ -23,6 +23,21 @@ export function setSwitchModelProvider(provider) {
  *   /switch auto            — Return to auto-routing / default
  */
 export async function handleSwitch(args) {
+    try {
+        return await runSwitch(args);
+    }
+    catch (error) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: `Model switch failed: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: new Date(),
+            },
+        };
+    }
+}
+async function runSwitch(args) {
     const modelName = args[0]?.trim();
     // No provider set — try to get models from config
     if (!providerRef) {

package/dist/commands/handlers/test-handlers.js

@@ -1,6 +1,5 @@
 import { CodeBuddyClient } from "../../codebuddy/client.js";
 import { AITestRunner, createAITestRunner } from "../../testing/ai-integration-tests.js";
-import stringWidth from "string-width";
 /**
  * Generate Tests - Create test scaffolds
  */
@@ -47,7 +46,7 @@ export async function handleAITest(args, codebuddyClient) {
     const option = args[0]?.toLowerCase();
     // Check for API key
     const apiKey = process.env.GROK_API_KEY;
-    if (!apiKey) {
+    if (!codebuddyClient && !apiKey) {
         return {
             handled: true,
             entry: {
@@ -66,9 +65,8 @@ Set your API key to run integration tests.`,
         // Fallback: create client from environment variables
         const model = process.env.GROK_MODEL || process.env.OPENAI_MODEL;
         const baseURL = process.env.GROK_BASE_URL || process.env.OPENAI_BASE_URL;
-        client = new CodeBuddyClient(apiKey, model, baseURL);
+        client = new CodeBuddyClient(apiKey ?? '', model, baseURL);
     }
-    const currentModel = client.getCurrentModel();
     const currentBaseURL = client.getBaseURL();
     // Detect local models (LM Studio, Ollama) and increase timeout
     const isLocalModel = currentBaseURL.includes(':1234') ||
@@ -86,87 +84,11 @@ Set your API key to run integration tests.`,
         testTools: option !== 'stream',
         testStreaming: option !== 'tools',
     };
-    // Fun test names and emojis
-    const testEmojis = {
-        'Basic Completion': '🧠',
-        'Simple Math': '🔢',
-        'JSON Output': '📋',
-        'Code Generation': '💻',
-        'Context Understanding': '🧩',
-        'Streaming Response': '🌊',
-        'Tool Calling': '🔧',
-        'Error Handling': '🛡️',
-        'Long Context': '📚',
-    };
-    const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let spinnerIndex = 0;
-    let currentTest = '';
-    const completedTests = [];
-    let spinnerInterval = null;
-    // Create client and run tests
+    // Ink owns the terminal. Render the final report through the conversation
+    // instead of writing cursor-control sequences over the active UI.
     try {
         const runner = createAITestRunner(client, testOptions);
-        // Helper to pad string to width accounting for emoji visual width
-        const padEnd = (str, targetWidth) => {
-            const currentWidth = stringWidth(str);
-            if (currentWidth >= targetWidth)
-                return str;
-            return str + ' '.repeat(targetWidth - currentWidth);
-        };
-        const W = 60; // box width
-        // Build progress display with proper emoji width handling
-        const buildProgressDisplay = () => {
-            const lines = [];
-            lines.push('┌' + '─'.repeat(W - 2) + '┐');
-            lines.push('│' + padEnd('          🧪 AI INTEGRATION TESTS IN PROGRESS', W - 2) + '│');
-            lines.push('├' + '─'.repeat(W - 2) + '┤');
-            lines.push('│' + padEnd(`  Model: ${currentModel}`, W - 2) + '│');
-            lines.push('├' + '─'.repeat(W - 2) + '┤');
-            // Show completed tests
-            for (const test of completedTests) {
-                lines.push('│' + padEnd(`  ${test}`, W - 2) + '│');
-            }
-            // Show current test with spinner
-            if (currentTest) {
-                const emoji = testEmojis[currentTest] || '🔬';
-                const spinner = spinnerFrames[spinnerIndex % spinnerFrames.length];
-                lines.push('│' + padEnd(`  ${spinner} ${emoji} ${currentTest}...`, W - 2) + '│');
-            }
-            lines.push('└' + '─'.repeat(W - 2) + '┘');
-            return lines.join('\n');
-        };
-        // Track progress
-        runner.on('test:start', ({ name }) => {
-            currentTest = name;
-        });
-        runner.on('test:complete', (result) => {
-            const emoji = testEmojis[result.name] || '🔬';
-            const status = result.passed ? '✅' : '❌';
-            const duration = result.duration ? `${(result.duration / 1000).toFixed(1)}s` : '';
-            completedTests.push(`${status} ${emoji} ${result.name} ${duration}`);
-            currentTest = '';
-        });
-        runner.on('test:skipped', ({ name }) => {
-            const emoji = testEmojis[name] || '🔬';
-            completedTests.push(`⏭️  ${emoji} ${name} (skipped)`);
-        });
-        // Start spinner animation (write to stderr to not interfere with output)
-        spinnerInterval = setInterval(() => {
-            spinnerIndex++;
-            // Clear and redraw progress (using ANSI escape codes)
-            const progress = buildProgressDisplay();
-            process.stderr.write(`\x1b[${completedTests.length + 7}A\x1b[0J${progress}\n`);
-        }, 100);
-        // Show initial progress
-        process.stderr.write('\n' + buildProgressDisplay() + '\n');
         const suite = await runner.runAll();
-        // Stop spinner
-        if (spinnerInterval) {
-            clearInterval(spinnerInterval);
-        }
-        // Clear progress display
-        const clearLines = completedTests.length + 8;
-        process.stderr.write(`\x1b[${clearLines}A\x1b[0J`);
         // Format final results
         const resultContent = AITestRunner.formatResults(suite);
         return {
@@ -179,10 +101,6 @@ Set your API key to run integration tests.`,
         };
     }
     catch (error) {
-        // Stop spinner on error
-        if (spinnerInterval) {
-            clearInterval(spinnerInterval);
-        }
         return {
             handled: true,
             entry: {

package/dist/commands/handlers/ui-handlers.js

@@ -4,17 +4,17 @@ import { getThemeManager } from "../../themes/theme-manager.js";
  */
 export function handleTheme(args) {
     const themeManager = getThemeManager();
-    const action = args[0]?.toLowerCase();
+    const action = (args[0]?.toLowerCase() === "set" ? args[1] : args[0])?.toLowerCase();
     let content;
-    if (!action || action === "list") {
+    if (!action || action === "list" || action === "status" || action === "current") {
         const themes = themeManager.getAvailableThemes();
         const currentTheme = themeManager.getCurrentTheme();
-        content = `🎨 Available Themes\n${"═".repeat(40)}\n\n`;
+        content = `🎨 Current theme: ${currentTheme.name} (${currentTheme.id})\nAvailable Themes\n${"═".repeat(40)}\n\n`;
         for (const theme of themes) {
             const isCurrent = theme.id === currentTheme.id;
             const marker = isCurrent ? "▶" : " ";
             const builtinMarker = theme.isBuiltin ? "" : " (custom)";
-            content += `${marker} ${theme.name}${builtinMarker}\n`;
+            content += `${marker} ${theme.name} (${theme.id})${builtinMarker}\n`;
             content += `    ${theme.description}\n\n`;
         }
         content += `\n💡 Usage: /theme <name>\n`;
@@ -28,7 +28,13 @@ export function handleTheme(args) {
             content = `🎨 Theme Changed!\n\n`;
             content += `Now using: ${theme.name}\n`;
             content += `${theme.description}\n\n`;
-            content += `💡 The theme will be applied to new messages.`;
+            content += `The theme is active immediately.`;
+            if (themeManager.getPreferenceSaveStatus() === false) {
+                content += `\nCould not save the preference; this change may be lost after restarting Buddy.`;
+            }
+            if (themeManager.getOverrideKeys().colors.length > 0) {
+                content += `\nCustom color overrides are still applied.`;
+            }
         }
         else {
             const themes = themeManager.getAvailableThemes();

package/dist/commands/login-chatgpt.d.ts

@@ -0,0 +1,8 @@
+import { type ChatGptAuth } from '../providers/codex-oauth.js';
+interface LoginOutput {
+    stdout: (message: string) => unknown;
+    warn: (message: string) => unknown;
+}
+/** Keep the callback alive so a failed browser launch can be completed manually. */
+export declare function loginChatGptWithBrowser(output: LoginOutput): Promise<ChatGptAuth>;
+export {};

package/dist/commands/login-chatgpt.js

@@ -0,0 +1,17 @@
+import open from 'open';
+import { loginInteractive } from '../providers/codex-oauth.js';
+/** Keep the callback alive so a failed browser launch can be completed manually. */
+export function loginChatGptWithBrowser(output) {
+    return loginInteractive(async (url) => {
+        output.stdout('If the browser does not open, copy this entire URL into your browser:');
+        output.stdout(url);
+        output.stdout('Keep this terminal open until sign-in completes.\n');
+        try {
+            await open(url);
+        }
+        catch {
+            output.warn('Could not open the browser automatically. Open the URL above manually; login is still waiting.');
+        }
+    });
+}
+//# sourceMappingURL=login-chatgpt.js.map

package/dist/commands/mcp-import.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+export declare function importMCPFile(filename: string, source: 'hermes' | 'openclaw', options?: {
+    dryRun?: boolean;
+    output?: string;
+}): {
+    written: boolean;
+    servers: import("../mcp/types.js").MCPServerConfig[];
+    warnings: string[];
+    rejected: string[];
+};
+export declare function registerMCPImportCommand(command: Command): void;

package/dist/commands/mcp-import.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { normalizeMCPImports } from '../mcp/import-normalize.js';
+import { writeJsonAtomicSync } from '../utils/atomic-write.js';
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+export function importMCPFile(filename, source, options = {}) {
+    const stat = fs.statSync(filename);
+    if (!stat.isFile() || stat.size > 1024 * 1024)
+        throw new Error('MCP import file must be at most 1 MiB');
+    let input;
+    try {
+        input = parse(fs.readFileSync(filename, 'utf8'), { uniqueKeys: true });
+    }
+    catch {
+        throw new Error('Invalid MCP import JSON/YAML');
+    }
+    if (!object(input))
+        throw new Error('MCP import requires an object');
+    const map = input.mcpServers ?? input.mcp_servers ?? (object(input.mcp) ? input.mcp.servers : undefined) ?? input;
+    const normalized = normalizeMCPImports(map, source);
+    if (options.dryRun || normalized.servers.length === 0)
+        return { ...normalized, written: false };
+    const output = options.output ?? path.join(process.cwd(), '.codebuddy', 'mcp.json');
+    let existing = {};
+    if (fs.existsSync(output)) {
+        const target = fs.lstatSync(output);
+        if (!target.isFile() || target.isSymbolicLink() || target.size > 1024 * 1024)
+            throw new Error('Invalid existing MCP target');
+        try {
+            const parsed = JSON.parse(fs.readFileSync(output, 'utf8'));
+            if (!object(parsed) || (parsed.mcpServers !== undefined && !object(parsed.mcpServers)))
+                throw new Error();
+            existing = parsed;
+        }
+        catch {
+            throw new Error('Existing MCP configuration is invalid; not replaced');
+        }
+    }
+    const servers = object(existing.mcpServers) ? existing.mcpServers : {};
+    for (const server of normalized.servers) {
+        if (Object.hasOwn(servers, server.name))
+            normalized.warnings.push(`${server.name}: existing configuration preserved`);
+        else
+            servers[server.name] = server;
+    }
+    fs.mkdirSync(path.dirname(output), { recursive: true, mode: 0o700 });
+    writeJsonAtomicSync(output, { ...existing, mcpServers: servers }, { mode: 0o600 });
+    return { ...normalized, written: true };
+}
+export function registerMCPImportCommand(command) {
+    command.command('import <file>').requiredOption('--from <source>', 'hermes or openclaw')
+        .option('--dry-run', 'Show sanitized mapping without writing or connecting')
+        .option('--output <file>', 'Target MCP JSON file (default project .codebuddy/mcp.json)')
+        .description('Import MCP declarations; credentials become environment references and existing entries are preserved')
+        .action((file, options) => {
+        if (options.from !== 'hermes' && options.from !== 'openclaw')
+            command.error('Source must be hermes or openclaw');
+        try {
+            process.stdout.write(JSON.stringify(importMCPFile(file, options.from, options), null, 2) + '\n');
+        }
+        catch {
+            command.error('MCP import failed; check input/target configuration. No credentials are printed.');
+        }
+    });
+}
+//# sourceMappingURL=mcp-import.js.map

package/dist/commands/mcp-invoke.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerMCPInvocationCommands(command: Command): void;