@lanonasis/cli 1.5.2 → 2.0.1

package/dist/core/progress.js

@@ -0,0 +1,428 @@
+/**
+ * Progress Indicators and Feedback System
+ * Provides real-time visual feedback for long-running operations
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import cliProgress from 'cli-progress';
+import { performance } from 'perf_hooks';
+export class ProgressIndicator {
+    spinner;
+    progressBar;
+    startTime;
+    /**
+     * Show a spinner for indeterminate progress
+     */
+    startSpinner(message, options) {
+        this.startTime = performance.now();
+        this.spinner = ora({
+            text: message,
+            spinner: (options?.spinner || 'dots12'),
+            color: (options?.color || 'cyan'),
+            prefixText: options?.prefix,
+            indent: options?.indent || 0
+        }).start();
+    }
+    /**
+     * Update spinner text
+     */
+    updateSpinner(message) {
+        if (this.spinner) {
+            this.spinner.text = message;
+        }
+    }
+    /**
+     * Complete spinner with success
+     */
+    succeedSpinner(message) {
+        if (this.spinner) {
+            const elapsed = this.getElapsedTime();
+            const finalMessage = message || this.spinner.text;
+            this.spinner.succeed(`${finalMessage} ${chalk.dim(`(${elapsed}ms)`)}`);
+            this.spinner = undefined;
+        }
+    }
+    /**
+     * Complete spinner with failure
+     */
+    failSpinner(message) {
+        if (this.spinner) {
+            const elapsed = this.getElapsedTime();
+            const finalMessage = message || this.spinner.text;
+            this.spinner.fail(`${finalMessage} ${chalk.dim(`(${elapsed}ms)`)}`);
+            this.spinner = undefined;
+        }
+    }
+    /**
+     * Complete spinner with warning
+     */
+    warnSpinner(message) {
+        if (this.spinner) {
+            const elapsed = this.getElapsedTime();
+            const finalMessage = message || this.spinner.text;
+            this.spinner.warn(`${finalMessage} ${chalk.dim(`(${elapsed}ms)`)}`);
+            this.spinner = undefined;
+        }
+    }
+    /**
+     * Stop spinner without status
+     */
+    stopSpinner() {
+        if (this.spinner) {
+            this.spinner.stop();
+            this.spinner = undefined;
+        }
+    }
+    /**
+     * Show a progress bar for determinate progress
+     */
+    startProgressBar(total, options) {
+        this.startTime = performance.now();
+        const format = options?.format ||
+            '{title} |' + chalk.cyan('{bar}') + '| {percentage}% | {value}/{total} | {duration}s | {eta}s remaining';
+        this.progressBar = new cliProgress.SingleBar({
+            format,
+            barCompleteChar: '█',
+            barIncompleteChar: '░',
+            hideCursor: true,
+            clearOnComplete: options?.clearOnComplete || false,
+            stopOnComplete: true
+        }, cliProgress.Presets.shades_classic);
+        this.progressBar.start(total, 0, {
+            title: options?.title || 'Progress'
+        });
+    }
+    /**
+     * Update progress bar
+     */
+    updateProgressBar(current, payload) {
+        if (this.progressBar) {
+            this.progressBar.update(current, payload);
+        }
+    }
+    /**
+     * Increment progress bar
+     */
+    incrementProgressBar(amount = 1) {
+        if (this.progressBar) {
+            this.progressBar.increment(amount);
+        }
+    }
+    /**
+     * Complete progress bar
+     */
+    stopProgressBar() {
+        if (this.progressBar) {
+            this.progressBar.stop();
+            this.progressBar = undefined;
+        }
+    }
+    /**
+     * Execute operation with spinner
+     */
+    async withSpinner(operation, message, options) {
+        this.startSpinner(message, options);
+        try {
+            const result = await operation();
+            this.succeedSpinner();
+            return result;
+        }
+        catch (error) {
+            this.failSpinner();
+            throw error;
+        }
+    }
+    /**
+     * Execute operation with progress tracking
+     */
+    async withProgress(operation, total, options) {
+        this.startProgressBar(total, options);
+        const tracker = {
+            update: (current, payload) => {
+                this.updateProgressBar(current, payload);
+            },
+            increment: (amount) => {
+                this.incrementProgressBar(amount);
+            }
+        };
+        try {
+            const result = await operation(tracker);
+            this.stopProgressBar();
+            return result;
+        }
+        catch (error) {
+            this.stopProgressBar();
+            throw error;
+        }
+    }
+    /**
+     * Get elapsed time since start
+     */
+    getElapsedTime() {
+        if (!this.startTime)
+            return '0';
+        const elapsed = Math.round(performance.now() - this.startTime);
+        return elapsed.toString();
+    }
+}
+/**
+ * Multi-step progress indicator
+ */
+export class MultiStepProgress {
+    steps;
+    currentStep = 0;
+    progressIndicator;
+    constructor(steps) {
+        this.steps = steps;
+        this.progressIndicator = new ProgressIndicator();
+    }
+    /**
+     * Start the multi-step process
+     */
+    start() {
+        this.render();
+    }
+    /**
+     * Complete current step and move to next
+     */
+    nextStep(success = true) {
+        if (this.currentStep < this.steps.length) {
+            this.steps[this.currentStep].status = success ? 'completed' : 'failed';
+            this.currentStep++;
+            this.render();
+        }
+    }
+    /**
+     * Complete all steps
+     */
+    complete() {
+        for (let i = this.currentStep; i < this.steps.length; i++) {
+            this.steps[i].status = 'completed';
+        }
+        this.currentStep = this.steps.length;
+        this.render();
+    }
+    /**
+     * Render the multi-step progress
+     */
+    render() {
+        console.clear();
+        const progressBar = this.renderProgressBar();
+        const stepList = this.renderStepList();
+        console.log(chalk.bold('Progress\n'));
+        console.log(progressBar);
+        console.log();
+        console.log(stepList);
+        if (this.currentStep < this.steps.length) {
+            console.log();
+            console.log(chalk.cyan(`→ ${this.steps[this.currentStep].name}...`));
+        }
+    }
+    /**
+     * Render progress bar
+     */
+    renderProgressBar() {
+        const completed = this.steps.filter(s => s.status === 'completed').length;
+        const total = this.steps.length;
+        const percentage = Math.round((completed / total) * 100);
+        const barLength = 40;
+        const filled = Math.round((completed / total) * barLength);
+        const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
+        return `[${chalk.cyan(bar)}] ${percentage}%`;
+    }
+    /**
+     * Render step list
+     */
+    renderStepList() {
+        return this.steps.map((step, index) => {
+            let icon;
+            let color;
+            switch (step.status) {
+                case 'completed':
+                    icon = chalk.green('✓');
+                    color = chalk.green;
+                    break;
+                case 'failed':
+                    icon = chalk.red('✗');
+                    color = chalk.red;
+                    break;
+                case 'pending':
+                    icon = chalk.gray('○');
+                    color = chalk.gray;
+                    break;
+                case 'active':
+                    icon = chalk.blue('●');
+                    color = chalk.blue;
+                    break;
+                default:
+                    icon = chalk.gray('○');
+                    color = chalk.gray;
+            }
+            const stepNumber = `[${index + 1}]`;
+            const name = color(step.name);
+            const description = step.description ? chalk.dim(` - ${step.description}`) : '';
+            return `${icon} ${stepNumber} ${name}${description}`;
+        }).join('\n');
+    }
+}
+/**
+ * Smart suggestions system
+ */
+export class SmartSuggestions {
+    userContext;
+    commandHistory = [];
+    constructor(userContext) {
+        this.userContext = userContext;
+    }
+    /**
+     * Get suggestions based on current context
+     */
+    getSuggestions(input) {
+        const suggestions = [];
+        // Command completion suggestions
+        if (input.startsWith('onasis ')) {
+            suggestions.push(...this.getCommandSuggestions(input));
+        }
+        // Natural language interpretation
+        if (!input.startsWith('onasis')) {
+            suggestions.push(...this.getNaturalLanguageSuggestions(input));
+        }
+        // Historical suggestions
+        suggestions.push(...this.getHistoricalSuggestions(input));
+        // Context-based suggestions
+        suggestions.push(...this.getContextualSuggestions());
+        return this.rankSuggestions(suggestions).slice(0, 5);
+    }
+    /**
+     * Get command-based suggestions
+     */
+    getCommandSuggestions(input) {
+        const commands = [
+            { command: 'memory create', description: 'Create a new memory' },
+            { command: 'memory search', description: 'Search memories' },
+            { command: 'memory list', description: 'List all memories' },
+            { command: 'topic create', description: 'Create a new topic' },
+            { command: 'api-keys create', description: 'Create API key' },
+            { command: 'auth login', description: 'Authenticate' },
+            { command: 'config set', description: 'Update configuration' }
+        ];
+        const partial = input.replace('onasis ', '').toLowerCase();
+        return commands
+            .filter(cmd => cmd.command.startsWith(partial))
+            .map(cmd => ({
+            text: `onasis ${cmd.command}`,
+            description: cmd.description,
+            type: 'command',
+            score: 0.8
+        }));
+    }
+    /**
+     * Get natural language suggestions
+     */
+    getNaturalLanguageSuggestions(input) {
+        const suggestions = [];
+        const lower = input.toLowerCase();
+        if (lower.includes('remember') || lower.includes('save')) {
+            suggestions.push({
+                text: 'onasis memory create',
+                description: 'Create a new memory from your input',
+                type: 'natural',
+                score: 0.9
+            });
+        }
+        if (lower.includes('find') || lower.includes('search')) {
+            suggestions.push({
+                text: `onasis memory search "${input.replace(/find|search/gi, '').trim()}"`,
+                description: 'Search for memories',
+                type: 'natural',
+                score: 0.9
+            });
+        }
+        if (lower.includes('help') || lower.includes('how')) {
+            suggestions.push({
+                text: 'onasis help',
+                description: 'Show help and documentation',
+                type: 'natural',
+                score: 0.85
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Get historical suggestions
+     */
+    getHistoricalSuggestions(input) {
+        return this.commandHistory
+            .filter(cmd => cmd.startsWith(input))
+            .map(cmd => ({
+            text: cmd,
+            description: 'Previously used command',
+            type: 'history',
+            score: 0.7
+        }));
+    }
+    /**
+     * Get contextual suggestions
+     */
+    getContextualSuggestions() {
+        const suggestions = [];
+        const now = new Date();
+        const hour = now.getHours();
+        // Time-based suggestions
+        if (hour >= 9 && hour <= 11) {
+            suggestions.push({
+                text: 'onasis memory create --type meeting',
+                description: 'Create morning meeting notes',
+                type: 'contextual',
+                score: 0.6
+            });
+        }
+        else if (hour >= 16 && hour <= 18) {
+            suggestions.push({
+                text: 'onasis memory list --today',
+                description: "Review today's memories",
+                type: 'contextual',
+                score: 0.6
+            });
+        }
+        // User behavior suggestions
+        if (!this.userContext.hasCreatedMemoryToday) {
+            suggestions.push({
+                text: 'onasis memory create',
+                description: "You haven't created a memory today",
+                type: 'contextual',
+                score: 0.75
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Rank suggestions by relevance
+     */
+    rankSuggestions(suggestions) {
+        return suggestions.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Add command to history
+     */
+    addToHistory(command) {
+        this.commandHistory.unshift(command);
+        if (this.commandHistory.length > 100) {
+            this.commandHistory.pop();
+        }
+    }
+    /**
+     * Display suggestions
+     */
+    displaySuggestions(suggestions) {
+        if (suggestions.length === 0)
+            return;
+        console.log(chalk.dim('\n💡 Suggestions:'));
+        suggestions.forEach((suggestion, index) => {
+            const number = chalk.cyan(`${index + 1}.`);
+            const text = chalk.bold(suggestion.text);
+            const desc = chalk.dim(suggestion.description);
+            console.log(`  ${number} ${text} - ${desc}`);
+        });
+    }
+}

package/dist/core/welcome.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Welcome and Onboarding Experience
+ * Provides first-time user experience and guided setup
+ */
+import { StateManager } from './architecture.js';
+export declare class WelcomeExperience {
+    private stateManager;
+    private isFirstRun;
+    constructor(stateManager: StateManager);
+    show(): Promise<void>;
+    private displayWelcomeBanner;
+    private showMainMenu;
+    private handleMenuChoice;
+    private startInteractiveSetup;
+    private goToDashboard;
+    private showDocumentation;
+    private showAbout;
+    private showSettings;
+    private showHelp;
+    private checkAuthentication;
+}
+/**
+ * Interactive Setup Flow
+ */
+export declare class InteractiveSetup {
+    private stateManager;
+    private setupProgress;
+    constructor(stateManager: StateManager);
+    run(): Promise<void>;
+    private showProgressHeader;
+    private renderProgressBar;
+    private setupConnection;
+    private setupAuthentication;
+    private authenticateWithVendorKey;
+    private authenticateWithBrowser;
+    private authenticateWithEmail;
+    private setupConfiguration;
+    private showSetupComplete;
+    private simulateDelay;
+}