@lanonasis/cli 1.4.1 → 1.5.0

package/dist/utils/api.d.ts

@@ -57,7 +57,7 @@ export interface GetMemoriesParams {
     limit?: number;
     offset?: number;
     memory_type?: MemoryType;
-    tags?: string[] | string;
+    tags?: string[];
     topic_id?: string;
     sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
     sort_order?: 'asc' | 'desc';
@@ -125,19 +125,13 @@ export interface HealthStatus {
     }>;
 }
 export interface PaginatedResponse<T> {
-    data?: T[];
-    memories?: T[];
-    results?: T[];
+    data: T[];
     pagination: {
         total: number;
         limit: number;
         offset: number;
         has_more: boolean;
-        page?: number;
-        pages?: number;
     };
-    total_results?: number;
-    search_time_ms?: number;
 }
 export interface ApiErrorResponse {
     error: string;
@@ -165,10 +159,6 @@ export declare class APIClient {
     updateTopic(id: string, data: UpdateTopicRequest): Promise<MemoryTopic>;
     deleteTopic(id: string): Promise<void>;
     getHealth(): Promise<HealthStatus>;
-    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
     request<T = Record<string, unknown>>(config: AxiosRequestConfig): Promise<T>;
 }
 export declare const apiClient: APIClient;

package/dist/utils/api.js

@@ -132,23 +132,6 @@ export class APIClient {
         const response = await this.client.get('/api/v1/health');
         return response.data;
     }
-    // Generic HTTP methods
-    async get(url, config) {
-        const response = await this.client.get(url, config);
-        return response.data;
-    }
-    async post(url, data, config) {
-        const response = await this.client.post(url, data, config);
-        return response.data;
-    }
-    async put(url, data, config) {
-        const response = await this.client.put(url, data, config);
-        return response.data;
-    }
-    async delete(url, config) {
-        const response = await this.client.delete(url, config);
-        return response.data;
-    }
     // Generic request method
     async request(config) {
         const response = await this.client.request(config);

package/dist/utils/completions.d.ts

@@ -0,0 +1,28 @@
+export interface CompletionData {
+    commands: string[];
+    memory: {
+        types: string[];
+        tags: string[];
+        recentIds: string[];
+    };
+    topics: string[];
+    organizations: string[];
+}
+export declare class TabCompletions {
+    private config;
+    private completionData;
+    constructor();
+    init(): Promise<void>;
+    private loadDynamicCompletions;
+    private loadRecentMemories;
+    private loadTopics;
+    private loadTags;
+    getCompletions(line: string, position: number): string[];
+    private getMemoryCompletions;
+    private getCreateCompletions;
+    private getSearchCompletions;
+    private getListCompletions;
+    private getTopicCompletions;
+    generateBashCompletion(): string;
+    generateZshCompletion(): string;
+}

package/dist/utils/completions.js

@@ -0,0 +1,276 @@
+import chalk from 'chalk';
+import { CLIConfig } from './config.js';
+export class TabCompletions {
+    config;
+    completionData;
+    constructor() {
+        this.config = new CLIConfig();
+        this.completionData = {
+            commands: [
+                'auth', 'login', 'logout', 'status',
+                'memory', 'mem', 'create', 'search', 'list', 'get', 'update', 'delete',
+                'topic', 'topics', 'org', 'organization',
+                'config', 'mcp', 'init', 'docs', 'help'
+            ],
+            memory: {
+                types: ['context', 'project', 'knowledge', 'reference', 'personal', 'workflow'],
+                tags: [],
+                recentIds: []
+            },
+            topics: [],
+            organizations: []
+        };
+    }
+    async init() {
+        await this.config.init();
+        await this.loadDynamicCompletions();
+    }
+    async loadDynamicCompletions() {
+        const isAuth = await this.config.isAuthenticated();
+        if (!isAuth)
+            return;
+        try {
+            // Load recent memory IDs, tags, topics from API
+            // This would be enhanced with actual API calls
+            await this.loadRecentMemories();
+            await this.loadTopics();
+            await this.loadTags();
+        }
+        catch (error) {
+            // Fail silently for completions
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.error(chalk.gray('Failed to load completions data'));
+            }
+        }
+    }
+    async loadRecentMemories() {
+        // This would call the API to get recent memory IDs
+        // For now, we'll use mock data
+        this.completionData.memory.recentIds = [
+            'mem_12345', 'mem_67890', 'mem_abcdef'
+        ];
+    }
+    async loadTopics() {
+        // This would call the API to get user's topics
+        this.completionData.topics = [
+            'work', 'personal', 'learning', 'projects'
+        ];
+    }
+    async loadTags() {
+        // This would call the API to get commonly used tags
+        this.completionData.memory.tags = [
+            'important', 'todo', 'reference', 'meeting', 'idea'
+        ];
+    }
+    getCompletions(line, position) {
+        const words = line.trim().split(/\s+/);
+        const currentWord = words[words.length - 1] || '';
+        // If we're at the beginning or after a space, suggest commands
+        if (words.length <= 1 || line.endsWith(' ')) {
+            return this.completionData.commands.filter(cmd => cmd.startsWith(currentWord.toLowerCase()));
+        }
+        const command = words[0];
+        const subcommand = words[1];
+        // Context-aware completions
+        switch (command) {
+            case 'memory':
+            case 'mem':
+                return this.getMemoryCompletions(words, currentWord);
+            case 'topic':
+            case 'topics':
+                return this.getTopicCompletions(words, currentWord);
+            case 'auth':
+                return ['login', 'logout', 'status'].filter(cmd => cmd.startsWith(currentWord));
+            case 'config':
+                return ['show', 'set', 'get', 'reset'].filter(cmd => cmd.startsWith(currentWord));
+            default:
+                return [];
+        }
+    }
+    getMemoryCompletions(words, currentWord) {
+        if (words.length === 2) {
+            // Memory subcommands
+            return ['create', 'search', 'list', 'get', 'update', 'delete', 'stats']
+                .filter(cmd => cmd.startsWith(currentWord));
+        }
+        const subcommand = words[1];
+        switch (subcommand) {
+            case 'create':
+                return this.getCreateCompletions(words, currentWord);
+            case 'search':
+                return this.getSearchCompletions(words, currentWord);
+            case 'list':
+                return this.getListCompletions(words, currentWord);
+            case 'get':
+            case 'update':
+            case 'delete':
+                return this.completionData.memory.recentIds.filter(id => id.startsWith(currentWord));
+            default:
+                return [];
+        }
+    }
+    getCreateCompletions(words, currentWord) {
+        // Look for flags
+        const prevWord = words[words.length - 2];
+        if (prevWord === '--type' || prevWord === '-t') {
+            return this.completionData.memory.types.filter(type => type.startsWith(currentWord));
+        }
+        if (prevWord === '--tags') {
+            return this.completionData.memory.tags.filter(tag => tag.startsWith(currentWord));
+        }
+        // Suggest flags
+        if (currentWord.startsWith('-')) {
+            return ['--title', '--content', '--type', '--tags', '--topic']
+                .filter(flag => flag.startsWith(currentWord));
+        }
+        return [];
+    }
+    getSearchCompletions(words, currentWord) {
+        const prevWord = words[words.length - 2];
+        if (prevWord === '--type') {
+            return this.completionData.memory.types.filter(type => type.startsWith(currentWord));
+        }
+        if (prevWord === '--topic') {
+            return this.completionData.topics.filter(topic => topic.startsWith(currentWord));
+        }
+        if (currentWord.startsWith('-')) {
+            return ['--limit', '--type', '--topic', '--tags']
+                .filter(flag => flag.startsWith(currentWord));
+        }
+        return [];
+    }
+    getListCompletions(words, currentWord) {
+        const prevWord = words[words.length - 2];
+        if (prevWord === '--type') {
+            return this.completionData.memory.types.filter(type => type.startsWith(currentWord));
+        }
+        if (currentWord.startsWith('-')) {
+            return ['--limit', '--type', '--topic', '--tags']
+                .filter(flag => flag.startsWith(currentWord));
+        }
+        return [];
+    }
+    getTopicCompletions(words, currentWord) {
+        if (words.length === 2) {
+            return ['list', 'create', 'get', 'update', 'delete']
+                .filter(cmd => cmd.startsWith(currentWord));
+        }
+        const subcommand = words[1];
+        if (['get', 'update', 'delete'].includes(subcommand)) {
+            return this.completionData.topics.filter(topic => topic.startsWith(currentWord));
+        }
+        return [];
+    }
+    // Generate shell completion scripts
+    generateBashCompletion() {
+        return `
+_lanonasis_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Basic command completion
+    if [[ \${COMP_CWORD} == 1 ]] ; then
+        opts="auth login logout status memory mem topic topics config mcp init docs help"
+        COMPREPLY=( \$(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+    
+    # Memory subcommands
+    if [[ \${COMP_WORDS[1]} == "memory" || \${COMP_WORDS[1]} == "mem" ]] ; then
+        if [[ \${COMP_CWORD} == 2 ]] ; then
+            opts="create search list get update delete stats"
+            COMPREPLY=( \$(compgen -W "\${opts}" -- \${cur}) )
+            return 0
+        fi
+    fi
+    
+    # Topic subcommands
+    if [[ \${COMP_WORDS[1]} == "topic" || \${COMP_WORDS[1]} == "topics" ]] ; then
+        if [[ \${COMP_CWORD} == 2 ]] ; then
+            opts="list create get update delete"
+            COMPREPLY=( \$(compgen -W "\${opts}" -- \${cur}) )
+            return 0
+        fi
+    fi
+}
+
+complete -F _lanonasis_completion lanonasis onasis memory maas
+`;
+    }
+    generateZshCompletion() {
+        return `
+#compdef lanonasis onasis memory maas
+
+_lanonasis() {
+    local context state line
+    typeset -A opt_args
+
+    _arguments -C \\
+        '1: :_lanonasis_commands' \\
+        '*::arg:->args'
+
+    case $state in
+        args)
+            case $words[1] in
+                memory|mem)
+                    _lanonasis_memory
+                    ;;
+                topic|topics)
+                    _lanonasis_topic
+                    ;;
+                auth)
+                    _arguments \\
+                        '1:(login logout status)'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_lanonasis_commands() {
+    local commands
+    commands=(
+        'auth:Authentication commands'
+        'memory:Memory management'
+        'topic:Topic management'
+        'config:Configuration'
+        'mcp:MCP server management'
+        'init:Initialize CLI'
+        'docs:Open documentation'
+        'help:Show help'
+    )
+    _describe 'commands' commands
+}
+
+_lanonasis_memory() {
+    local subcommands
+    subcommands=(
+        'create:Create new memory'
+        'search:Search memories'
+        'list:List memories'
+        'get:Get specific memory'
+        'update:Update memory'
+        'delete:Delete memory'
+        'stats:Memory statistics'
+    )
+    _describe 'memory commands' subcommands
+}
+
+_lanonasis_topic() {
+    local subcommands
+    subcommands=(
+        'list:List topics'
+        'create:Create topic'
+        'get:Get topic'
+        'update:Update topic'
+        'delete:Delete topic'
+    )
+    _describe 'topic commands' subcommands
+}
+
+_lanonasis
+`;
+    }
+}

package/dist/utils/config.d.ts

@@ -16,6 +16,8 @@ export declare class CLIConfig {
     setApiUrl(url: string): Promise<void>;
     setToken(token: string): Promise<void>;
     getToken(): string | undefined;
+    setApiKey(apiKey: string): Promise<void>;
+    getApiKey(): string | undefined;
     getCurrentUser(): Promise<UserProfile | undefined>;
     isAuthenticated(): Promise<boolean>;
     logout(): Promise<void>;

package/dist/utils/config.js

@@ -67,10 +67,22 @@ export class CLIConfig {
     getToken() {
         return this.config.token;
     }
+    async setApiKey(apiKey) {
+        this.config.apiKey = apiKey;
+        await this.save();
+    }
+    getApiKey() {
+        return this.config.apiKey || process.env.LANONASIS_API_KEY;
+    }
     async getCurrentUser() {
         return this.config.user;
     }
     async isAuthenticated() {
+        // Check for API key first
+        const apiKey = this.getApiKey();
+        if (apiKey)
+            return true;
+        // Then check for valid JWT token
         const token = this.getToken();
         if (!token)
             return false;
@@ -85,6 +97,7 @@ export class CLIConfig {
     }
     async logout() {
         this.config.token = undefined;
+        this.config.apiKey = undefined;
         this.config.user = undefined;
         await this.save();
     }

package/dist/utils/formatting.d.ts

@@ -2,5 +2,3 @@ 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;
-export declare function formatDate(date: string | Date): string;
-export declare function formatTableData(data: unknown[]): string[][];

package/dist/utils/formatting.js

@@ -32,16 +32,3 @@ export function formatDuration(ms) {
         return `${(ms / 1000).toFixed(1)}s`;
     return `${(ms / 60000).toFixed(1)}m`;
 }
-export function formatDate(date) {
-    const d = new Date(date);
-    return d.toLocaleString();
-}
-export function formatTableData(data) {
-    return data.map(item => {
-        if (Array.isArray(item))
-            return item.map(String);
-        if (typeof item === 'object' && item !== null)
-            return Object.values(item).map(String);
-        return [String(item)];
-    });
-}

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

@@ -2,70 +2,27 @@ interface MCPConnectionOptions {
     serverPath?: string;
     serverUrl?: string;
     useRemote?: boolean;
-    useWebSocket?: boolean;
-    connectionMode?: 'local' | 'remote' | 'websocket';
-}
-/**
- * Interface for MCP tool arguments
- */
-interface MCPToolArgs {
-    [key: string]: unknown;
-}
-/**
- * Interface for MCP tool response
- */
-export interface MCPToolResponse {
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-    };
-    id?: string;
-    title?: string;
-    memory_type?: string;
-    length?: number;
-    forEach?: (callback: (item: any, index: number) => void) => void;
-    code?: number;
-    message?: string;
-    response?: any;
-}
-/**
- * Interface for MCP WebSocket messages
- */
-export interface MCPWebSocketMessage {
-    id: number;
-    method?: string;
-    params?: Record<string, unknown>;
-    result?: Record<string, unknown>;
-    error?: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
+    mode?: 'local' | 'remote' | 'websocket';
 }
 export declare class MCPClient {
     private client;
     private config;
     private isConnected;
     private sseConnection;
-    private wsConnection;
+    private wsClient;
     constructor();
     /**
      * Connect to MCP server (local or remote)
      */
     connect(options?: MCPConnectionOptions): Promise<boolean>;
     /**
-     * Initialize SSE connection for real-time updates
-     */
-    private initializeSSE;
-    /**
-     * Initialize WebSocket connection for enterprise MCP server
+     * Initialize WebSocket MCP connection for enterprise users
      */
     private initializeWebSocket;
     /**
-     * Send a message over the WebSocket connection
+     * Initialize SSE connection for real-time updates
      */
-    private sendWebSocketMessage;
+    private initializeSSE;
     /**
      * Disconnect from MCP server
      */
@@ -73,7 +30,7 @@ export declare class MCPClient {
     /**
      * Call an MCP tool
      */
-    callTool(toolName: string, args: MCPToolArgs): Promise<MCPToolResponse>;
+    callTool(toolName: string, args: any): Promise<any>;
     /**
      * Call remote tool via REST API with MCP interface
      */