@lanonasis/cli 3.0.1 → 3.0.2

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

@@ -0,0 +1,5 @@
+/**
+ * Enhanced Memory Commands - mem0-inspired advanced operations
+ */
+import { Command } from 'commander';
+export declare function enhancedMemoryCommands(program: Command): void;

package/dist/commands/enhanced-memory.js

@@ -0,0 +1,404 @@
+/**
+ * Enhanced Memory Commands - mem0-inspired advanced operations
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { table } from 'table';
+import inquirer from 'inquirer';
+import { getMCPClient } from '../utils/mcp-client.js';
+import { CLIConfig } from '../utils/config.js';
+export function enhancedMemoryCommands(program) {
+    const memory = program.command('memory').description('Enhanced memory operations with mem0-inspired features');
+    // Bulk pause memories
+    memory.command('bulk-pause')
+        .description('Pause multiple memories by criteria')
+        .option('--category <category>', 'Pause memories in specific category')
+        .option('--app <app_id>', 'Pause memories from specific app')
+        .option('--before <date>', 'Pause memories created before date (ISO format)')
+        .option('--ids <ids>', 'Comma-separated memory IDs to pause')
+        .option('--dry-run', 'Show what would be paused without executing')
+        .action(async (options) => {
+        const spinner = ora('Processing bulk pause operation...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Connecting to MCP server...');
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+            }
+            const bulkArgs = { operation: 'pause' };
+            if (options.category)
+                bulkArgs.category = options.category;
+            if (options.app)
+                bulkArgs.app_id = options.app;
+            if (options.before)
+                bulkArgs.before = options.before;
+            if (options.ids)
+                bulkArgs.memory_ids = options.ids.split(',').map((id) => id.trim());
+            if (options.dryRun) {
+                spinner.succeed('Dry run mode - showing affected memories');
+                console.log(chalk.yellow('This would pause memories matching the criteria'));
+                return;
+            }
+            const result = await client.callTool('memory_bulk_operations', bulkArgs);
+            spinner.succeed(`Bulk pause completed: ${result.result?.affected_count} memories paused`);
+            if (result.result?.results && result.result?.results.length > 0) {
+                console.log(chalk.cyan('\n📊 Operation Results:'));
+                const tableData = [
+                    [chalk.bold('Memory ID'), chalk.bold('Status'), chalk.bold('Previous State')]
+                ];
+                result.result?.results.forEach((r) => {
+                    tableData.push([
+                        r.memory_id.substring(0, 8) + '...',
+                        r.success ? chalk.green('✓ Paused') : chalk.red('✗ Failed'),
+                        r.previous_state
+                    ]);
+                });
+                console.log(table(tableData));
+            }
+        }
+        catch (error) {
+            spinner.fail(`Bulk pause failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Archive old memories
+    memory.command('archive')
+        .description('Archive memories older than specified date')
+        .requiredOption('--before <date>', 'Archive memories created before date (ISO format)')
+        .option('--app <app_id>', 'Archive memories from specific app')
+        .option('--dry-run', 'Show what would be archived without executing')
+        .action(async (options) => {
+        const spinner = ora('Processing archive operation...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Connecting to MCP server...');
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+            }
+            const bulkArgs = {
+                operation: 'archive',
+                before: options.before
+            };
+            if (options.app)
+                bulkArgs.app_id = options.app;
+            if (options.dryRun) {
+                spinner.succeed('Dry run mode - showing memories to be archived');
+                console.log(chalk.yellow(`This would archive memories created before ${options.before}`));
+                return;
+            }
+            const result = await client.callTool('memory_bulk_operations', bulkArgs);
+            spinner.succeed(`Archive completed: ${result.result?.affected_count} memories archived`);
+            console.log(chalk.green(`\n✓ Successfully archived ${result.result?.affected_count} memories`));
+            console.log(chalk.cyan(`  Archived memories created before: ${options.before}`));
+            if (options.app) {
+                console.log(chalk.cyan(`  From app: ${options.app}`));
+            }
+        }
+        catch (error) {
+            spinner.fail(`Archive failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Find related memories
+    memory.command('related')
+        .description('Find memories related to a specific memory')
+        .argument('<memory_id>', 'Source memory ID')
+        .option('-l, --limit <number>', 'Maximum related memories to show', '5')
+        .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.6')
+        .action(async (memoryId, options) => {
+        const spinner = ora('Finding related memories...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Connecting to MCP server...');
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+            }
+            const result = await client.callTool('memory_find_related', {
+                memory_id: memoryId,
+                limit: parseInt(options.limit),
+                threshold: parseFloat(options.threshold)
+            });
+            spinner.succeed(`Found ${result.result?.count} related memories`);
+            if (result.result?.count === 0) {
+                console.log(chalk.yellow('\nNo related memories found'));
+                return;
+            }
+            console.log(chalk.cyan('\n🔗 Source Memory:'));
+            console.log(`  ${chalk.bold(result.result?.source_memory.title)}`);
+            console.log(`  ${result.result?.source_memory.content.substring(0, 100)}...`);
+            console.log(chalk.cyan('\n🔍 Related Memories:'));
+            result.result?.related_memories.forEach((memory, index) => {
+                console.log(`\n${chalk.bold(`${index + 1}. ${memory.title}`)}`);
+                console.log(`   ID: ${chalk.gray(memory.id)}`);
+                const similarity = memory.relevance_score ?? memory.score;
+                if (similarity !== undefined) {
+                    console.log(`   Similarity: ${chalk.green((similarity * 100).toFixed(1) + '%')}`);
+                }
+                const content = memory.content ?? memory.metadata?.content ?? '';
+                console.log(`   Content: ${content
+                    ? `${content.substring(0, 80)}...`
+                    : chalk.gray('[no preview]')}`);
+            });
+        }
+        catch (error) {
+            spinner.fail(`Related search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Advanced filtering
+    memory.command('filter')
+        .description('Filter memories with advanced criteria')
+        .option('--app-id <app_id>', 'Filter by application ID')
+        .option('--category <category>', 'Filter by category/tag')
+        .option('--since <date>', 'Filter memories since date (ISO format)')
+        .option('--before <date>', 'Filter memories before date (ISO format)')
+        .option('--state <state>', 'Filter by memory state (active, paused, archived)')
+        .option('--limit <number>', 'Maximum results', '20')
+        .action(async (options) => {
+        const spinner = ora('Filtering memories...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Connecting to MCP server...');
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+            }
+            const searchArgs = {
+                query: '*', // Wildcard search
+                limit: parseInt(options.limit)
+            };
+            if (options.appId)
+                searchArgs.app_id = options.appId;
+            if (options.category)
+                searchArgs.category = options.category;
+            if (options.since)
+                searchArgs.since = options.since;
+            if (options.before)
+                searchArgs.before = options.before;
+            const result = await client.callTool('memory_search_memories', searchArgs);
+            spinner.succeed(`Found ${result.result?.total || result.result?.results.length} memories`);
+            if (result.result?.results.length === 0) {
+                console.log(chalk.yellow('\nNo memories match the filter criteria'));
+                return;
+            }
+            console.log(chalk.cyan('\n📋 Filtered Memories:'));
+            const tableData = [
+                [chalk.bold('ID'), chalk.bold('Title'), chalk.bold('Type'), chalk.bold('Created')]
+            ];
+            result.result?.results.forEach((memory) => {
+                tableData.push([
+                    memory.id.substring(0, 8) + '...',
+                    memory.title.substring(0, 30) + (memory.title.length > 30 ? '...' : ''),
+                    memory.memory_type || 'context',
+                    new Date(memory.created_at).toLocaleDateString()
+                ]);
+            });
+            console.log(table(tableData));
+            // Show filter summary
+            console.log(chalk.cyan('\n📊 Filter Summary:'));
+            if (options.appId)
+                console.log(`  App ID: ${options.appId}`);
+            if (options.category)
+                console.log(`  Category: ${options.category}`);
+            if (options.since)
+                console.log(`  Since: ${options.since}`);
+            if (options.before)
+                console.log(`  Before: ${options.before}`);
+            if (options.state)
+                console.log(`  State: ${options.state}`);
+        }
+        catch (error) {
+            spinner.fail(`Filter failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Memory analytics
+    memory.command('analytics')
+        .description('Show memory usage analytics and insights')
+        .option('--app <app_id>', 'Analytics for specific app')
+        .option('--period <days>', 'Analysis period in days', '30')
+        .action(async (options) => {
+        const spinner = ora('Generating memory analytics...').start();
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                spinner.info('Connecting to MCP server...');
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+            }
+            // Get all memories for analysis
+            const allMemories = await client.callTool('memory_search_memories', {
+                query: '*',
+                limit: 1000
+            });
+            spinner.succeed('Analytics generated');
+            const memories = allMemories.result?.results || [];
+            // Basic statistics
+            console.log(chalk.cyan('\n📊 Memory Analytics'));
+            console.log(chalk.cyan('=================='));
+            console.log(`Total Memories: ${chalk.bold(memories.length)}`);
+            // Memory types breakdown
+            const typeBreakdown = {};
+            memories.forEach((m) => {
+                const type = m.memory_type || 'context';
+                typeBreakdown[type] = (typeBreakdown[type] || 0) + 1;
+            });
+            console.log(chalk.cyan('\n📈 Memory Types:'));
+            Object.entries(typeBreakdown).forEach(([type, count]) => {
+                const percentage = ((count / memories.length) * 100).toFixed(1);
+                console.log(`  ${type}: ${chalk.bold(count)} (${percentage}%)`);
+            });
+            // Recent activity
+            const now = new Date();
+            const periodDays = parseInt(options.period);
+            const cutoffDate = new Date(now.getTime() - (periodDays * 24 * 60 * 60 * 1000));
+            const recentMemories = memories.filter((m) => new Date(m.created_at) >= cutoffDate);
+            console.log(chalk.cyan(`\n📅 Recent Activity (${periodDays} days):`));
+            console.log(`  New memories: ${chalk.bold(recentMemories.length)}`);
+            console.log(`  Daily average: ${chalk.bold((recentMemories.length / periodDays).toFixed(1))}`);
+            // App breakdown if not filtering by specific app
+            if (!options.app) {
+                const appBreakdown = {};
+                memories.forEach((m) => {
+                    const app = m.app_id || 'default';
+                    appBreakdown[app] = (appBreakdown[app] || 0) + 1;
+                });
+                console.log(chalk.cyan('\n🔧 App Usage:'));
+                Object.entries(appBreakdown)
+                    .sort(([, a], [, b]) => b - a)
+                    .slice(0, 5)
+                    .forEach(([app, count]) => {
+                    const percentage = ((count / memories.length) * 100).toFixed(1);
+                    console.log(`  ${app}: ${chalk.bold(count)} (${percentage}%)`);
+                });
+            }
+        }
+        catch (error) {
+            spinner.fail(`Analytics failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // Interactive memory management
+    memory.command('manage')
+        .description('Interactive memory management interface')
+        .action(async () => {
+        console.log(chalk.cyan('🧠 Interactive Memory Management'));
+        console.log(chalk.cyan('================================'));
+        try {
+            const client = getMCPClient();
+            if (!client.isConnectedToServer()) {
+                const spinner = ora('Connecting to MCP server...').start();
+                const config = new CLIConfig();
+                await client.connect({ useRemote: !!config.get('token') });
+                spinner.succeed('Connected to MCP server');
+            }
+            while (true) {
+                const { action } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'action',
+                        message: 'What would you like to do?',
+                        choices: [
+                            { name: '🔍 Search memories', value: 'search' },
+                            { name: '📊 View analytics', value: 'analytics' },
+                            { name: '🔗 Find related memories', value: 'related' },
+                            { name: '⏸️  Bulk pause memories', value: 'bulk_pause' },
+                            { name: '📦 Archive old memories', value: 'archive' },
+                            { name: '🚪 Exit', value: 'exit' }
+                        ]
+                    }
+                ]);
+                if (action === 'exit') {
+                    console.log(chalk.green('👋 Goodbye!'));
+                    break;
+                }
+                // Handle each action
+                switch (action) {
+                    case 'search':
+                    case 'search': {
+                        const { query } = await inquirer.prompt([
+                            { type: 'input', name: 'query', message: 'Enter search query:' }
+                        ]);
+                        if (query) {
+                            const spinner = ora('Searching...').start();
+                            const results = await client.callTool('memory_search_memories', { query });
+                            spinner.succeed(`Found ${results.result?.results.length} memories`);
+                            results.result?.results.slice(0, 5).forEach((m, i) => {
+                                console.log(`\n${i + 1}. ${chalk.bold(m.title)}`);
+                                console.log(`   ${m.content.substring(0, 100)}...`);
+                            });
+                        }
+                        break;
+                    }
+                    case 'analytics': {
+                        console.log(chalk.cyan('📊 Generating analytics...'));
+                        // Could call the analytics logic here
+                        break;
+                    }
+                    case 'related': {
+                        const { memoryId } = await inquirer.prompt([
+                            { type: 'input', name: 'memoryId', message: 'Enter memory ID:' }
+                        ]);
+                        if (memoryId) {
+                            const spinner = ora('Finding related memories...').start();
+                            const related = await client.callTool('memory_find_related', { memory_id: memoryId });
+                            spinner.succeed(`Found ${related.result?.count} related memories`);
+                            related.result?.related_memories?.slice(0, 3).forEach((m, i) => {
+                                console.log(`\n${i + 1}. ${chalk.bold(m.title)}`);
+                                console.log(`   Similarity: ${chalk.green((m.relevance_score * 100).toFixed(1) + '%')}`);
+                            });
+                        }
+                        break;
+                    }
+                    case 'bulk_pause': {
+                        const { pauseCriteria } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'pauseCriteria',
+                                message: 'Pause memories by:',
+                                choices: [
+                                    { name: 'Before specific date', value: 'date' },
+                                    { name: 'By category', value: 'category' },
+                                    { name: 'By app', value: 'app' }
+                                ]
+                            }
+                        ]);
+                        console.log(chalk.yellow(`Selected: ${pauseCriteria}`));
+                        // Could implement the specific pause logic here
+                        break;
+                    }
+                    case 'archive': {
+                        const { archiveDate } = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'archiveDate',
+                                message: 'Archive memories before date (YYYY-MM-DD):',
+                                validate: (input) => {
+                                    const date = new Date(input);
+                                    return !isNaN(date.getTime()) || 'Please enter a valid date';
+                                }
+                            }
+                        ]);
+                        if (archiveDate) {
+                            const spinner = ora('Archiving memories...').start();
+                            const result = await client.callTool('memory_bulk_operations', {
+                                operation: 'archive',
+                                before: archiveDate
+                            });
+                            spinner.succeed(`Archived ${result.result?.affected_count} memories`);
+                        }
+                        break;
+                    }
+                }
+                console.log(); // Add spacing
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`Management interface failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/mcp.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { table } from 'table';
 import { getMCPClient } from '../utils/mcp-client.js';
+import { EnhancedMCPClient } from '../mcp/client/enhanced-client.js';
 import { CLIConfig } from '../utils/config.js';
 export function mcpCommands(program) {
     const mcp = program
@@ -92,12 +93,32 @@ export function mcpCommands(program) {
                     config.set('mcpServerUrl', options.url);
                 }
             }
-            const client = getMCPClient();
-            const connected = await client.connect({
-                connectionMode,
-                serverPath: options.server,
-                serverUrl: options.url
-            });
+            let connected = false;
+            // Use Enhanced MCP Client for better connection handling
+            const enhancedClient = new EnhancedMCPClient();
+            if (options.url) {
+                // Connect to specific URL (WebSocket or remote)
+                const serverConfig = {
+                    name: 'user-specified',
+                    type: (options.url.startsWith('wss://') ? 'websocket' : 'stdio'),
+                    url: options.url,
+                    priority: 1
+                };
+                connected = await enhancedClient.connectSingle(serverConfig);
+                if (connected) {
+                    spinner.succeed(chalk.green(`Connected to MCP server at ${options.url}`));
+                    return;
+                }
+            }
+            else {
+                // Fall back to old client for local connections
+                const client = getMCPClient();
+                connected = await client.connect({
+                    connectionMode,
+                    serverPath: options.server,
+                    serverUrl: options.url
+                });
+            }
             if (connected) {
                 spinner.succeed(chalk.green(`Connected to MCP server in ${connectionMode} mode`));
                 if (connectionMode === 'remote') {

package/dist/mcp/access-control.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Memory Access Control System
+ * Implements granular permissions and audit logging inspired by mem0's ACL system
+ */
+export interface AccessControlRule {
+    id: string;
+    user_id: string;
+    app_id: string;
+    memory_id?: string;
+    permission: 'read' | 'write' | 'delete' | 'admin';
+    granted: boolean;
+    created_at: string;
+    expires_at?: string;
+}
+export interface AccessLog {
+    id: string;
+    user_id: string;
+    app_id: string;
+    memory_id: string;
+    access_type: string;
+    timestamp: string;
+    success: boolean;
+    metadata?: Record<string, any>;
+}
+export declare class MemoryAccessControl {
+    private config;
+    private accessRules;
+    private accessLogs;
+    constructor();
+    /**
+     * Check if user has access to create memories in an app
+     */
+    checkCreateAccess(userId: string, appId: string): Promise<boolean>;
+    /**
+     * Check if user has access to read a specific memory
+     */
+    checkMemoryAccess(memoryId: string, appId: string): Promise<boolean>;
+    /**
+     * Get all memories accessible to a user in an app
+     */
+    getAccessibleMemories(userId: string, appId: string): Promise<string[]>;
+    /**
+     * Log memory access for audit purposes
+     */
+    logMemoryAccess(memoryId: string, appId: string, accessType: string, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * Grant access to a memory or app
+     */
+    grantAccess(userId: string, appId: string, permission: 'read' | 'write' | 'delete' | 'admin', memoryId?: string, expiresAt?: string): Promise<void>;
+    /**
+     * Revoke access to a memory or app
+     */
+    revokeAccess(userId: string, appId: string, memoryId?: string): Promise<void>;
+    /**
+     * Get access logs for audit purposes
+     */
+    getAccessLogs(userId?: string, appId?: string, memoryId?: string, limit?: number): AccessLog[];
+    /**
+     * Private helper methods
+     */
+    private getAccessRules;
+    private isUserApp;
+    private getCurrentUserId;
+    private getMemoryInfo;
+    private getUserMemories;
+    private getSharedMemories;
+    private generateId;
+}