@lanonasis/cli 1.0.0

package/README.md

@@ -0,0 +1,217 @@
+# Lanonasis CLI - Enterprise Infrastructure Management
+
+🚀 **Professional CLI for Lanonasis Platform Services**
+
+The Lanonasis CLI provides a powerful command-line interface for interacting with the entire Lanonasis ecosystem, including Memory as a Service (MaaS), infrastructure management, and multi-service orchestration. Manage your memories, search through knowledge bases, organize your thoughts, and control your infrastructure - all from the terminal.
+
+## ⚡ Quick Start
+
+```bash
+# Install globally
+npm install -g @lanonasis/cli
+
+# Or use with npx (no installation needed)
+npx -y @lanonasis/cli init
+
+# Initialize Lanonasis services
+lanonasis init
+
+# Configure your services
+lanonasis config set api-url https://your-lanonasis-service.com
+
+# Authenticate
+lanonasis auth login
+
+# Memory operations (also available as 'memory' and 'maas' commands)
+lanonasis memory create -t "My First Memory" -c "This is the content of my memory"
+lanonasis memory search "search query"
+lanonasis memory list
+
+# Infrastructure management (future services)
+lanonasis deploy status
+lanonasis services list
+```
+
+## 🚀 Installation
+
+### Global Installation (Recommended)
+```bash
+npm install -g @lanonasis/cli
+```
+
+### NPX Usage (No Installation)
+```bash
+npx -y @lanonasis/cli --help
+npx -y @lanonasis/cli init
+```
+
+### Local Installation
+```bash
+npm install @lanonasis/cli
+npx lanonasis --help
+```
+
+## 📋 Available Commands
+
+### 🔧 Setup & Configuration
+- `lanonasis init` - Initialize CLI and show setup instructions
+- `lanonasis config set <key> <value>` - Set configuration values
+- `lanonasis config get <key>` - Get configuration value
+- `lanonasis config list` - List all configuration options
+- `lanonasis status` - Show CLI status and configuration
+
+### 🔐 Authentication
+- `lanonasis auth login` - Authenticate with your services
+- `lanonasis auth logout` - Sign out
+- `lanonasis auth status` - Check authentication status
+
+### 📝 Memory Operations
+- `lanonasis create -t "Title" -c "Content" [--type <type>]` - Create new memory
+- `lanonasis search <query> [-l <limit>]` - Search memories
+- `lanonasis list [-l <limit>] [--type <type>]` - List memories
+- `lanonasis help` - Show detailed help
+
+#### Alternative Commands (Backwards Compatibility)
+- `memory <command>` - Direct memory operations
+- `maas <command>` - Memory as a Service operations
+
+## 🧠 Memory Types
+
+The CLI supports the following memory types:
+- **conversation** - Chat and dialogue context
+- **knowledge** - Educational and reference content
+- **project** - Project-specific documentation
+- **context** - General contextual information
+- **reference** - Quick reference materials
+
+## ⚙️ Configuration
+
+Configure your CLI to connect to your Lanonasis services:
+
+```bash
+# Set your service endpoint
+lanonasis config set api-url https://your-lanonasis-service.com
+
+# View current configuration
+lanonasis config list
+```
+
+## 🔒 Authentication
+
+Authenticate with your Lanonasis platform:
+
+```bash
+# Login to your service
+lanonasis auth login
+
+# Check authentication status
+lanonasis auth status
+
+# Logout
+lanonasis auth logout
+```
+
+## 📖 Usage Examples
+
+```bash
+# Create different types of memories
+lanonasis create -t "Meeting Notes" -c "Project kickoff discussion" --type project
+lanonasis create -t "API Reference" -c "POST /api/memories endpoint" --type reference
+lanonasis create -t "Learning Notes" -c "Vector embeddings concepts" --type knowledge
+
+# Using npx (no installation)
+npx -y @lanonasis/cli create -t "Quick Note" -c "NPX usage example"
+
+# Search with different options
+lanonasis search "API endpoints" -l 5
+lanonasis search "project meeting"
+
+# List with filters
+lanonasis list --type project -l 10
+lanonasis list -l 20
+
+# Alternative command usage
+memory search "my query"  # Direct memory command
+maas list --type knowledge  # MaaS command
+```
+
+## 🌐 MaaS Service Integration
+
+This CLI is designed to work with Memory as a Service platforms that provide:
+- RESTful API endpoints
+- JWT or API key authentication
+- Vector-based memory search
+- Multi-tenant memory storage
+
+### Setting up your MaaS Service
+
+1. **Deploy** a MaaS service using the provided backend
+2. **Configure** the CLI with your service endpoint
+3. **Authenticate** using your service credentials
+4. **Start** managing your memories!
+
+## 🛠️ Development
+
+### Prerequisites
+- Node.js 18+
+- npm or yarn
+
+### Local Development
+```bash
+git clone <repository-url>
+cd memory-cli
+npm install
+
+# Development mode
+npm run dev
+
+# Build
+npm run build
+
+# Test locally
+node dist/index-simple.js help
+```
+
+## 📦 What's Included
+
+- **Full CLI Interface** - Complete command-line tool
+- **Memory Management** - Create, search, list memories
+- **Type System** - Organized memory categorization
+- **Authentication** - Secure service integration
+- **Configuration** - Flexible service setup
+- **Help System** - Comprehensive documentation
+
+## 🔗 Related Projects
+
+- **Memory Service Backend** - Full MaaS API server
+- **Memory SDK** - JavaScript/TypeScript SDK for developers
+- **Memory Visualizer** - Interactive memory exploration
+
+## 📄 License
+
+MIT License - see LICENSE file for details
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 🐛 Support
+
+- **Issues**: [GitHub Issues](https://github.com/seyederick/memory-cli/issues)
+- **Documentation**: [CLI Documentation](https://github.com/seyederick/memory-cli)
+
+## 🎯 Use Cases
+
+- **Personal Knowledge Management** - Organize your thoughts and notes
+- **Team Knowledge Sharing** - Collaborative memory management
+- **Project Documentation** - Context-aware project memories
+- **Research Organization** - Academic and research note-taking
+- **API Integration** - Programmatic memory management
+
+---
+
+**Built with ❤️ for the Memory as a Service ecosystem**

package/dist/commands/auth.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(options: any): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,130 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { apiClient } from '../utils/api.js';
+import { CLIConfig } from '../utils/config.js';
+export async function loginCommand(options) {
+    const config = new CLIConfig();
+    await config.init();
+    console.log(chalk.blue.bold('🔐 Login to MaaS (Supabase Auth)'));
+    console.log();
+    let { email, password } = options;
+    // Get credentials if not provided
+    if (!email || !password) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'email',
+                message: 'Email:',
+                default: email,
+                validate: (input) => {
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    return emailRegex.test(input) || 'Please enter a valid email address';
+                }
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Password:',
+                mask: '*',
+                validate: (input) => input.length > 0 || 'Password is required'
+            }
+        ]);
+        email = answers.email;
+        password = answers.password;
+    }
+    const spinner = ora('Authenticating...').start();
+    try {
+        const response = await apiClient.login(email, password);
+        // Store token and user info
+        await config.setToken(response.token);
+        spinner.succeed('Login successful');
+        console.log();
+        console.log(chalk.green('✓ Authenticated successfully'));
+        console.log(`Welcome, ${response.user.email}!`);
+        if (response.user.organization_id) {
+            console.log(`Organization: ${response.user.organization_id}`);
+        }
+        console.log(`Plan: ${response.user.plan || 'free'}`);
+    }
+    catch (error) {
+        spinner.fail('Login failed');
+        if (error.response?.status === 401) {
+            console.error(chalk.red('✖ Invalid email or password'));
+            // Ask if they want to register
+            const answer = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'register',
+                    message: 'Would you like to create a new account?',
+                    default: false
+                }
+            ]);
+            if (answer.register) {
+                await registerFlow(email);
+            }
+        }
+        else {
+            console.error(chalk.red('✖ Login failed:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+async function registerFlow(defaultEmail) {
+    console.log();
+    console.log(chalk.blue.bold('📝 Create New Account'));
+    console.log();
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            default: defaultEmail,
+            validate: (input) => {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                return emailRegex.test(input) || 'Please enter a valid email address';
+            }
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password (min 8 characters):',
+            mask: '*',
+            validate: (input) => input.length >= 8 || 'Password must be at least 8 characters'
+        },
+        {
+            type: 'password',
+            name: 'confirmPassword',
+            message: 'Confirm password:',
+            mask: '*',
+            validate: (input, answers) => {
+                return input === answers.password || 'Passwords do not match';
+            }
+        },
+        {
+            type: 'input',
+            name: 'organizationName',
+            message: 'Organization name (optional):',
+            default: ''
+        }
+    ]);
+    const spinner = ora('Creating account...').start();
+    try {
+        const response = await apiClient.register(answers.email, answers.password, answers.organizationName || undefined);
+        const config = new CLIConfig();
+        await config.setToken(response.token);
+        spinner.succeed('Account created successfully');
+        console.log();
+        console.log(chalk.green('✓ Account created and authenticated'));
+        console.log(`Welcome to MaaS, ${response.user.email}!`);
+        if (answers.organizationName) {
+            console.log(`Organization: ${answers.organizationName}`);
+        }
+        console.log(`Plan: ${response.user.plan || 'free'}`);
+    }
+    catch (error) {
+        spinner.fail('Registration failed');
+        console.error(chalk.red('✖ Registration failed:'), error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function configCommands(program: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { CLIConfig } from '../utils/config.js';
+import { apiClient } from '../utils/api.js';
+export function configCommands(program) {
+    // Show current configuration
+    program
+        .command('show')
+        .description('Show current configuration')
+        .action(async () => {
+        const config = new CLIConfig();
+        await config.init();
+        console.log(chalk.blue.bold('⚙️  Current Configuration'));
+        console.log();
+        console.log(chalk.green('API URL:'), config.getApiUrl());
+        console.log(chalk.green('Config Path:'), config.getConfigPath());
+        const isAuth = await config.isAuthenticated();
+        console.log(chalk.green('Authenticated:'), isAuth ? chalk.green('Yes') : chalk.red('No'));
+        if (isAuth) {
+            const user = await config.getCurrentUser();
+            if (user) {
+                console.log(chalk.green('User:'), user.email);
+                console.log(chalk.green('Organization:'), user.organization_id);
+                console.log(chalk.green('Role:'), user.role);
+                console.log(chalk.green('Plan:'), user.plan);
+            }
+        }
+    });
+    // Set API URL
+    program
+        .command('set-url')
+        .description('Set API URL')
+        .argument('[url]', 'API URL')
+        .action(async (url) => {
+        const config = new CLIConfig();
+        await config.init();
+        if (!url) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'url',
+                    message: 'API URL:',
+                    default: config.getApiUrl(),
+                    validate: (input) => {
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'Please enter a valid URL';
+                        }
+                    }
+                }
+            ]);
+            url = answer.url;
+        }
+        await config.setApiUrl(url);
+        console.log(chalk.green('✓ API URL updated:'), url);
+    });
+    // Test connection
+    program
+        .command('test')
+        .description('Test connection to API')
+        .action(async () => {
+        const config = new CLIConfig();
+        await config.init();
+        console.log(chalk.blue('🔌 Testing connection...'));
+        console.log(chalk.gray(`API URL: ${config.getApiUrl()}`));
+        console.log();
+        try {
+            const health = await apiClient.getHealth();
+            console.log(chalk.green('✓ Connection successful'));
+            console.log(`Status: ${health.status}`);
+            console.log(`Version: ${health.version}`);
+            console.log(`Uptime: ${Math.round(health.uptime)}s`);
+            if (health.dependencies) {
+                console.log();
+                console.log(chalk.yellow('Dependencies:'));
+                Object.entries(health.dependencies).forEach(([name, info]) => {
+                    const status = info.status === 'healthy' ? chalk.green('✓') : chalk.red('✖');
+                    console.log(`  ${status} ${name}: ${info.status} (${info.response_time}ms)`);
+                });
+            }
+        }
+        catch (error) {
+            console.log(chalk.red('✖ Connection failed'));
+            if (error.code === 'ECONNREFUSED') {
+                console.error(chalk.red('Cannot connect to API server'));
+                console.log(chalk.yellow('Make sure the API server is running'));
+            }
+            else {
+                console.error(chalk.red('Error:'), error.message);
+            }
+            process.exit(1);
+        }
+    });
+    // Reset configuration
+    program
+        .command('reset')
+        .description('Reset all configuration')
+        .option('-f, --force', 'skip confirmation')
+        .action(async (options) => {
+        if (!options.force) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you sure you want to reset all configuration? This will log you out.',
+                    default: false
+                }
+            ]);
+            if (!answer.confirm) {
+                console.log(chalk.yellow('Reset cancelled'));
+                return;
+            }
+        }
+        const config = new CLIConfig();
+        await config.clear();
+        console.log(chalk.green('✓ Configuration reset'));
+        console.log(chalk.yellow('Run'), chalk.white('memory init'), chalk.yellow('to reconfigure'));
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(options: any): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { CLIConfig } from '../utils/config.js';
+export async function initCommand(options) {
+    const config = new CLIConfig();
+    console.log(chalk.blue.bold('🚀 Initializing MaaS CLI'));
+    console.log();
+    // Check if config already exists
+    const configExists = await config.exists();
+    if (configExists && !options.force) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: 'Configuration already exists. Overwrite?',
+                default: false
+            }
+        ]);
+        if (!answer.overwrite) {
+            console.log(chalk.yellow('Initialization cancelled'));
+            return;
+        }
+    }
+    // Get configuration
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'apiUrl',
+            message: 'API URL:',
+            default: 'http://localhost:3000/api/v1',
+            validate: (input) => {
+                try {
+                    new URL(input);
+                    return true;
+                }
+                catch {
+                    return 'Please enter a valid URL';
+                }
+            }
+        }
+    ]);
+    // Initialize config
+    await config.init();
+    await config.setApiUrl(answers.apiUrl);
+    console.log();
+    console.log(chalk.green('✓ CLI initialized successfully'));
+    console.log(chalk.gray(`Configuration saved to: ${config.getConfigPath()}`));
+    console.log();
+    console.log(chalk.yellow('Next steps:'));
+    console.log(chalk.white('  memory login    # Authenticate with your account'));
+    console.log(chalk.white('  memory --help   # Show available commands'));
+}

package/dist/commands/memory.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function memoryCommands(program: Command): void;