@lanonasis/cli 1.5.0 → 1.5.2

package/dist/utils/completions.js

@@ -1,276 +0,0 @@
-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/mcp-client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/mcp-client.test.js

@@ -1,125 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test';
-import { MCPClient } from './mcp-client';
-describe('MCPClient', () => {
-    let client;
-    beforeEach(() => {
-        client = new MCPClient();
-    });
-    describe('constructor', () => {
-        it('should create client instance', () => {
-            expect(client).toBeDefined();
-            expect(client.isConnected()).toBe(false);
-        });
-    });
-    describe('connection modes', () => {
-        it('should support local connection mode', async () => {
-            const result = await client.connect({ mode: 'local' });
-            // Local mode may fail without actual server, but should not throw
-            expect(typeof result).toBe('boolean');
-        });
-        it('should support remote connection mode', async () => {
-            const result = await client.connect({ mode: 'remote' });
-            // Remote mode may fail without credentials, but should not throw
-            expect(typeof result).toBe('boolean');
-        });
-        it('should support websocket connection mode', async () => {
-            const result = await client.connect({ mode: 'websocket' });
-            // WebSocket mode may fail without server, but should not throw
-            expect(typeof result).toBe('boolean');
-        });
-    });
-    describe('connection options', () => {
-        it('should handle server path option', async () => {
-            const options = {
-                mode: 'local',
-                serverPath: '/custom/path/to/server'
-            };
-            const result = await client.connect(options);
-            expect(typeof result).toBe('boolean');
-        });
-        it('should handle server URL option', async () => {
-            const options = {
-                mode: 'websocket',
-                serverUrl: 'ws://custom.server.com:8081'
-            };
-            const result = await client.connect(options);
-            expect(typeof result).toBe('boolean');
-        });
-    });
-    describe('tool operations', () => {
-        it('should handle list tools request', async () => {
-            // Mock successful connection first
-            client.isConnected = () => true;
-            try {
-                const tools = await client.listTools();
-                expect(Array.isArray(tools)).toBe(true);
-            }
-            catch (error) {
-                // Expected if no actual connection
-                expect(error).toBeDefined();
-            }
-        });
-        it('should handle call tool request', async () => {
-            // Mock successful connection first
-            client.isConnected = () => true;
-            try {
-                const result = await client.callTool('test_tool', { param: 'value' });
-                expect(result).toBeDefined();
-            }
-            catch (error) {
-                // Expected if no actual connection
-                expect(error).toBeDefined();
-            }
-        });
-    });
-    describe('memory operations', () => {
-        it('should handle create memory request', async () => {
-            // Mock successful connection first
-            client.isConnected = () => true;
-            try {
-                const result = await client.createMemory({
-                    title: 'Test Memory',
-                    content: 'Test content',
-                    tags: ['test']
-                });
-                expect(result).toBeDefined();
-            }
-            catch (error) {
-                // Expected if no actual connection
-                expect(error).toBeDefined();
-            }
-        });
-        it('should handle search memories request', async () => {
-            // Mock successful connection first
-            client.isConnected = () => true;
-            try {
-                const result = await client.searchMemories({
-                    query: 'test query',
-                    limit: 10
-                });
-                expect(result).toBeDefined();
-            }
-            catch (error) {
-                // Expected if no actual connection
-                expect(error).toBeDefined();
-            }
-        });
-    });
-    describe('error handling', () => {
-        it('should handle connection failures gracefully', async () => {
-            const result = await client.connect({
-                mode: 'websocket',
-                serverUrl: 'ws://nonexistent.server:9999'
-            });
-            expect(result).toBe(false);
-        });
-        it('should handle invalid connection modes', async () => {
-            try {
-                await client.connect({ mode: 'invalid' });
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-            }
-        });
-    });
-});

package/dist/utils/output.d.ts

@@ -1,23 +0,0 @@
-export interface OutputOptions {
-    format?: string;
-    silent?: boolean;
-    json?: boolean;
-}
-export declare class OutputManager {
-    private static instance;
-    private options;
-    static getInstance(): OutputManager;
-    setOptions(options: OutputOptions): void;
-    isJsonOutput(): boolean;
-    isSilent(): boolean;
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    json(data: any): void;
-    table(data: any[]): void;
-    success(message: string): void;
-    warning(message: string): void;
-    info(message: string): void;
-}
-export declare const output: OutputManager;
-export declare function showOutput(format?: string): boolean;
-export declare function formatOutput(data: any, format?: string): string;

package/dist/utils/output.js

@@ -1,97 +0,0 @@
-import chalk from 'chalk';
-export class OutputManager {
-    static instance;
-    options = {};
-    static getInstance() {
-        if (!OutputManager.instance) {
-            OutputManager.instance = new OutputManager();
-        }
-        return OutputManager.instance;
-    }
-    setOptions(options) {
-        this.options = { ...this.options, ...options };
-    }
-    isJsonOutput() {
-        return this.options.format === 'json' ||
-            this.options.json === true ||
-            process.env.CLI_OUTPUT_FORMAT === 'json';
-    }
-    isSilent() {
-        return this.options.silent === true ||
-            this.isJsonOutput() ||
-            process.env.CLI_SILENT === 'true';
-    }
-    log(...args) {
-        if (!this.isSilent()) {
-            console.log(...args);
-        }
-    }
-    error(...args) {
-        if (this.isJsonOutput()) {
-            console.error(JSON.stringify({
-                error: true,
-                message: args.join(' ').replace(/\x1b\[[0-9;]*m/g, '') // Strip ANSI codes
-            }));
-        }
-        else {
-            console.error(...args);
-        }
-    }
-    json(data) {
-        console.log(JSON.stringify(data, null, 2));
-    }
-    table(data) {
-        if (this.isJsonOutput()) {
-            this.json(data);
-        }
-        else {
-            console.table(data);
-        }
-    }
-    success(message) {
-        if (this.isJsonOutput()) {
-            this.json({ success: true, message });
-        }
-        else {
-            this.log(chalk.green('✓'), message);
-        }
-    }
-    warning(message) {
-        if (this.isJsonOutput()) {
-            this.json({ warning: true, message });
-        }
-        else {
-            this.log(chalk.yellow('⚠️'), message);
-        }
-    }
-    info(message) {
-        if (!this.isSilent()) {
-            if (this.isJsonOutput()) {
-                this.json({ info: true, message });
-            }
-            else {
-                this.log(chalk.blue('ℹ'), message);
-            }
-        }
-    }
-}
-export const output = OutputManager.getInstance();
-// Helper to conditionally show output
-export function showOutput(format) {
-    return format !== 'json' && process.env.CLI_OUTPUT_FORMAT !== 'json';
-}
-// Helper to format output based on format
-export function formatOutput(data, format) {
-    const outputFormat = format || process.env.CLI_OUTPUT_FORMAT || 'table';
-    switch (outputFormat) {
-        case 'json':
-            return JSON.stringify(data, null, 2);
-        case 'yaml':
-            // Simple YAML-like format
-            return Object.entries(data)
-                .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-                .join('\n');
-        default:
-            return data;
-    }
-}

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

@@ -1,60 +0,0 @@
-/**
- * WebSocket MCP Client for Enterprise Connections
- * Connects to mcp.lanonasis.com WebSocket server for real-time MCP operations
- */
-import { EventEmitter } from 'events';
-export interface MCPParams {
-    [key: string]: unknown;
-}
-export interface MCPResult {
-    [key: string]: unknown;
-}
-export interface MCPError {
-    code: number;
-    message: string;
-    data?: unknown;
-}
-export interface MCPMessage {
-    id?: string;
-    type: 'request' | 'response' | 'notification' | 'error';
-    method?: string;
-    params?: MCPParams;
-    result?: MCPResult;
-    error?: MCPError;
-}
-export interface WebSocketMCPClientOptions {
-    url?: string;
-    apiKey: string;
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
-    timeout?: number;
-}
-export declare class WebSocketMCPClient extends EventEmitter {
-    private ws;
-    private url;
-    private apiKey;
-    private reconnectInterval;
-    private maxReconnectAttempts;
-    private timeout;
-    private reconnectAttempts;
-    private isConnected;
-    private messageId;
-    private pendingRequests;
-    constructor(options: WebSocketMCPClientOptions);
-    connect(): Promise<void>;
-    private handleMessage;
-    sendRequest(method: string, params?: MCPParams): Promise<MCPResult>;
-    listTools(): Promise<MCPResult>;
-    callTool(name: string, arguments_?: MCPParams): Promise<MCPResult>;
-    deleteMemory(id: string): Promise<MCPResult>;
-    searchMemories(args: MCPParams): Promise<MCPResult>;
-    listResources(): Promise<MCPResult>;
-    getMemories(query?: string): Promise<MCPResult>;
-    disconnect(): void;
-    getConnectionStatus(): {
-        connected: boolean;
-        url: string;
-        reconnectAttempts: number;
-        pendingRequests: number;
-    };
-}