@lanonasis/memory-client 1.0.1 → 2.0.0

package/dist/node/index.js

@@ -0,0 +1,610 @@
+import { CoreMemoryClient } from '../core/client';
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+
+/**
+ * CLI Integration Module for Memory Client SDK
+ *
+ * Provides intelligent CLI detection and MCP channel utilization
+ * when @lanonasis/cli v1.5.2+ is available in the environment
+ *
+ * IMPORTANT: This file imports Node.js modules and should only be used in Node.js environments
+ */
+const execAsync = promisify(exec);
+/**
+ * CLI Detection and Integration Service
+ */
+class CLIIntegration {
+    constructor() {
+        this.cliInfo = null;
+        this.detectionPromise = null;
+    }
+    /**
+     * Detect if CLI is available and get its capabilities
+     */
+    async detectCLI() {
+        // Return cached result if already detected
+        if (this.cliInfo) {
+            return this.cliInfo;
+        }
+        // Return existing promise if detection is in progress
+        if (this.detectionPromise) {
+            return this.detectionPromise;
+        }
+        // Start new detection
+        this.detectionPromise = this.performDetection();
+        this.cliInfo = await this.detectionPromise;
+        return this.cliInfo;
+    }
+    async performDetection() {
+        try {
+            // Check if onasis/lanonasis CLI is available
+            let versionOutput = '';
+            try {
+                const { stdout } = await execAsync('onasis --version 2>/dev/null', { timeout: 5000 });
+                versionOutput = stdout;
+            }
+            catch {
+                // Try lanonasis if onasis fails
+                const { stdout } = await execAsync('lanonasis --version 2>/dev/null', { timeout: 5000 });
+                versionOutput = stdout;
+            }
+            const version = versionOutput.trim();
+            // Verify it's v1.5.2 or higher for Golden Contract support
+            const versionMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
+            if (!versionMatch) {
+                return { available: false };
+            }
+            const [, major, minor, patch] = versionMatch.map(Number);
+            const isCompatible = major > 1 || (major === 1 && minor > 5) || (major === 1 && minor === 5 && patch >= 2);
+            if (!isCompatible) {
+                return {
+                    available: true,
+                    version,
+                    mcpAvailable: false,
+                    authenticated: false
+                };
+            }
+            // Check MCP availability
+            let mcpAvailable = false;
+            try {
+                await execAsync('onasis mcp status --output json 2>/dev/null || lanonasis mcp status --output json 2>/dev/null', {
+                    timeout: 3000
+                });
+                mcpAvailable = true;
+            }
+            catch {
+                // MCP not available or not configured
+            }
+            // Check authentication status
+            let authenticated = false;
+            try {
+                const { stdout: authOutput } = await execAsync('onasis auth status --output json 2>/dev/null || lanonasis auth status --output json 2>/dev/null', {
+                    timeout: 3000
+                });
+                const authStatus = JSON.parse(authOutput);
+                authenticated = authStatus.authenticated === true;
+            }
+            catch {
+                // Authentication check failed
+            }
+            return {
+                available: true,
+                version,
+                mcpAvailable,
+                authenticated
+            };
+        }
+        catch {
+            return { available: false };
+        }
+    }
+    /**
+     * Execute CLI command and return parsed JSON result
+     */
+    async executeCLICommand(command, options = {}) {
+        const cliInfo = await this.detectCLI();
+        if (!cliInfo.available) {
+            return { error: 'CLI not available' };
+        }
+        if (!cliInfo.authenticated) {
+            return { error: 'CLI not authenticated. Run: onasis login' };
+        }
+        try {
+            const timeout = options.timeout || 30000;
+            const outputFormat = options.outputFormat || 'json';
+            const verbose = options.verbose ? '--verbose' : '';
+            // Determine which CLI command to use (prefer onasis for Golden Contract)
+            const cliCmd = await this.getPreferredCLICommand();
+            const fullCommand = `${cliCmd} ${command} --output ${outputFormat} ${verbose}`.trim();
+            const { stdout, stderr } = await execAsync(fullCommand, {
+                timeout,
+                maxBuffer: 1024 * 1024 // 1MB buffer
+            });
+            if (stderr && stderr.trim()) {
+                console.warn('CLI warning:', stderr);
+            }
+            if (outputFormat === 'json') {
+                try {
+                    const result = JSON.parse(stdout);
+                    return { data: result };
+                }
+                catch (parseError) {
+                    return { error: `Failed to parse CLI JSON output: ${parseError instanceof Error ? parseError.message : 'Unknown error'}` };
+                }
+            }
+            return { data: stdout };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                return { error: 'CLI command timeout' };
+            }
+            return {
+                error: error instanceof Error ? error.message : 'CLI command failed'
+            };
+        }
+    }
+    /**
+     * Get preferred CLI command (onasis for Golden Contract, fallback to lanonasis)
+     */
+    async getPreferredCLICommand() {
+        try {
+            execSync('which onasis', { stdio: 'ignore', timeout: 1000 });
+            return 'onasis';
+        }
+        catch {
+            return 'lanonasis';
+        }
+    }
+    /**
+     * Memory operations via CLI
+     */
+    async createMemoryViaCLI(title, content, options = {}) {
+        const { memoryType = 'context', tags = [], topicId } = options;
+        let command = `memory create --title "${title}" --content "${content}" --memory-type ${memoryType}`;
+        if (tags.length > 0) {
+            command += ` --tags "${tags.join(',')}"`;
+        }
+        if (topicId) {
+            command += ` --topic-id "${topicId}"`;
+        }
+        return this.executeCLICommand(command);
+    }
+    async listMemoriesViaCLI(options = {}) {
+        let command = 'memory list';
+        if (options.limit) {
+            command += ` --limit ${options.limit}`;
+        }
+        if (options.memoryType) {
+            command += ` --memory-type ${options.memoryType}`;
+        }
+        if (options.tags && options.tags.length > 0) {
+            command += ` --tags "${options.tags.join(',')}"`;
+        }
+        if (options.sortBy) {
+            command += ` --sort-by ${options.sortBy}`;
+        }
+        return this.executeCLICommand(command);
+    }
+    async searchMemoriesViaCLI(query, options = {}) {
+        let command = `memory search "${query}"`;
+        if (options.limit) {
+            command += ` --limit ${options.limit}`;
+        }
+        if (options.memoryTypes && options.memoryTypes.length > 0) {
+            command += ` --memory-types "${options.memoryTypes.join(',')}"`;
+        }
+        return this.executeCLICommand(command);
+    }
+    /**
+     * Health check via CLI
+     */
+    async healthCheckViaCLI() {
+        return this.executeCLICommand('health');
+    }
+    /**
+     * MCP-specific operations
+     */
+    async getMCPStatus() {
+        const cliInfo = await this.detectCLI();
+        if (!cliInfo.mcpAvailable) {
+            return { error: 'MCP not available via CLI' };
+        }
+        return this.executeCLICommand('mcp status');
+    }
+    async listMCPTools() {
+        const cliInfo = await this.detectCLI();
+        if (!cliInfo.mcpAvailable) {
+            return { error: 'MCP not available via CLI' };
+        }
+        return this.executeCLICommand('mcp tools');
+    }
+    /**
+     * Authentication operations
+     */
+    async getAuthStatus() {
+        return this.executeCLICommand('auth status');
+    }
+    /**
+     * Check if specific CLI features are available
+     */
+    async getCapabilities() {
+        const cliInfo = await this.detectCLI();
+        return {
+            cliAvailable: cliInfo.available,
+            version: cliInfo.version,
+            mcpSupport: cliInfo.mcpAvailable || false,
+            authenticated: cliInfo.authenticated || false,
+            goldenContract: cliInfo.available && this.isGoldenContractCompliant(cliInfo.version)
+        };
+    }
+    isGoldenContractCompliant(version) {
+        if (!version)
+            return false;
+        const versionMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
+        if (!versionMatch)
+            return false;
+        const [, major, minor, patch] = versionMatch.map(Number);
+        return major > 1 || (major === 1 && minor > 5) || (major === 1 && minor === 5 && patch >= 2);
+    }
+    /**
+     * Force refresh CLI detection
+     */
+    async refresh() {
+        this.cliInfo = null;
+        this.detectionPromise = null;
+        return this.detectCLI();
+    }
+    /**
+     * Get cached CLI info without re-detection
+     */
+    getCachedInfo() {
+        return this.cliInfo;
+    }
+}
+// Singleton instance for convenient access
+const cliIntegration = new CLIIntegration();
+
+/**
+ * Enhanced Memory Client with CLI Integration
+ *
+ * Intelligently routes requests through CLI v1.5.2+ when available,
+ * with fallback to direct API for maximum compatibility and performance
+ *
+ * IMPORTANT: This file uses Node.js-specific features (process.env) and should only be used in Node.js environments
+ */
+/**
+ * Enhanced Memory Client with intelligent CLI/API routing
+ */
+class EnhancedMemoryClient {
+    createDefaultCapabilities() {
+        return {
+            cliAvailable: false,
+            mcpSupport: false,
+            authenticated: false,
+            goldenContract: false
+        };
+    }
+    constructor(config) {
+        this.capabilities = null;
+        this.config = {
+            preferCLI: true,
+            enableMCP: true,
+            cliDetectionTimeout: 5000,
+            fallbackToAPI: true,
+            minCLIVersion: '1.5.2',
+            verbose: false,
+            timeout: 30000,
+            apiKey: config.apiKey || process.env.LANONASIS_API_KEY || '',
+            authToken: config.authToken || '',
+            headers: config.headers || {},
+            ...config
+        };
+        this.directClient = new CoreMemoryClient(config);
+        this.cliIntegration = new CLIIntegration();
+    }
+    /**
+     * Initialize the client and detect capabilities
+     */
+    async initialize() {
+        try {
+            const detectionPromise = this.cliIntegration.getCapabilities();
+            const capabilities = this.config.cliDetectionTimeout > 0
+                ? await Promise.race([
+                    detectionPromise,
+                    new Promise((resolve) => {
+                        setTimeout(() => resolve(null), this.config.cliDetectionTimeout);
+                    })
+                ])
+                : await detectionPromise;
+            if (capabilities) {
+                this.capabilities = capabilities;
+                if (this.config.verbose && capabilities.cliAvailable && !capabilities.authenticated) {
+                    const suggestedCommand = capabilities.goldenContract ? 'onasis login' : 'lanonasis login';
+                    console.warn(`CLI detected but not authenticated. Run '${suggestedCommand}' to enable enhanced SDK features.`);
+                }
+            }
+            else {
+                this.capabilities = this.createDefaultCapabilities();
+                if (this.config.verbose) {
+                    console.warn(`CLI detection timed out after ${this.config.cliDetectionTimeout}ms. Falling back to API mode.`);
+                }
+            }
+        }
+        catch (error) {
+            if (this.config.verbose) {
+                console.warn('CLI detection failed:', error);
+            }
+            this.capabilities = this.createDefaultCapabilities();
+        }
+    }
+    /**
+     * Get current capabilities
+     */
+    async getCapabilities() {
+        if (!this.capabilities) {
+            await this.initialize();
+        }
+        if (!this.capabilities) {
+            this.capabilities = this.createDefaultCapabilities();
+        }
+        return this.capabilities;
+    }
+    /**
+     * Determine if operation should use CLI
+     */
+    async shouldUseCLI() {
+        const capabilities = await this.getCapabilities();
+        return (this.config.preferCLI &&
+            capabilities.cliAvailable &&
+            capabilities.authenticated &&
+            capabilities.goldenContract);
+    }
+    /**
+     * Execute operation with intelligent routing
+     */
+    async executeOperation(operation, cliOperation, apiOperation) {
+        const useCLI = await this.shouldUseCLI();
+        const capabilities = await this.getCapabilities();
+        if (useCLI) {
+            try {
+                const result = await cliOperation();
+                if (result.error && this.config.fallbackToAPI) {
+                    console.warn(`CLI ${operation} failed, falling back to API:`, result.error);
+                    const apiResult = await apiOperation();
+                    return {
+                        ...apiResult,
+                        source: 'api',
+                        mcpUsed: false
+                    };
+                }
+                return {
+                    ...result,
+                    source: 'cli',
+                    mcpUsed: capabilities.mcpSupport
+                };
+            }
+            catch (error) {
+                if (this.config.fallbackToAPI) {
+                    console.warn(`CLI ${operation} error, falling back to API:`, error);
+                    const apiResult = await apiOperation();
+                    return {
+                        ...apiResult,
+                        source: 'api',
+                        mcpUsed: false
+                    };
+                }
+                return {
+                    error: error instanceof Error ? error.message : `CLI ${operation} failed`,
+                    source: 'cli',
+                    mcpUsed: false
+                };
+            }
+        }
+        else {
+            const result = await apiOperation();
+            return {
+                ...result,
+                source: 'api',
+                mcpUsed: false
+            };
+        }
+    }
+    // Enhanced API Methods
+    /**
+     * Health check with intelligent routing
+     */
+    async healthCheck() {
+        return this.executeOperation('health check', () => this.cliIntegration.healthCheckViaCLI(), () => this.directClient.healthCheck());
+    }
+    /**
+     * Create memory with CLI/API routing
+     */
+    async createMemory(memory) {
+        return this.executeOperation('create memory', () => this.cliIntegration.createMemoryViaCLI(memory.title, memory.content, {
+            memoryType: memory.memory_type,
+            tags: memory.tags,
+            topicId: memory.topic_id
+        }), () => this.directClient.createMemory(memory));
+    }
+    /**
+     * List memories with intelligent routing
+     */
+    async listMemories(options = {}) {
+        return this.executeOperation('list memories', () => this.cliIntegration.listMemoriesViaCLI({
+            limit: options.limit,
+            memoryType: options.memory_type,
+            tags: options.tags,
+            sortBy: options.sort
+        }), () => this.directClient.listMemories(options));
+    }
+    /**
+     * Search memories with MCP enhancement when available
+     */
+    async searchMemories(request) {
+        return this.executeOperation('search memories', () => this.cliIntegration.searchMemoriesViaCLI(request.query, {
+            limit: request.limit,
+            memoryTypes: request.memory_types
+        }), () => this.directClient.searchMemories(request));
+    }
+    /**
+     * Get memory by ID (API only for now)
+     */
+    async getMemory(id) {
+        // CLI doesn't have get by ID yet, use API
+        const result = await this.directClient.getMemory(id);
+        return {
+            ...result,
+            source: 'api',
+            mcpUsed: false
+        };
+    }
+    /**
+     * Update memory (API only for now)
+     */
+    async updateMemory(id, updates) {
+        // CLI doesn't have update yet, use API
+        const result = await this.directClient.updateMemory(id, updates);
+        return {
+            ...result,
+            source: 'api',
+            mcpUsed: false
+        };
+    }
+    /**
+     * Delete memory (API only for now)
+     */
+    async deleteMemory(id) {
+        // CLI doesn't have delete yet, use API
+        const result = await this.directClient.deleteMemory(id);
+        return {
+            ...result,
+            source: 'api',
+            mcpUsed: false
+        };
+    }
+    // Topic Operations (API only for now)
+    async createTopic(topic) {
+        const result = await this.directClient.createTopic(topic);
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    async getTopics() {
+        const result = await this.directClient.getTopics();
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    async getTopic(id) {
+        const result = await this.directClient.getTopic(id);
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    async updateTopic(id, updates) {
+        const result = await this.directClient.updateTopic(id, updates);
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    async deleteTopic(id) {
+        const result = await this.directClient.deleteTopic(id);
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    /**
+     * Get memory statistics
+     */
+    async getMemoryStats() {
+        const result = await this.directClient.getMemoryStats();
+        return { ...result, source: 'api', mcpUsed: false };
+    }
+    // Utility Methods
+    /**
+     * Force CLI re-detection
+     */
+    async refreshCLIDetection() {
+        this.capabilities = null;
+        await this.cliIntegration.refresh();
+        await this.initialize();
+    }
+    /**
+     * Get authentication status from CLI
+     */
+    async getAuthStatus() {
+        try {
+            const result = await this.cliIntegration.getAuthStatus();
+            return { ...result, source: 'cli', mcpUsed: false };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Auth status check failed',
+                source: 'cli',
+                mcpUsed: false
+            };
+        }
+    }
+    /**
+     * Get MCP status when available
+     */
+    async getMCPStatus() {
+        const capabilities = await this.getCapabilities();
+        if (!capabilities.mcpSupport) {
+            return {
+                error: 'MCP not available',
+                source: 'cli',
+                mcpUsed: false
+            };
+        }
+        try {
+            const result = await this.cliIntegration.getMCPStatus();
+            return { ...result, source: 'cli', mcpUsed: true };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'MCP status check failed',
+                source: 'cli',
+                mcpUsed: false
+            };
+        }
+    }
+    /**
+     * Update authentication for both CLI and API client
+     */
+    setAuthToken(token) {
+        this.directClient.setAuthToken(token);
+    }
+    setApiKey(apiKey) {
+        this.directClient.setApiKey(apiKey);
+    }
+    clearAuth() {
+        this.directClient.clearAuth();
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        this.directClient.updateConfig(updates);
+    }
+    /**
+     * Get configuration summary
+     */
+    getConfigSummary() {
+        return {
+            apiUrl: this.config.apiUrl,
+            preferCLI: this.config.preferCLI,
+            enableMCP: this.config.enableMCP,
+            capabilities: this.capabilities || undefined
+        };
+    }
+}
+/**
+ * Factory function to create an enhanced memory client
+ */
+async function createNodeMemoryClient(config) {
+    const client = new EnhancedMemoryClient(config);
+    await client.initialize();
+    return client;
+}
+/**
+ * Synchronous factory function (initialization happens on first API call)
+ */
+function createEnhancedMemoryClient(config) {
+    return new EnhancedMemoryClient(config);
+}
+
+export { CLIIntegration, EnhancedMemoryClient, cliIntegration, createEnhancedMemoryClient, createNodeMemoryClient };
+//# sourceMappingURL=index.js.map