@lanonasis/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { config } from 'dotenv';
+import { initCommand } from './commands/init.js';
+import { loginCommand } from './commands/auth.js';
+import { memoryCommands } from './commands/memory.js';
+import { topicCommands } from './commands/topics.js';
+import { configCommands } from './commands/config.js';
+import { orgCommands } from './commands/organization.js';
+import { CLIConfig } from './utils/config.js';
+// Load environment variables
+config();
+const program = new Command();
+// CLI Configuration
+const cliConfig = new CLIConfig();
+program
+    .name('memory')
+    .alias('maas')
+    .description('Enterprise Memory as a Service (MaaS) CLI')
+    .version('1.0.0')
+    .option('-v, --verbose', 'enable verbose logging')
+    .option('--api-url <url>', 'override API URL')
+    .option('--output <format>', 'output format (json, table, yaml)', 'table')
+    .hook('preAction', (thisCommand, actionCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.verbose) {
+        process.env.CLI_VERBOSE = 'true';
+    }
+    if (opts.apiUrl) {
+        process.env.MEMORY_API_URL = opts.apiUrl;
+    }
+    process.env.CLI_OUTPUT_FORMAT = opts.output;
+});
+// Global error handler
+process.on('uncaughtException', (error) => {
+    console.error(chalk.red('✖ Unexpected error:'), error.message);
+    if (process.env.CLI_VERBOSE === 'true') {
+        console.error(error.stack);
+    }
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error(chalk.red('✖ Unhandled promise rejection:'), reason);
+    if (process.env.CLI_VERBOSE === 'true') {
+        console.error(promise);
+    }
+    process.exit(1);
+});
+// Welcome message for first-time users
+const showWelcome = () => {
+    console.log(chalk.blue.bold('🧠 Memory as a Service (MaaS) CLI'));
+    console.log(chalk.gray('Enterprise-grade memory management for AI applications'));
+    console.log();
+    console.log(chalk.yellow('Get started:'));
+    console.log(chalk.white('  memory init     # Initialize CLI configuration'));
+    console.log(chalk.white('  memory login    # Authenticate with Supabase account'));
+    console.log(chalk.white('  memory --help   # Show all available commands'));
+    console.log();
+};
+// Check if user is authenticated for protected commands
+const requireAuth = (command) => {
+    command.hook('preAction', async () => {
+        const isAuthenticated = await cliConfig.isAuthenticated();
+        if (!isAuthenticated) {
+            console.error(chalk.red('✖ Authentication required'));
+            console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+            process.exit(1);
+        }
+    });
+};
+// Initialize command (no auth required)
+program
+    .command('init')
+    .description('Initialize CLI configuration')
+    .option('-f, --force', 'overwrite existing configuration')
+    .action(initCommand);
+// Authentication commands (no auth required)
+const authCmd = program
+    .command('auth')
+    .alias('login')
+    .description('Authentication commands');
+authCmd
+    .command('login')
+    .description('Login to your MaaS account')
+    .option('-e, --email <email>', 'email address')
+    .option('-p, --password <password>', 'password')
+    .action(loginCommand);
+authCmd
+    .command('logout')
+    .description('Logout from your account')
+    .action(async () => {
+    await cliConfig.logout();
+    console.log(chalk.green('✓ Logged out successfully'));
+});
+authCmd
+    .command('status')
+    .description('Show authentication status')
+    .action(async () => {
+    const isAuth = await cliConfig.isAuthenticated();
+    const user = await cliConfig.getCurrentUser();
+    if (isAuth && user) {
+        console.log(chalk.green('✓ Authenticated'));
+        console.log(`Email: ${user.email}`);
+        console.log(`Organization: ${user.organization_id}`);
+        console.log(`Plan: ${user.plan}`);
+    }
+    else {
+        console.log(chalk.red('✖ Not authenticated'));
+        console.log(chalk.yellow('Run:'), chalk.white('memory login'));
+    }
+});
+// Memory commands (require auth)
+const memoryCmd = program
+    .command('memory')
+    .alias('mem')
+    .description('Memory management commands');
+requireAuth(memoryCmd);
+memoryCommands(memoryCmd);
+// Topic commands (require auth)
+const topicCmd = program
+    .command('topic')
+    .alias('topics')
+    .description('Topic management commands');
+requireAuth(topicCmd);
+topicCommands(topicCmd);
+// Configuration commands (require auth)
+const configCmd = program
+    .command('config')
+    .description('Configuration management');
+requireAuth(configCmd);
+configCommands(configCmd);
+// Organization commands (require auth)
+const orgCmd = program
+    .command('org')
+    .alias('organization')
+    .description('Organization management');
+requireAuth(orgCmd);
+orgCommands(orgCmd);
+// Global commands that don't require auth
+program
+    .command('status')
+    .description('Show overall system status')
+    .action(async () => {
+    const isAuth = await cliConfig.isAuthenticated();
+    const apiUrl = cliConfig.getApiUrl();
+    console.log(chalk.blue.bold('MaaS CLI Status'));
+    console.log(`API URL: ${apiUrl}`);
+    console.log(`Authenticated: ${isAuth ? chalk.green('Yes') : chalk.red('No')}`);
+    if (isAuth) {
+        const user = await cliConfig.getCurrentUser();
+        if (user) {
+            console.log(`User: ${user.email}`);
+            console.log(`Plan: ${user.plan}`);
+        }
+    }
+});
+program
+    .command('docs')
+    .description('Open documentation in browser')
+    .action(() => {
+    const url = 'https://docs.seyederick.com/memory-service';
+    console.log(chalk.blue(`Opening documentation: ${url}`));
+    // Try to open in browser
+    import('open').then(open => {
+        open.default(url).catch(() => {
+            console.log(chalk.yellow('Could not open browser automatically.'));
+            console.log(chalk.white(`Please visit: ${url}`));
+        });
+    }).catch(() => {
+        console.log(chalk.white(`Please visit: ${url}`));
+    });
+});
+// Help customization
+program.configureHelp({
+    formatHelp: (cmd, helper) => {
+        const term = helper.termWidth || 80;
+        const helpWidth = Math.min(term - 2, 80);
+        let help = chalk.blue.bold('🧠 Memory as a Service CLI\n\n');
+        help += helper.commandUsage(cmd) + '\n\n';
+        if (cmd.description()) {
+            help += chalk.yellow('Description:\n');
+            help += `  ${cmd.description()}\n\n`;
+        }
+        const commands = helper.visibleCommands(cmd);
+        if (commands.length > 0) {
+            help += chalk.yellow('Commands:\n');
+            const maxNameLength = Math.max(...commands.map(c => c.name().length));
+            commands.forEach(c => {
+                const name = c.name().padEnd(maxNameLength);
+                help += `  ${chalk.white(name)}  ${c.description()}\n`;
+            });
+            help += '\n';
+        }
+        const options = helper.visibleOptions(cmd);
+        if (options.length > 0) {
+            help += chalk.yellow('Options:\n');
+            options.forEach(option => {
+                help += `  ${option.flags.padEnd(20)}  ${option.description}\n`;
+            });
+            help += '\n';
+        }
+        help += chalk.gray('For more help on a specific command, run: memory <command> --help\n');
+        help += chalk.gray('Documentation: https://docs.seyederick.com/memory-service\n');
+        return help;
+    }
+});
+// Parse CLI arguments
+async function main() {
+    // Show welcome message if no arguments provided
+    if (process.argv.length <= 2) {
+        showWelcome();
+        return;
+    }
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red('✖ Error:'), error.message);
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.error(error.stack);
+            }
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/utils/api.d.ts

@@ -0,0 +1,24 @@
+import { AxiosRequestConfig } from 'axios';
+export declare class APIClient {
+    private client;
+    private config;
+    constructor();
+    login(email: string, password: string): Promise<any>;
+    register(email: string, password: string, organizationName?: string): Promise<any>;
+    createMemory(data: any): Promise<any>;
+    getMemories(params?: any): Promise<any>;
+    getMemory(id: string): Promise<any>;
+    updateMemory(id: string, data: any): Promise<any>;
+    deleteMemory(id: string): Promise<void>;
+    searchMemories(query: string, options?: any): Promise<any>;
+    getMemoryStats(): Promise<any>;
+    bulkDeleteMemories(memoryIds: string[]): Promise<any>;
+    createTopic(data: any): Promise<any>;
+    getTopics(): Promise<any>;
+    getTopic(id: string): Promise<any>;
+    updateTopic(id: string, data: any): Promise<any>;
+    deleteTopic(id: string): Promise<void>;
+    getHealth(): Promise<any>;
+    request<T = any>(config: AxiosRequestConfig): Promise<T>;
+}
+export declare const apiClient: APIClient;

package/dist/utils/api.js

@@ -0,0 +1,141 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { CLIConfig } from './config.js';
+export class APIClient {
+    client;
+    config;
+    constructor() {
+        this.config = new CLIConfig();
+        this.client = axios.create();
+        // Setup request interceptor to add auth token
+        this.client.interceptors.request.use(async (config) => {
+            await this.config.init();
+            const token = this.config.getToken();
+            if (token) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+            config.baseURL = this.config.getApiUrl();
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.log(chalk.dim(`→ ${config.method?.toUpperCase()} ${config.url}`));
+            }
+            return config;
+        });
+        // Setup response interceptor for error handling
+        this.client.interceptors.response.use((response) => {
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.log(chalk.dim(`← ${response.status} ${response.statusText}`));
+            }
+            return response;
+        }, (error) => {
+            if (error.response) {
+                const { status, data } = error.response;
+                if (status === 401) {
+                    console.error(chalk.red('✖ Authentication failed'));
+                    console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+                    process.exit(1);
+                }
+                if (status === 403) {
+                    console.error(chalk.red('✖ Permission denied'));
+                    if (data.message) {
+                        console.error(chalk.gray(data.message));
+                    }
+                    process.exit(1);
+                }
+                if (status === 429) {
+                    console.error(chalk.red('✖ Rate limit exceeded'));
+                    console.error(chalk.gray('Please wait a moment before trying again'));
+                    process.exit(1);
+                }
+                if (process.env.CLI_VERBOSE === 'true') {
+                    console.error(chalk.dim(`← ${status} ${error.response.statusText}`));
+                    console.error(chalk.dim(JSON.stringify(data, null, 2)));
+                }
+            }
+            return Promise.reject(error);
+        });
+    }
+    // Authentication - aligned with Supabase auth
+    async login(email, password) {
+        const response = await this.client.post('/api/v1/auth/login', {
+            email,
+            password
+        });
+        return response.data;
+    }
+    async register(email, password, organizationName) {
+        const response = await this.client.post('/api/v1/auth/register', {
+            email,
+            password,
+            organization_name: organizationName
+        });
+        return response.data;
+    }
+    // Memory operations - aligned with existing schema
+    async createMemory(data) {
+        const response = await this.client.post('/api/v1/memory', data);
+        return response.data;
+    }
+    async getMemories(params = {}) {
+        const response = await this.client.get('/api/v1/memory', { params });
+        return response.data;
+    }
+    async getMemory(id) {
+        const response = await this.client.get(`/api/v1/memory/${id}`);
+        return response.data;
+    }
+    async updateMemory(id, data) {
+        const response = await this.client.put(`/api/v1/memory/${id}`, data);
+        return response.data;
+    }
+    async deleteMemory(id) {
+        await this.client.delete(`/api/v1/memory/${id}`);
+    }
+    async searchMemories(query, options = {}) {
+        const response = await this.client.post('/api/v1/memory/search', {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    async getMemoryStats() {
+        const response = await this.client.get('/api/v1/memory/stats');
+        return response.data;
+    }
+    async bulkDeleteMemories(memoryIds) {
+        const response = await this.client.post('/api/v1/memory/bulk/delete', {
+            memory_ids: memoryIds
+        });
+        return response.data;
+    }
+    // Topic operations - working with existing memory_topics table
+    async createTopic(data) {
+        const response = await this.client.post('/api/v1/topics', data);
+        return response.data;
+    }
+    async getTopics() {
+        const response = await this.client.get('/api/v1/topics');
+        return response.data;
+    }
+    async getTopic(id) {
+        const response = await this.client.get(`/api/v1/topics/${id}`);
+        return response.data;
+    }
+    async updateTopic(id, data) {
+        const response = await this.client.put(`/api/v1/topics/${id}`, data);
+        return response.data;
+    }
+    async deleteTopic(id) {
+        await this.client.delete(`/api/v1/topics/${id}`);
+    }
+    // Health check
+    async getHealth() {
+        const response = await this.client.get('/api/v1/health');
+        return response.data;
+    }
+    // Generic request method
+    async request(config) {
+        const response = await this.client.request(config);
+        return response.data;
+    }
+}
+export const apiClient = new APIClient();

package/dist/utils/config.d.ts

@@ -0,0 +1,26 @@
+interface UserProfile {
+    email: string;
+    organization_id: string;
+    role: string;
+    plan: string;
+}
+export declare class CLIConfig {
+    private configDir;
+    private configPath;
+    private config;
+    constructor();
+    init(): Promise<void>;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    getApiUrl(): string;
+    setApiUrl(url: string): Promise<void>;
+    setToken(token: string): Promise<void>;
+    getToken(): string | undefined;
+    getCurrentUser(): Promise<UserProfile | undefined>;
+    isAuthenticated(): Promise<boolean>;
+    logout(): Promise<void>;
+    clear(): Promise<void>;
+    getConfigPath(): string;
+    exists(): Promise<boolean>;
+}
+export {};

package/dist/utils/config.js

@@ -0,0 +1,104 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { jwtDecode } from 'jwt-decode';
+export class CLIConfig {
+    configDir;
+    configPath;
+    config = {};
+    constructor() {
+        this.configDir = path.join(os.homedir(), '.maas');
+        this.configPath = path.join(this.configDir, 'config.json');
+    }
+    async init() {
+        try {
+            await fs.mkdir(this.configDir, { recursive: true });
+            await this.load();
+        }
+        catch (error) {
+            // Config doesn't exist yet, that's ok
+        }
+    }
+    async load() {
+        try {
+            const data = await fs.readFile(this.configPath, 'utf-8');
+            this.config = JSON.parse(data);
+        }
+        catch (error) {
+            this.config = {};
+        }
+    }
+    async save() {
+        await fs.mkdir(this.configDir, { recursive: true });
+        this.config.lastUpdated = new Date().toISOString();
+        await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+    }
+    getApiUrl() {
+        return process.env.MEMORY_API_URL ||
+            this.config.apiUrl ||
+            'http://localhost:3000/api/v1';
+    }
+    async setApiUrl(url) {
+        this.config.apiUrl = url;
+        await this.save();
+    }
+    async setToken(token) {
+        this.config.token = token;
+        // Decode token to get user info
+        try {
+            const decoded = jwtDecode(token);
+            // We'll need to fetch full user details from the API
+            // For now, store what we can decode
+            this.config.user = {
+                email: decoded.email || '',
+                organization_id: decoded.organizationId || '',
+                role: decoded.role || '',
+                plan: decoded.plan || ''
+            };
+        }
+        catch (error) {
+            // Invalid token, don't store user info
+        }
+        await this.save();
+    }
+    getToken() {
+        return this.config.token;
+    }
+    async getCurrentUser() {
+        return this.config.user;
+    }
+    async isAuthenticated() {
+        const token = this.getToken();
+        if (!token)
+            return false;
+        try {
+            const decoded = jwtDecode(token);
+            const now = Date.now() / 1000;
+            return decoded.exp > now;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async logout() {
+        this.config.token = undefined;
+        this.config.user = undefined;
+        await this.save();
+    }
+    async clear() {
+        this.config = {};
+        await this.save();
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+    async exists() {
+        try {
+            await fs.access(this.configPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/utils/formatting.d.ts

@@ -0,0 +1,4 @@
+export declare function formatOutput(data: any, 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;

package/dist/utils/formatting.js

@@ -0,0 +1,34 @@
+export function formatOutput(data, format = 'table') {
+    switch (format) {
+        case 'json':
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        case 'yaml':
+            // Would need to import yaml library
+            console.log('YAML output not implemented yet');
+            break;
+        default:
+            // Table format is handled by calling code
+            break;
+    }
+}
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+export function truncateText(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.substring(0, maxLength - 3) + '...';
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${(ms / 60000).toFixed(1)}m`;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lanonasis/cli",
+  "version": "1.0.0",
+  "description": "Lanonasis Enterprise CLI - Memory as a Service and Infrastructure Management",
+  "main": "dist/index-simple.js",
+  "bin": {
+    "lanonasis": "dist/index-simple.js",
+    "memory": "dist/index-simple.js",
+    "maas": "dist/index-simple.js"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc && chmod +x dist/index-simple.js",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "lanonasis",
+    "cli",
+    "memory",
+    "ai",
+    "maas",
+    "enterprise",
+    "infrastructure",
+    "orchestrator"
+  ],
+  "author": "Lanonasis (Seye Derick)",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/inquirer": "^9.0.7",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
+    "eslint": "^9.17.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}