@lanonasis/cli 3.0.1 → 3.0.2

package/dist/mcp/memory-state.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Memory State Management System
+ * Implements comprehensive memory lifecycle management inspired by mem0's state system
+ */
+export declare enum MemoryState {
+    ACTIVE = "active",
+    PAUSED = "paused",
+    ARCHIVED = "archived",
+    DELETED = "deleted"
+}
+export interface MemoryStateTransition {
+    id: string;
+    memory_id: string;
+    from_state: MemoryState;
+    to_state: MemoryState;
+    reason?: string;
+    metadata?: Record<string, any>;
+    timestamp: string;
+    user_id: string;
+}
+export interface LanonasisMemory {
+    id: string;
+    user_id: string;
+    app_id: string;
+    title: string;
+    content: string;
+    state: MemoryState;
+    metadata: Record<string, any>;
+    categories: string[];
+    created_at: string;
+    updated_at: string;
+    archived_at?: string;
+    deleted_at?: string;
+}
+export interface BulkOperationResult {
+    memory_id: string;
+    success: boolean;
+    previous_state: MemoryState;
+    new_state: MemoryState;
+    error?: string;
+}
+export declare class MemoryStateManager {
+    private config;
+    private stateTransitions;
+    constructor();
+    initialize(): Promise<void>;
+    /**
+     * Update memory state with validation and history tracking
+     */
+    updateMemoryState(memoryId: string, newState: MemoryState, reason?: string, metadata?: Record<string, any>): Promise<MemoryStateTransition>;
+    /**
+     * Bulk state update operations
+     */
+    bulkUpdateState(memoryIds: string[], operation: 'pause' | 'delete' | 'archive'): Promise<BulkOperationResult[]>;
+    /**
+     * Get memory state history
+     */
+    getMemoryStateHistory(memoryId: string): MemoryStateTransition[];
+    /**
+     * Get memories by state
+     */
+    getMemoriesByState(state: MemoryState, userId?: string, appId?: string, limit?: number): Promise<LanonasisMemory[]>;
+    /**
+     * Archive old memories based on policy
+     */
+    archiveOldMemories(beforeDate: string, userId?: string, appId?: string): Promise<BulkOperationResult[]>;
+    /**
+     * Restore memories from archived/paused state
+     */
+    restoreMemories(memoryIds: string[]): Promise<BulkOperationResult[]>;
+    /**
+     * Private helper methods
+     */
+    private isValidTransition;
+    private operationToState;
+    private getMemory;
+    private updateMemoryViaAPI;
+    private callMemoryAPI;
+    private getCurrentUserId;
+    private generateTransitionId;
+}

package/dist/mcp/memory-state.js

@@ -0,0 +1,301 @@
+/**
+ * Memory State Management System
+ * Implements comprehensive memory lifecycle management inspired by mem0's state system
+ */
+import { CLIConfig } from '../utils/config.js';
+import { logger } from './logger.js';
+export var MemoryState;
+(function (MemoryState) {
+    MemoryState["ACTIVE"] = "active";
+    MemoryState["PAUSED"] = "paused";
+    MemoryState["ARCHIVED"] = "archived";
+    MemoryState["DELETED"] = "deleted";
+})(MemoryState || (MemoryState = {}));
+export class MemoryStateManager {
+    config;
+    stateTransitions = [];
+    constructor() {
+        this.config = new CLIConfig();
+    }
+    async initialize() {
+        logger.info('Memory State Manager initialized');
+    }
+    /**
+     * Update memory state with validation and history tracking
+     */
+    async updateMemoryState(memoryId, newState, reason, metadata) {
+        try {
+            // Get current memory state
+            const memory = await this.getMemory(memoryId);
+            if (!memory) {
+                throw new Error(`Memory ${memoryId} not found`);
+            }
+            const currentState = memory.state;
+            // Validate state transition
+            if (!this.isValidTransition(currentState, newState)) {
+                throw new Error(`Invalid state transition from ${currentState} to ${newState}`);
+            }
+            // Create state transition record
+            const transition = {
+                id: this.generateTransitionId(),
+                memory_id: memoryId,
+                from_state: currentState,
+                to_state: newState,
+                reason,
+                metadata,
+                timestamp: new Date().toISOString(),
+                user_id: await this.getCurrentUserId()
+            };
+            // Update memory state via API
+            await this.updateMemoryViaAPI(memoryId, {
+                state: newState,
+                updated_at: transition.timestamp,
+                archived_at: newState === MemoryState.ARCHIVED
+                    ? transition.timestamp
+                    : null,
+                deleted_at: newState === MemoryState.DELETED
+                    ? transition.timestamp
+                    : null
+            });
+            // Record transition
+            this.stateTransitions.push(transition);
+            logger.info('Memory state updated', {
+                memoryId,
+                fromState: currentState,
+                toState: newState,
+                reason
+            });
+            return transition;
+        }
+        catch (error) {
+            logger.error('Failed to update memory state', { error, memoryId, newState });
+            throw error;
+        }
+    }
+    /**
+     * Bulk state update operations
+     */
+    async bulkUpdateState(memoryIds, operation) {
+        const results = [];
+        const targetState = this.operationToState(operation);
+        for (const memoryId of memoryIds) {
+            try {
+                const memory = await this.getMemory(memoryId);
+                if (!memory) {
+                    results.push({
+                        memory_id: memoryId,
+                        success: false,
+                        previous_state: MemoryState.ACTIVE,
+                        new_state: targetState,
+                        error: 'Memory not found'
+                    });
+                    continue;
+                }
+                const previousState = memory.state;
+                // Skip if already in target state
+                if (previousState === targetState) {
+                    results.push({
+                        memory_id: memoryId,
+                        success: true,
+                        previous_state: previousState,
+                        new_state: targetState
+                    });
+                    continue;
+                }
+                // Perform state transition
+                await this.updateMemoryState(memoryId, targetState, `Bulk ${operation} operation`);
+                results.push({
+                    memory_id: memoryId,
+                    success: true,
+                    previous_state: previousState,
+                    new_state: targetState
+                });
+            }
+            catch (error) {
+                results.push({
+                    memory_id: memoryId,
+                    success: false,
+                    previous_state: MemoryState.ACTIVE,
+                    new_state: targetState,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        }
+        logger.info('Bulk state update completed', {
+            operation,
+            totalMemories: memoryIds.length,
+            successful: results.filter(r => r.success).length,
+            failed: results.filter(r => !r.success).length
+        });
+        return results;
+    }
+    /**
+     * Get memory state history
+     */
+    getMemoryStateHistory(memoryId) {
+        return this.stateTransitions
+            .filter(t => t.memory_id === memoryId)
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    }
+    /**
+     * Get memories by state
+     */
+    async getMemoriesByState(state, userId, appId, limit = 100) {
+        try {
+            const params = new URLSearchParams({
+                state,
+                limit: limit.toString(),
+                ...(userId && { user_id: userId }),
+                ...(appId && { app_id: appId })
+            });
+            const memories = await this.callMemoryAPI('GET', `/memory?${params}`);
+            return memories.memories || [];
+        }
+        catch (error) {
+            logger.error('Failed to get memories by state', { error, state, userId, appId });
+            return [];
+        }
+    }
+    /**
+     * Archive old memories based on policy
+     */
+    async archiveOldMemories(beforeDate, userId, appId) {
+        try {
+            // Get memories created before the specified date
+            const params = new URLSearchParams({
+                before: beforeDate,
+                state: MemoryState.ACTIVE,
+                ...(userId && { user_id: userId }),
+                ...(appId && { app_id: appId })
+            });
+            const memories = await this.callMemoryAPI('GET', `/memory?${params}`);
+            const memoryIds = memories.memories?.map((m) => m.id) || [];
+            if (memoryIds.length === 0) {
+                return [];
+            }
+            return await this.bulkUpdateState(memoryIds, 'archive');
+        }
+        catch (error) {
+            logger.error('Failed to archive old memories', { error, beforeDate, userId, appId });
+            return [];
+        }
+    }
+    /**
+     * Restore memories from archived/paused state
+     */
+    async restoreMemories(memoryIds) {
+        const results = [];
+        for (const memoryId of memoryIds) {
+            try {
+                const memory = await this.getMemory(memoryId);
+                if (!memory) {
+                    results.push({
+                        memory_id: memoryId,
+                        success: false,
+                        previous_state: MemoryState.ARCHIVED,
+                        new_state: MemoryState.ACTIVE,
+                        error: 'Memory not found'
+                    });
+                    continue;
+                }
+                const previousState = memory.state;
+                // Only restore from paused or archived states
+                if (previousState !== MemoryState.PAUSED && previousState !== MemoryState.ARCHIVED) {
+                    results.push({
+                        memory_id: memoryId,
+                        success: false,
+                        previous_state: previousState,
+                        new_state: MemoryState.ACTIVE,
+                        error: `Cannot restore from ${previousState} state`
+                    });
+                    continue;
+                }
+                await this.updateMemoryState(memoryId, MemoryState.ACTIVE, 'Memory restoration');
+                results.push({
+                    memory_id: memoryId,
+                    success: true,
+                    previous_state: previousState,
+                    new_state: MemoryState.ACTIVE
+                });
+            }
+            catch (error) {
+                results.push({
+                    memory_id: memoryId,
+                    success: false,
+                    previous_state: MemoryState.ARCHIVED,
+                    new_state: MemoryState.ACTIVE,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Private helper methods
+     */
+    isValidTransition(fromState, toState) {
+        const validTransitions = {
+            [MemoryState.ACTIVE]: [MemoryState.PAUSED, MemoryState.ARCHIVED, MemoryState.DELETED],
+            [MemoryState.PAUSED]: [MemoryState.ACTIVE, MemoryState.ARCHIVED, MemoryState.DELETED],
+            [MemoryState.ARCHIVED]: [MemoryState.ACTIVE, MemoryState.DELETED],
+            [MemoryState.DELETED]: [] // No transitions from deleted state
+        };
+        return validTransitions[fromState]?.includes(toState) || false;
+    }
+    operationToState(operation) {
+        switch (operation) {
+            case 'pause':
+                return MemoryState.PAUSED;
+            case 'archive':
+                return MemoryState.ARCHIVED;
+            case 'delete':
+                return MemoryState.DELETED;
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
+    }
+    async getMemory(memoryId) {
+        try {
+            const response = await this.callMemoryAPI('GET', `/memory/${memoryId}`);
+            return response;
+        }
+        catch (error) {
+            logger.error('Failed to get memory', { error, memoryId });
+            return null;
+        }
+    }
+    async updateMemoryViaAPI(memoryId, updates) {
+        await this.callMemoryAPI('PUT', `/memory/${memoryId}`, updates);
+    }
+    async callMemoryAPI(method, endpoint, data) {
+        const apiUrl = this.config.get('apiUrl') || 'https://api.lanonasis.com';
+        const token = this.config.get('token');
+        const axios = (await import('axios')).default;
+        const response = await axios({
+            method,
+            url: `${apiUrl}/api/v1${endpoint}`,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            data
+        });
+        return response.data;
+    }
+    async getCurrentUserId() {
+        const token = this.config.get('token');
+        if (token && typeof token === 'string') {
+            try {
+                const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+                return payload.sub || payload.user_id || 'anonymous';
+            }
+            catch {
+                return 'anonymous';
+            }
+        }
+        return 'anonymous';
+    }
+    generateTransitionId() {
+        return `transition_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    }
+}

package/dist/mcp/schemas/tool-schemas.d.ts

@@ -175,11 +175,11 @@ export declare const ApiKeyRevokeSchema: z.ZodObject<{
     key_id: z.ZodString;
     reason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    key_id?: string;
     reason?: string;
-}, {
     key_id?: string;
+}, {
     reason?: string;
+    key_id?: string;
 }>;
 export declare const SystemHealthSchema: z.ZodObject<{
     verbose: z.ZodDefault<z.ZodBoolean>;
@@ -217,13 +217,13 @@ export declare const BulkOperationSchema: z.ZodObject<{
     transaction: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     operation?: "create" | "delete" | "update";
-    entity_type?: "topic" | "memory" | "apikey";
     items?: Record<string, any>[];
+    entity_type?: "topic" | "memory" | "apikey";
     transaction?: boolean;
 }, {
     operation?: "create" | "delete" | "update";
-    entity_type?: "topic" | "memory" | "apikey";
     items?: Record<string, any>[];
+    entity_type?: "topic" | "memory" | "apikey";
     transaction?: boolean;
 }>;
 export declare const ImportExportSchema: z.ZodObject<{
@@ -551,11 +551,11 @@ export declare const MCPSchemas: {
             key_id: z.ZodString;
             reason: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            key_id?: string;
             reason?: string;
-        }, {
             key_id?: string;
+        }, {
             reason?: string;
+            key_id?: string;
         }>;
     };
     system: {
@@ -597,13 +597,13 @@ export declare const MCPSchemas: {
             transaction: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             operation?: "create" | "delete" | "update";
-            entity_type?: "topic" | "memory" | "apikey";
             items?: Record<string, any>[];
+            entity_type?: "topic" | "memory" | "apikey";
             transaction?: boolean;
         }, {
             operation?: "create" | "delete" | "update";
-            entity_type?: "topic" | "memory" | "apikey";
             items?: Record<string, any>[];
+            entity_type?: "topic" | "memory" | "apikey";
             transaction?: boolean;
         }>;
         importExport: z.ZodObject<{

package/dist/mcp/vector-store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vector Store Integration
+ * Supports multiple vector stores with configurable embedding models
+ */
+export interface VectorStoreConfig {
+    provider: 'local' | 'qdrant' | 'chroma';
+    url?: string;
+    apiKey?: string;
+    collection?: string;
+    dimensions?: number;
+}
+export interface SearchResult {
+    id: string;
+    score: number;
+    metadata: any;
+}
+export declare class LanonasisVectorStore {
+    private config;
+    private storeConfig;
+    private isInitialized;
+    private localEmbeddings;
+    constructor();
+    initialize(): Promise<void>;
+    isConfigured(): boolean;
+    addMemory(memoryId: string, content: string, metadata: any): Promise<void>;
+    searchMemories(query: string, options?: any): Promise<SearchResult[]>;
+    findRelatedMemories(memoryId: string, options?: any): Promise<SearchResult[]>;
+    private generateSimpleEmbedding;
+    private simpleHash;
+    private cosineSimilarity;
+}

package/dist/mcp/vector-store.js

@@ -0,0 +1,92 @@
+/**
+ * Vector Store Integration
+ * Supports multiple vector stores with configurable embedding models
+ */
+import { CLIConfig } from '../utils/config.js';
+import { logger } from './logger.js';
+export class LanonasisVectorStore {
+    config;
+    storeConfig;
+    isInitialized = false;
+    localEmbeddings = new Map();
+    constructor() {
+        this.config = new CLIConfig();
+        this.storeConfig = {
+            provider: 'local',
+            collection: 'lanonasis_memories',
+            dimensions: 384
+        };
+    }
+    async initialize() {
+        this.isInitialized = true;
+        logger.info('Vector store initialized', { provider: this.storeConfig.provider });
+    }
+    isConfigured() {
+        return this.isInitialized;
+    }
+    async addMemory(memoryId, content, metadata) {
+        const embedding = this.generateSimpleEmbedding(content);
+        this.localEmbeddings.set(memoryId, { embedding, metadata, content });
+        logger.debug('Memory added to vector store', { memoryId });
+    }
+    async searchMemories(query, options = {}) {
+        const queryEmbedding = this.generateSimpleEmbedding(query);
+        const results = [];
+        // Only consider memories the caller is allowed to see
+        const allowedIds = options.memoryIds
+            ? new Set(options.memoryIds)
+            : undefined;
+        for (const [id, data] of this.localEmbeddings) {
+            if (allowedIds && !allowedIds.has(id))
+                continue;
+            const similarity = this.cosineSimilarity(queryEmbedding, data.embedding);
+            if (similarity >= (options.threshold || 0.7)) {
+                results.push({ id, score: similarity, metadata: data.metadata });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, options.limit || 10);
+    }
+    async findRelatedMemories(memoryId, options = {}) {
+        const memory = this.localEmbeddings.get(memoryId);
+        if (!memory)
+            return [];
+        const results = [];
+        for (const [id, data] of this.localEmbeddings) {
+            if (id === memoryId)
+                continue;
+            const similarity = this.cosineSimilarity(memory.embedding, data.embedding);
+            if (similarity >= (options.threshold || 0.6)) {
+                results.push({ id, score: similarity, metadata: data.metadata });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, options.limit || 5);
+    }
+    generateSimpleEmbedding(text) {
+        const words = text.toLowerCase().split(/\s+/);
+        const embedding = new Array(this.storeConfig.dimensions ?? 384).fill(0);
+        words.forEach((word, index) => {
+            const hash = this.simpleHash(word);
+            const position = Math.abs(hash) % embedding.length;
+            embedding[position] += 1 / (index + 1);
+        });
+        const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+        return embedding.map(val => magnitude > 0 ? val / magnitude : 0);
+    }
+    simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash;
+    }
+    cosineSimilarity(a, b) {
+        const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
+        const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
+        const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
+        return magnitudeA && magnitudeB ? dotProduct / (magnitudeA * magnitudeB) : 0;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "LanOnasis Enterprise CLI - Memory as a Service, API Key Management, and Infrastructure Orchestration",
   "main": "dist/index-simple.js",
   "bin": {