@lanonasis/cli 1.0.1 → 1.1.0

package/README.md

@@ -1,8 +1,14 @@
 # Lanonasis CLI - Enterprise Infrastructure Management
 
-🚀 **Professional CLI for Lanonasis Platform Services**
+🚀 **Professional CLI for Lanonasis Platform Services with MCP Integration**
 
-The Lanonasis CLI provides a powerful command-line interface for interacting with the entire Lanonasis ecosystem, including Memory as a Service (MaaS), infrastructure management, and multi-service orchestration. Manage your memories, search through knowledge bases, organize your thoughts, and control your infrastructure - all from the terminal.
+The Lanonasis CLI provides a powerful command-line interface for interacting with the entire Lanonasis ecosystem, including Memory as a Service (MaaS), infrastructure management, and multi-service orchestration. Now with **Model Context Protocol (MCP)** integration for unified AI-agent communication. Manage your memories, search through knowledge bases, organize your thoughts, and control your infrastructure - all from the terminal.
+
+## 🆕 New in v1.1.0
+- **MCP Integration**: Full Model Context Protocol support for AI agents
+- **Hybrid Mode**: Seamless switching between local MCP and remote API
+- **Real-time Updates**: SSE streaming for live memory synchronization
+- **Unified Interface**: Same commands work with local or cloud backends
 
 ## ⚡ Quick Start
 
@@ -135,6 +141,40 @@ memory search "my query"  # Direct memory command
 maas list --type knowledge  # MaaS command
 ```
 
+## 🤖 MCP Integration (Model Context Protocol)
+
+The CLI now includes full MCP support for AI agent integration:
+
+```bash
+# Connect to MCP server
+lanonasis mcp connect          # Auto-detect mode
+lanonasis mcp connect --remote  # Use cloud API
+lanonasis mcp connect --local   # Use local server
+
+# Check MCP status
+lanonasis mcp status
+
+# List available tools
+lanonasis mcp tools
+
+# Memory operations via MCP
+lanonasis mcp memory create -t "Title" -c "Content"
+lanonasis mcp memory search "query"
+
+# Stream real-time updates
+lanonasis memory-mcp stream
+
+# Configure MCP preferences
+lanonasis mcp config --prefer-remote
+```
+
+### MCP Features:
+- **Unified Interface**: Same commands for local/remote backends
+- **Auto-Connect**: Automatically connects based on auth status
+- **Tool Discovery**: Dynamic listing of available MCP tools
+- **Real-time SSE**: Live updates when using remote mode
+- **Hybrid Mode**: Seamless fallback between MCP and REST API
+
 ## 🌐 MaaS Service Integration
 
 This CLI is designed to work with Memory as a Service platforms that provide:
@@ -181,11 +221,43 @@ node dist/index-simple.js help
 - **Configuration** - Flexible service setup
 - **Help System** - Comprehensive documentation
 
+## 📦 SDK & Related Packages
+
+### Memory Client SDK
+Install the TypeScript/JavaScript SDK for application integration:
+
+```bash
+# Install SDK for your applications
+npm install @lanonasis/memory-client
+
+# Use in your code
+import { createMemoryClient } from '@lanonasis/memory-client';
+
+const client = createMemoryClient({
+  baseURL: 'https://api.lanonasis.com',
+  apiKey: 'your-api-key-here'
+});
+```
+
+### Complete Installation for Developers
+```bash
+# Install CLI globally for command-line usage
+npm install -g @lanonasis/cli
+
+# Install SDK locally for application development
+npm install @lanonasis/memory-client
+
+# Now you have both CLI and SDK available!
+lanonasis --help                    # CLI commands
+# SDK available for import in your code
+```
+
 ## 🔗 Related Projects
 
-- **Memory Service Backend** - Full MaaS API server
-- **Memory SDK** - JavaScript/TypeScript SDK for developers
-- **Memory Visualizer** - Interactive memory exploration
+- **Memory Service Backend** - Full MaaS API server ([GitHub](https://github.com/thefixer3x/vibe-memory))
+- **Memory Client SDK** - JavaScript/TypeScript SDK (`@lanonasis/memory-client`)
+- **Memory Visualizer** - Interactive memory exploration (included in backend)
+- **VSCode Extension** - IDE integration (coming soon)
 
 ## 📄 License
 

package/dist/commands/auth.d.ts

@@ -1 +1,6 @@
-export declare function loginCommand(options: any): Promise<void>;
+interface LoginOptions {
+    email?: string;
+    password?: string;
+}
+export declare function loginCommand(options: LoginOptions): Promise<void>;
+export {};

package/dist/commands/auth.js

@@ -49,7 +49,9 @@ export async function loginCommand(options) {
     }
     catch (error) {
         spinner.fail('Login failed');
-        if (error.response?.status === 401) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const errorResponse = error && typeof error === 'object' && 'response' in error ? error.response : null;
+        if (errorResponse && typeof errorResponse === 'object' && 'status' in errorResponse && errorResponse.status === 401) {
             console.error(chalk.red('✖ Invalid email or password'));
             // Ask if they want to register
             const answer = await inquirer.prompt([
@@ -65,7 +67,7 @@ export async function loginCommand(options) {
             }
         }
         else {
-            console.error(chalk.red('✖ Login failed:'), error.message);
+            console.error(chalk.red('✖ Login failed:'), errorMessage);
         }
         process.exit(1);
     }
@@ -98,7 +100,7 @@ async function registerFlow(defaultEmail) {
             message: 'Confirm password:',
             mask: '*',
             validate: (input, answers) => {
-                return input === answers.password || 'Passwords do not match';
+                return input === answers?.password || 'Passwords do not match';
             }
         },
         {
@@ -124,7 +126,8 @@ async function registerFlow(defaultEmail) {
     }
     catch (error) {
         spinner.fail('Registration failed');
-        console.error(chalk.red('✖ Registration failed:'), error.message);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('✖ Registration failed:'), errorMessage);
         process.exit(1);
     }
 }

package/dist/commands/config.js

@@ -3,6 +3,65 @@ import inquirer from 'inquirer';
 import { CLIConfig } from '../utils/config.js';
 import { apiClient } from '../utils/api.js';
 export function configCommands(program) {
+    // Generic config set command
+    program
+        .command('set <key> <value>')
+        .description('Set configuration value')
+        .action(async (key, value) => {
+        const config = new CLIConfig();
+        await config.init();
+        // Handle special cases
+        switch (key) {
+            case 'api-url':
+                await config.setApiUrl(value);
+                console.log(chalk.green('✓ API URL updated:'), value);
+                break;
+            case 'ai-integration':
+                if (value === 'claude-mcp') {
+                    config.set('mcpEnabled', true);
+                    config.set('aiIntegration', 'claude-mcp');
+                    console.log(chalk.green('✓ AI integration set to Claude MCP'));
+                    console.log(chalk.cyan('  MCP will be automatically initialized for memory operations'));
+                    console.log(chalk.cyan('  Run "lanonasis mcp-server init" to test the connection'));
+                }
+                else {
+                    console.log(chalk.yellow('⚠️  Unknown AI integration:'), value);
+                    console.log(chalk.gray('  Currently supported: claude-mcp'));
+                }
+                break;
+            case 'mcp-use-remote':
+                config.set('mcpUseRemote', value === 'true');
+                console.log(chalk.green('✓ MCP remote mode:'), value === 'true' ? 'enabled' : 'disabled');
+                break;
+            case 'mcp-server-path':
+                config.set('mcpServerPath', value);
+                console.log(chalk.green('✓ MCP server path updated:'), value);
+                break;
+            case 'mcp-server-url':
+                config.set('mcpServerUrl', value);
+                console.log(chalk.green('✓ MCP server URL updated:'), value);
+                break;
+            default:
+                // Generic config set
+                config.set(key, value);
+                console.log(chalk.green(`✓ ${key} set to:`), value);
+        }
+    });
+    // Generic config get command
+    program
+        .command('get <key>')
+        .description('Get configuration value')
+        .action(async (key) => {
+        const config = new CLIConfig();
+        await config.init();
+        const value = config.get(key);
+        if (value !== undefined) {
+            console.log(chalk.green(`${key}:`), value);
+        }
+        else {
+            console.log(chalk.yellow(`⚠️  ${key} is not set`));
+        }
+    });
     // Show current configuration
     program
         .command('show')
@@ -26,6 +85,29 @@ export function configCommands(program) {
             }
         }
     });
+    // List all configuration options
+    program
+        .command('list')
+        .description('List all configuration options')
+        .action(async () => {
+        const config = new CLIConfig();
+        await config.init();
+        console.log(chalk.blue.bold('📋 Configuration Options'));
+        console.log();
+        const configOptions = [
+            { key: 'api-url', description: 'API endpoint URL', current: config.getApiUrl() },
+            { key: 'ai-integration', description: 'AI integration mode', current: config.get('aiIntegration') || 'none' },
+            { key: 'mcp-use-remote', description: 'Use remote MCP server', current: config.get('mcpUseRemote') || false },
+            { key: 'mcp-server-path', description: 'Local MCP server path', current: config.get('mcpServerPath') || 'default' },
+            { key: 'mcp-server-url', description: 'Remote MCP server URL', current: config.get('mcpServerUrl') || 'https://api.lanonasis.com' },
+            { key: 'mcpEnabled', description: 'MCP integration enabled', current: config.get('mcpEnabled') || false }
+        ];
+        configOptions.forEach(opt => {
+            console.log(chalk.green(opt.key.padEnd(20)), chalk.gray(opt.description.padEnd(30)), chalk.yellow(String(opt.current)));
+        });
+        console.log();
+        console.log(chalk.gray('Use "lanonasis config set <key> <value>" to update any option'));
+    });
     // Set API URL
     program
         .command('set-url')
@@ -72,24 +154,26 @@ export function configCommands(program) {
             console.log(chalk.green('✓ Connection successful'));
             console.log(`Status: ${health.status}`);
             console.log(`Version: ${health.version}`);
-            console.log(`Uptime: ${Math.round(health.uptime)}s`);
             if (health.dependencies) {
                 console.log();
                 console.log(chalk.yellow('Dependencies:'));
                 Object.entries(health.dependencies).forEach(([name, info]) => {
                     const status = info.status === 'healthy' ? chalk.green('✓') : chalk.red('✖');
-                    console.log(`  ${status} ${name}: ${info.status} (${info.response_time}ms)`);
+                    const responseTime = info.response_time || info.latency_ms || 0;
+                    console.log(`  ${status} ${name}: ${info.status} (${responseTime}ms)`);
                 });
             }
         }
         catch (error) {
             console.log(chalk.red('✖ Connection failed'));
-            if (error.code === 'ECONNREFUSED') {
+            const errorCode = error && typeof error === 'object' && 'code' in error ? error.code : null;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (errorCode === 'ECONNREFUSED') {
                 console.error(chalk.red('Cannot connect to API server'));
                 console.log(chalk.yellow('Make sure the API server is running'));
             }
             else {
-                console.error(chalk.red('Error:'), error.message);
+                console.error(chalk.red('Error:'), errorMessage);
             }
             process.exit(1);
         }

package/dist/commands/init.d.ts

@@ -1 +1,5 @@
-export declare function initCommand(options: any): Promise<void>;
+interface InitOptions {
+    force?: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/mcp.d.ts

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

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');
+        }
+    });
+}