@lanonasis/cli 1.0.1 → 1.1.0

package/dist/commands/memory.js

@@ -80,7 +80,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,10 +101,10 @@ 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
+                page: parseInt(options.page || '1'),
+                limit: parseInt(options.limit || '20'),
+                sort: options.sort || 'created_at',
+                order: options.order || 'desc'
             };
             if (options.type)
                 params.memory_type = options.type;
@@ -155,7 +156,8 @@ export function memoryCommands(program) {
             }
         }
         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 +174,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());
@@ -202,7 +204,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 +247,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 +328,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 +362,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 +400,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);
         }
     });
@@ -133,7 +134,8 @@ export function topicCommands(program) {
             }
         }
         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 (error) {
+            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')

package/dist/utils/api.d.ts

@@ -1,24 +1,164 @@
 import { AxiosRequestConfig } from 'axios';
+export interface AuthResponse {
+    user: {
+        id: string;
+        email: string;
+        organization_id: string;
+        role: 'admin' | 'user' | 'viewer';
+        plan: 'free' | 'pro' | 'enterprise';
+        created_at: string;
+        updated_at: string;
+    };
+    token: string;
+    expires_at: string;
+}
+export interface RegisterRequest {
+    email: string;
+    password: string;
+    organization_name?: string;
+}
+export interface LoginRequest {
+    email: string;
+    password: string;
+}
+export type MemoryType = 'context' | 'project' | 'knowledge' | 'reference' | 'personal' | 'workflow';
+export interface MemoryEntry {
+    id: string;
+    title: string;
+    content: string;
+    memory_type: MemoryType;
+    tags: string[];
+    topic_id?: string | null;
+    user_id: string;
+    organization_id: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    last_accessed?: string;
+    access_count: number;
+}
+export interface CreateMemoryRequest {
+    title: string;
+    content: string;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateMemoryRequest {
+    title?: string;
+    content?: string;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface GetMemoriesParams {
+    limit?: number;
+    offset?: number;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string;
+    sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
+    sort_order?: 'asc' | 'desc';
+}
+export interface SearchMemoryRequest {
+    query: string;
+    memory_types?: MemoryType[];
+    tags?: string[];
+    topic_id?: string;
+    limit?: number;
+    threshold?: number;
+}
+export interface MemorySearchResult extends MemoryEntry {
+    relevance_score: number;
+}
+export interface MemoryStats {
+    total_memories: number;
+    memories_by_type: Record<MemoryType, number>;
+    total_size_bytes: number;
+    avg_access_count: number;
+    most_accessed_memory?: MemoryEntry;
+    recent_memories: MemoryEntry[];
+}
+export interface BulkDeleteRequest {
+    memory_ids: string[];
+}
+export interface BulkDeleteResponse {
+    deleted_count: number;
+    failed_deletes?: string[];
+}
+export interface MemoryTopic {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    user_id: string;
+    parent_topic_id?: string;
+    is_system: boolean;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateTopicRequest {
+    name: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    parent_topic_id?: string;
+}
+export interface UpdateTopicRequest {
+    name?: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    parent_topic_id?: string;
+}
+export interface HealthStatus {
+    status: 'healthy' | 'unhealthy';
+    version: string;
+    timestamp: string;
+    dependencies: Record<string, {
+        status: string;
+        latency_ms?: number;
+    }>;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        has_more: boolean;
+    };
+}
+export interface ApiErrorResponse {
+    error: string;
+    message: string;
+    status_code: number;
+    details?: Record<string, unknown>;
+}
 export declare class APIClient {
     private client;
     private config;
     constructor();
-    login(email: string, password: string): Promise<any>;
-    register(email: string, password: string, organizationName?: string): Promise<any>;
-    createMemory(data: any): Promise<any>;
-    getMemories(params?: any): Promise<any>;
-    getMemory(id: string): Promise<any>;
-    updateMemory(id: string, data: any): Promise<any>;
+    login(email: string, password: string): Promise<AuthResponse>;
+    register(email: string, password: string, organizationName?: string): Promise<AuthResponse>;
+    createMemory(data: CreateMemoryRequest): Promise<MemoryEntry>;
+    getMemories(params?: GetMemoriesParams): Promise<PaginatedResponse<MemoryEntry>>;
+    getMemory(id: string): Promise<MemoryEntry>;
+    updateMemory(id: string, data: UpdateMemoryRequest): Promise<MemoryEntry>;
     deleteMemory(id: string): Promise<void>;
-    searchMemories(query: string, options?: any): Promise<any>;
-    getMemoryStats(): Promise<any>;
-    bulkDeleteMemories(memoryIds: string[]): Promise<any>;
-    createTopic(data: any): Promise<any>;
-    getTopics(): Promise<any>;
-    getTopic(id: string): Promise<any>;
-    updateTopic(id: string, data: any): Promise<any>;
+    searchMemories(query: string, options?: Omit<SearchMemoryRequest, 'query'>): Promise<PaginatedResponse<MemorySearchResult>>;
+    getMemoryStats(): Promise<MemoryStats>;
+    bulkDeleteMemories(memoryIds: string[]): Promise<BulkDeleteResponse>;
+    createTopic(data: CreateTopicRequest): Promise<MemoryTopic>;
+    getTopics(): Promise<MemoryTopic[]>;
+    getTopic(id: string): Promise<MemoryTopic>;
+    updateTopic(id: string, data: UpdateTopicRequest): Promise<MemoryTopic>;
     deleteTopic(id: string): Promise<void>;
-    getHealth(): Promise<any>;
-    request<T = any>(config: AxiosRequestConfig): Promise<T>;
+    getHealth(): Promise<HealthStatus>;
+    request<T = Record<string, unknown>>(config: AxiosRequestConfig): Promise<T>;
 }
 export declare const apiClient: APIClient;

package/dist/utils/config.d.ts

@@ -22,5 +22,11 @@ export declare class CLIConfig {
     clear(): Promise<void>;
     getConfigPath(): string;
     exists(): Promise<boolean>;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    setAndSave(key: string, value: any): Promise<void>;
+    getMCPServerPath(): string;
+    getMCPServerUrl(): string;
+    shouldUseRemoteMCP(): boolean;
 }
 export {};

package/dist/utils/config.js

@@ -1,7 +1,10 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
 import { jwtDecode } from 'jwt-decode';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class CLIConfig {
     configDir;
     configPath;
@@ -15,7 +18,7 @@ export class CLIConfig {
             await fs.mkdir(this.configDir, { recursive: true });
             await this.load();
         }
-        catch (error) {
+        catch {
             // Config doesn't exist yet, that's ok
         }
     }
@@ -24,7 +27,7 @@ export class CLIConfig {
             const data = await fs.readFile(this.configPath, 'utf-8');
             this.config = JSON.parse(data);
         }
-        catch (error) {
+        catch {
             this.config = {};
         }
     }
@@ -50,13 +53,13 @@ export class CLIConfig {
             // We'll need to fetch full user details from the API
             // For now, store what we can decode
             this.config.user = {
-                email: decoded.email || '',
-                organization_id: decoded.organizationId || '',
-                role: decoded.role || '',
-                plan: decoded.plan || ''
+                email: String(decoded.email || ''),
+                organization_id: String(decoded.organizationId || ''),
+                role: String(decoded.role || ''),
+                plan: String(decoded.plan || '')
             };
         }
-        catch (error) {
+        catch {
             // Invalid token, don't store user info
         }
         await this.save();
@@ -74,9 +77,9 @@ export class CLIConfig {
         try {
             const decoded = jwtDecode(token);
             const now = Date.now() / 1000;
-            return decoded.exp > now;
+            return typeof decoded.exp === 'number' && decoded.exp > now;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -101,4 +104,35 @@ export class CLIConfig {
             return false;
         }
     }
+    // Generic get/set methods for MCP and other dynamic config
+    get(key) {
+        return this.config[key];
+    }
+    set(key, value) {
+        this.config[key] = value;
+    }
+    async setAndSave(key, value) {
+        this.set(key, value);
+        await this.save();
+    }
+    // MCP-specific helpers
+    getMCPServerPath() {
+        return this.config.mcpServerPath || path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
+    }
+    getMCPServerUrl() {
+        return this.config.mcpServerUrl || 'https://api.lanonasis.com';
+    }
+    shouldUseRemoteMCP() {
+        const preference = this.config.mcpPreference || 'auto';
+        switch (preference) {
+            case 'remote':
+                return true;
+            case 'local':
+                return false;
+            case 'auto':
+            default:
+                // Use remote if authenticated, otherwise local
+                return !!this.config.token;
+        }
+    }
 }

package/dist/utils/formatting.d.ts

@@ -1,4 +1,4 @@
-export declare function formatOutput(data: any, format?: string): void;
+export declare function formatOutput(data: unknown, format?: string): void;
 export declare function formatBytes(bytes: number): string;
 export declare function truncateText(text: string, maxLength: number): string;
 export declare function formatDuration(ms: number): string;

package/dist/utils/mcp-client.d.ts

@@ -0,0 +1,53 @@
+interface MCPConnectionOptions {
+    serverPath?: string;
+    serverUrl?: string;
+    useRemote?: boolean;
+}
+export declare class MCPClient {
+    private client;
+    private config;
+    private isConnected;
+    private sseConnection;
+    constructor();
+    /**
+     * Connect to MCP server (local or remote)
+     */
+    connect(options?: MCPConnectionOptions): Promise<boolean>;
+    /**
+     * Initialize SSE connection for real-time updates
+     */
+    private initializeSSE;
+    /**
+     * Disconnect from MCP server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Call an MCP tool
+     */
+    callTool(toolName: string, args: any): Promise<any>;
+    /**
+     * Call remote tool via REST API with MCP interface
+     */
+    private callRemoteTool;
+    /**
+     * List available tools
+     */
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+    }>>;
+    /**
+     * Check if connected to MCP server
+     */
+    isConnectedToServer(): boolean;
+    /**
+     * Get connection status details
+     */
+    getConnectionStatus(): {
+        connected: boolean;
+        mode: string;
+        server?: string;
+    };
+}
+export declare function getMCPClient(): MCPClient;
+export {};