@lanonasis/cli 1.0.1 → 1.2.0

package/dist/commands/mcp.js

@@ -0,0 +1,318 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { table } from 'table';
+import { getMCPClient } from '../utils/mcp-client.js';
+import { CLIConfig } from '../utils/config.js';
+export function mcpCommands(program) {
+    const mcp = program
+        .command('mcp')
+        .description('MCP (Model Context Protocol) server operations');
+    // Also register mcp-server command directly on program for convenience
+    const mcpServer = program
+        .command('mcp-server')
+        .description('MCP server initialization and management');
+    mcpServer.command('init')
+        .description('Initialize MCP server configuration')
+        .action(async () => {
+        console.log(chalk.cyan('🚀 Initializing MCP Server Configuration'));
+        console.log('');
+        const config = new CLIConfig();
+        const isAuthenticated = !!config.get('token');
+        if (isAuthenticated) {
+            console.log(chalk.green('✓ Authenticated - Using remote MCP mode'));
+            console.log('  Your memory operations will use api.lanonasis.com');
+            console.log('  with real-time SSE updates enabled');
+        }
+        else {
+            console.log(chalk.yellow('⚠️  Not authenticated - Using local MCP mode'));
+            console.log('  Run "lanonasis auth login" to enable remote mode');
+        }
+        console.log('');
+        console.log(chalk.cyan('Available MCP Commands:'));
+        console.log('  lanonasis mcp connect       # Auto-connect to best mode');
+        console.log('  lanonasis mcp connect -r    # Force remote mode');
+        console.log('  lanonasis mcp connect -l    # Force local mode');
+        console.log('  lanonasis mcp status        # Check connection status');
+        console.log('  lanonasis mcp tools         # List available tools');
+        console.log('');
+        console.log(chalk.cyan('Memory operations are MCP-powered by default!'));
+        // Auto-connect to MCP
+        const spinner = ora('Auto-connecting to MCP...').start();
+        try {
+            const client = getMCPClient();
+            const connected = await client.connect({ useRemote: isAuthenticated });
+            if (connected) {
+                spinner.succeed(chalk.green(`Connected to ${isAuthenticated ? 'remote' : 'local'} MCP server`));
+            }
+            else {
+                spinner.fail('Failed to auto-connect to MCP');
+            }
+        }
+        catch (error) {
+            spinner.fail('MCP auto-connect failed');
+        }
+    });
+    // Connect command
+    mcp.command('connect')
+        .description('Connect to MCP server (local or remote)')
+        .option('-l, --local', 'Connect to local MCP server')
+        .option('-r, --remote', 'Connect to remote MCP server (api.lanonasis.com)')
+        .option('-s, --server <path>', 'Local MCP server path')
+        .option('-u, --url <url>', 'Remote MCP server URL')
+        .action(async (options) => {
+        const spinner = ora('Connecting to MCP server...').start();
+        const config = new CLIConfig();
+        try {
+            // Determine connection mode
+            let useRemote = options.remote;
+            if (!options.local && !options.remote) {
+                // Default to remote if authenticated, otherwise local
+                useRemote = !!config.get('token');
+            }
+            // Save preference
+            config.set('mcpUseRemote', useRemote);
+            if (options.server) {
+                config.set('mcpServerPath', options.server);
+            }
+            if (options.url) {
+                config.set('mcpServerUrl', options.url);
+            }
+            const client = getMCPClient();
+            const connected = await client.connect({
+                useRemote,
+                serverPath: options.server,
+                serverUrl: options.url
+            });
+            if (connected) {
+                spinner.succeed(chalk.green(`Connected to ${useRemote ? 'remote' : 'local'} MCP server`));
+                if (useRemote) {
+                    console.log(chalk.cyan('ℹ️  Using remote MCP via api.lanonasis.com'));
+                    console.log(chalk.cyan('📡 SSE endpoint active for real-time updates'));
+                }
+            }
+            else {
+                spinner.fail('Failed to connect to MCP server');
+            }
+        }
+        catch (error) {
+            spinner.fail(`Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Disconnect command
+    mcp.command('disconnect')
+        .description('Disconnect from MCP server')
+        .action(async () => {
+        const client = getMCPClient();
+        await client.disconnect();
+        console.log(chalk.green('✓ Disconnected from MCP server'));
+    });
+    // Status command
+    mcp.command('status')
+        .description('Show MCP connection status')
+        .action(async () => {
+        const client = getMCPClient();
+        const status = client.getConnectionStatus();
+        console.log(chalk.cyan('\n📊 MCP Connection Status'));
+        console.log(chalk.cyan('========================'));
+        console.log(`Status: ${status.connected ? chalk.green('Connected') : chalk.red('Disconnected')}`);
+        console.log(`Mode: ${status.mode === 'remote' ? chalk.blue('Remote (API)') : chalk.yellow('Local')}`);
+        console.log(`Server: ${status.server}`);
+        if (status.connected && status.mode === 'remote') {
+            console.log(`\n${chalk.cyan('Features:')}`);
+            console.log('• Real-time updates via SSE');
+            console.log('• Authenticated API access');
+            console.log('• MCP-compatible tool interface');
+        }
+    });
+    // List tools command
+    mcp.command('tools')
+        .description('List available MCP tools')
+        .action(async () => {
+        const spinner = ora('Fetching available tools...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Not connected. Attempting auto-connect...');
+                const config = new CLIConfig();
+                const useRemote = !!config.get('token');
+                await client.connect({ useRemote });
+            }
+            const tools = await client.listTools();
+            spinner.succeed('Tools fetched successfully');
+            console.log(chalk.cyan('\n🔧 Available MCP Tools'));
+            console.log(chalk.cyan('====================='));
+            const tableData = [
+                [chalk.bold('Tool Name'), chalk.bold('Description')]
+            ];
+            tools.forEach(tool => {
+                tableData.push([
+                    chalk.green(tool.name),
+                    tool.description
+                ]);
+            });
+            console.log(table(tableData, {
+                border: {
+                    topBody: '─',
+                    topJoin: '┬',
+                    topLeft: '┌',
+                    topRight: '┐',
+                    bottomBody: '─',
+                    bottomJoin: '┴',
+                    bottomLeft: '└',
+                    bottomRight: '┘',
+                    bodyLeft: '│',
+                    bodyRight: '│',
+                    bodyJoin: '│',
+                    joinBody: '─',
+                    joinLeft: '├',
+                    joinRight: '┤',
+                    joinJoin: '┼'
+                }
+            }));
+        }
+        catch (error) {
+            spinner.fail(`Failed to fetch tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Call tool command
+    mcp.command('call')
+        .description('Call an MCP tool directly')
+        .argument('<tool>', 'Tool name to call')
+        .option('-a, --args <json>', 'Tool arguments as JSON')
+        .action(async (toolName, options) => {
+        const spinner = ora(`Calling tool: ${toolName}...`).start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Not connected. Attempting auto-connect...');
+                const config = new CLIConfig();
+                const useRemote = !!config.get('token');
+                await client.connect({ useRemote });
+            }
+            let args = {};
+            if (options.args) {
+                try {
+                    args = JSON.parse(options.args);
+                }
+                catch (error) {
+                    spinner.fail('Invalid JSON arguments');
+                    process.exit(1);
+                }
+            }
+            const result = await client.callTool(toolName, args);
+            spinner.succeed(`Tool ${toolName} executed successfully`);
+            console.log(chalk.cyan('\n📤 Tool Result:'));
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            spinner.fail(`Tool execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Memory-specific MCP commands
+    const memory = mcp.command('memory')
+        .description('Memory operations via MCP');
+    memory.command('create')
+        .description('Create memory via MCP')
+        .requiredOption('-t, --title <title>', 'Memory title')
+        .requiredOption('-c, --content <content>', 'Memory content')
+        .option('-T, --type <type>', 'Memory type', 'context')
+        .option('--tags <tags>', 'Comma-separated tags')
+        .action(async (options) => {
+        const spinner = ora('Creating memory via MCP...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Not connected. Attempting auto-connect...');
+                const config = new CLIConfig();
+                const useRemote = !!config.get('token');
+                await client.connect({ useRemote });
+            }
+            const result = await client.callTool('memory_create_memory', {
+                title: options.title,
+                content: options.content,
+                memory_type: options.type,
+                tags: options.tags ? options.tags.split(',').map((t) => t.trim()) : []
+            });
+            spinner.succeed('Memory created successfully');
+            console.log(chalk.green('\n✓ Memory created'));
+            console.log(`ID: ${chalk.cyan(result.id)}`);
+            console.log(`Title: ${result.title}`);
+            console.log(`Type: ${result.memory_type}`);
+        }
+        catch (error) {
+            spinner.fail(`Failed to create memory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    memory.command('search')
+        .description('Search memories via MCP')
+        .argument('<query>', 'Search query')
+        .option('-l, --limit <number>', 'Maximum results', '10')
+        .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.7')
+        .action(async (query, options) => {
+        const spinner = ora('Searching memories via MCP...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Not connected. Attempting auto-connect...');
+                const config = new CLIConfig();
+                const useRemote = !!config.get('token');
+                await client.connect({ useRemote });
+            }
+            const results = await client.callTool('memory_search_memories', {
+                query,
+                limit: parseInt(options.limit),
+                threshold: parseFloat(options.threshold)
+            });
+            spinner.succeed(`Found ${results.length} memories`);
+            if (results.length === 0) {
+                console.log(chalk.yellow('\nNo memories found matching your query'));
+                return;
+            }
+            console.log(chalk.cyan('\n🔍 Search Results:'));
+            results.forEach((memory, index) => {
+                console.log(`\n${chalk.bold(`${index + 1}. ${memory.title}`)}`);
+                console.log(`   ID: ${chalk.gray(memory.id)}`);
+                console.log(`   Type: ${chalk.blue(memory.memory_type)}`);
+                console.log(`   Score: ${chalk.green((memory.relevance_score * 100).toFixed(1) + '%')}`);
+                console.log(`   Content: ${memory.content.substring(0, 100)}...`);
+            });
+        }
+        catch (error) {
+            spinner.fail(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Configure MCP preferences
+    mcp.command('config')
+        .description('Configure MCP preferences')
+        .option('--prefer-remote', 'Prefer remote MCP server when available')
+        .option('--prefer-local', 'Prefer local MCP server')
+        .option('--auto', 'Auto-detect best connection mode')
+        .action(async (options) => {
+        const config = new CLIConfig();
+        if (options.preferRemote) {
+            config.set('mcpPreference', 'remote');
+            console.log(chalk.green('✓ Set MCP preference to remote'));
+        }
+        else if (options.preferLocal) {
+            config.set('mcpPreference', 'local');
+            console.log(chalk.green('✓ Set MCP preference to local'));
+        }
+        else if (options.auto) {
+            config.set('mcpPreference', 'auto');
+            console.log(chalk.green('✓ Set MCP preference to auto-detect'));
+        }
+        else {
+            const current = config.get('mcpPreference') || 'auto';
+            console.log(`Current MCP preference: ${chalk.cyan(current)}`);
+            console.log('\nOptions:');
+            console.log('  --prefer-remote : Use remote MCP server (api.lanonasis.com)');
+            console.log('  --prefer-local  : Use local MCP server');
+            console.log('  --auto          : Auto-detect based on authentication');
+        }
+    });
+}

package/dist/commands/memory.js

@@ -6,6 +6,7 @@ import wrap from 'word-wrap';
 import { format } from 'date-fns';
 import { apiClient } from '../utils/api.js';
 import { formatBytes, truncateText } from '../utils/formatting.js';
+// Using GetMemoriesParams from api.ts
 export function memoryCommands(program) {
     // Create memory
     program
@@ -80,7 +81,8 @@ export function memoryCommands(program) {
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to create memory:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to create memory:'), errorMessage);
             process.exit(1);
         }
     });
@@ -100,25 +102,26 @@ export function memoryCommands(program) {
         try {
             const spinner = ora('Fetching memories...').start();
             const params = {
-                page: parseInt(options.page),
-                limit: parseInt(options.limit),
-                sort: options.sort,
-                order: options.order
+                offset: (parseInt(options.page || '1') - 1) * parseInt(options.limit || '20'),
+                limit: parseInt(options.limit || '20'),
+                sort_by: (options.sort || 'created_at'),
+                sort_order: (options.order || 'desc')
             };
             if (options.type)
                 params.memory_type = options.type;
             if (options.tags)
-                params.tags = options.tags;
-            if (options.userId)
-                params.user_id = options.userId;
+                params.tags = options.tags.split(',').map(t => t.trim());
+            // Note: user_id filtering removed as it's handled by authentication
             const result = await apiClient.getMemories(params);
             spinner.stop();
-            if (result.memories.length === 0) {
+            if (result.data.length === 0) {
                 console.log(chalk.yellow('No memories found'));
                 return;
             }
             console.log(chalk.blue.bold(`\n📚 Memories (${result.pagination.total} total)`));
-            console.log(chalk.gray(`Page ${result.pagination.page} of ${result.pagination.pages}`));
+            const currentPage = Math.floor(result.pagination.offset / result.pagination.limit) + 1;
+            const totalPages = Math.ceil(result.pagination.total / result.pagination.limit);
+            console.log(chalk.gray(`Page ${currentPage} of ${totalPages}`));
             console.log();
             const outputFormat = process.env.CLI_OUTPUT_FORMAT || 'table';
             if (outputFormat === 'json') {
@@ -126,7 +129,7 @@ export function memoryCommands(program) {
             }
             else {
                 // Table format
-                const tableData = result.memories.map((memory) => [
+                const tableData = result.data.map((memory) => [
                     truncateText(memory.title, 30),
                     memory.memory_type,
                     memory.tags.slice(0, 3).join(', '),
@@ -134,7 +137,6 @@ export function memoryCommands(program) {
                     memory.access_count
                 ]);
                 const tableConfig = {
-                    header: ['Title', 'Type', 'Tags', 'Created', 'Access'],
                     columnDefault: {
                         width: 20,
                         wrapWord: true
@@ -147,15 +149,18 @@ export function memoryCommands(program) {
                         { width: 8 }
                     ]
                 };
-                console.log(table([tableConfig.header, ...tableData], tableConfig));
+                const tableHeaders = ['Title', 'Type', 'Tags', 'Created', 'Access'];
+                console.log(table([tableHeaders, ...tableData], tableConfig));
                 // Pagination info
-                if (result.pagination.pages > 1) {
-                    console.log(chalk.gray(`\nUse --page ${result.pagination.page + 1} for next page`));
+                if (result.pagination.has_more) {
+                    const nextPage = currentPage + 1;
+                    console.log(chalk.gray(`\nUse --page ${nextPage} for next page`));
                 }
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to list memories:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to list memories:'), errorMessage);
             process.exit(1);
         }
     });
@@ -172,8 +177,8 @@ export function memoryCommands(program) {
         try {
             const spinner = ora(`Searching for "${query}"...`).start();
             const searchOptions = {
-                limit: parseInt(options.limit),
-                threshold: parseFloat(options.threshold)
+                limit: parseInt(options.limit || '20'),
+                threshold: parseFloat(options.threshold || '0.7')
             };
             if (options.type) {
                 searchOptions.memory_types = options.type.split(',').map((t) => t.trim());
@@ -183,14 +188,14 @@ export function memoryCommands(program) {
             }
             const result = await apiClient.searchMemories(query, searchOptions);
             spinner.stop();
-            if (result.results.length === 0) {
+            if (result.data.length === 0) {
                 console.log(chalk.yellow('No memories found matching your search'));
                 return;
             }
-            console.log(chalk.blue.bold(`\n🔍 Search Results (${result.total_results} found)`));
-            console.log(chalk.gray(`Query: "${query}" | Search time: ${result.search_time_ms}ms`));
+            console.log(chalk.blue.bold(`\n🔍 Search Results (${result.pagination.total} found)`));
+            console.log(chalk.gray(`Query: "${query}"`));
             console.log();
-            result.results.forEach((memory, index) => {
+            result.data.forEach((memory, index) => {
                 const score = (memory.relevance_score * 100).toFixed(1);
                 console.log(chalk.green(`${index + 1}. ${memory.title}`) + chalk.gray(` (${score}% match)`));
                 console.log(chalk.white(`   ${truncateText(memory.content, 100)}`));
@@ -202,7 +207,8 @@ export function memoryCommands(program) {
             });
         }
         catch (error) {
-            console.error(chalk.red('✖ Search failed:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Search failed:'), errorMessage);
             process.exit(1);
         }
     });
@@ -244,7 +250,8 @@ export function memoryCommands(program) {
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to get memory:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to get memory:'), errorMessage);
             process.exit(1);
         }
     });
@@ -324,7 +331,8 @@ export function memoryCommands(program) {
             console.log(`  Title: ${memory.title}`);
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to update memory:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to update memory:'), errorMessage);
             process.exit(1);
         }
     });
@@ -357,7 +365,8 @@ export function memoryCommands(program) {
             spinner.succeed('Memory deleted successfully');
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to delete memory:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to delete memory:'), errorMessage);
             process.exit(1);
         }
     });
@@ -394,7 +403,8 @@ export function memoryCommands(program) {
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to get statistics:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to get statistics:'), errorMessage);
             process.exit(1);
         }
     });

package/dist/commands/topics.js

@@ -82,7 +82,8 @@ export function topicCommands(program) {
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to create topic:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to create topic:'), errorMessage);
             process.exit(1);
         }
     });
@@ -116,7 +117,6 @@ export function topicCommands(program) {
                     topic.parent_topic_id ? '✓' : ''
                 ]);
                 const tableConfig = {
-                    header: ['Name', 'Description', 'Color', 'Created', 'Child'],
                     columnDefault: {
                         width: 20,
                         wrapWord: true
@@ -129,11 +129,13 @@ export function topicCommands(program) {
                         { width: 8 }
                     ]
                 };
-                console.log(table([tableConfig.header, ...tableData], tableConfig));
+                const tableHeaders = ['Name', 'Description', 'System', 'Created'];
+                console.log(table([tableHeaders, ...tableData], tableConfig));
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to list topics:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to list topics:'), errorMessage);
             process.exit(1);
         }
     });
@@ -174,7 +176,8 @@ export function topicCommands(program) {
             }
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to get topic:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to get topic:'), errorMessage);
             process.exit(1);
         }
     });
@@ -257,7 +260,8 @@ export function topicCommands(program) {
             console.log(`  Name: ${topic.name}`);
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to update topic:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to update topic:'), errorMessage);
             process.exit(1);
         }
     });
@@ -290,7 +294,8 @@ export function topicCommands(program) {
             spinner.succeed('Topic deleted successfully');
         }
         catch (error) {
-            console.error(chalk.red('✖ Failed to delete topic:'), error.message);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to delete topic:'), errorMessage);
             process.exit(1);
         }
     });

package/dist/index-simple.js

@@ -11,7 +11,7 @@ const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
 const program = new Command();
 program
     .name('lanonasis')
-    .description('Lanonasis Enterprise CLI - Memory as a Service and Infrastructure Management')
+    .description('Lanonasis Enterprise CLI - Memory as a Service with MCP Integration')
     .version(packageJson.version);
 program
     .command('init')

package/dist/index.js

@@ -8,7 +8,9 @@ import { memoryCommands } from './commands/memory.js';
 import { topicCommands } from './commands/topics.js';
 import { configCommands } from './commands/config.js';
 import { orgCommands } from './commands/organization.js';
+import { mcpCommands } from './commands/mcp.js';
 import { CLIConfig } from './utils/config.js';
+import { getMCPClient } from './utils/mcp-client.js';
 // Load environment variables
 config();
 const program = new Command();
@@ -17,12 +19,13 @@ const cliConfig = new CLIConfig();
 program
     .name('memory')
     .alias('maas')
-    .description('Enterprise Memory as a Service (MaaS) CLI')
+    .description('Enterprise Memory as a Service (MaaS) CLI with MCP Integration')
     .version('1.0.0')
     .option('-v, --verbose', 'enable verbose logging')
     .option('--api-url <url>', 'override API URL')
     .option('--output <format>', 'output format (json, table, yaml)', 'table')
-    .hook('preAction', (thisCommand, actionCommand) => {
+    .option('--no-mcp', 'disable MCP and use direct API')
+    .hook('preAction', async (thisCommand, actionCommand) => {
     const opts = thisCommand.opts();
     if (opts.verbose) {
         process.env.CLI_VERBOSE = 'true';
@@ -31,6 +34,24 @@ program
         process.env.MEMORY_API_URL = opts.apiUrl;
     }
     process.env.CLI_OUTPUT_FORMAT = opts.output;
+    // Auto-initialize MCP unless disabled
+    if (opts.mcp !== false && !['init', 'auth', 'login', 'mcp'].includes(actionCommand.name())) {
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                const useRemote = await cliConfig.isAuthenticated();
+                await client.connect({ useRemote });
+                if (process.env.CLI_VERBOSE === 'true') {
+                    console.log(chalk.gray(`MCP connected (${useRemote ? 'remote' : 'local'})`));
+                }
+            }
+        }
+        catch {
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.log(chalk.yellow('MCP auto-connect failed, using direct API'));
+            }
+        }
+    }
 });
 // Global error handler
 process.on('uncaughtException', (error) => {
@@ -110,13 +131,16 @@ authCmd
         console.log(chalk.yellow('Run:'), chalk.white('memory login'));
     }
 });
-// Memory commands (require auth)
+// MCP Commands (primary interface)
+mcpCommands(program);
+// Memory commands (require auth) - now MCP-powered by default
 const memoryCmd = program
     .command('memory')
     .alias('mem')
     .description('Memory management commands');
 requireAuth(memoryCmd);
 memoryCommands(memoryCmd);
+// Note: Memory commands are now MCP-powered when available
 // Topic commands (require auth)
 const topicCmd = program
     .command('topic')
@@ -174,8 +198,7 @@ program
 // Help customization
 program.configureHelp({
     formatHelp: (cmd, helper) => {
-        const term = helper.termWidth || 80;
-        const helpWidth = Math.min(term - 2, 80);
+        // Get terminal width for formatting (currently using default helper formatting)
         let help = chalk.blue.bold('🧠 Memory as a Service CLI\n\n');
         help += helper.commandUsage(cmd) + '\n\n';
         if (cmd.description()) {