@lanonasis/cli 1.5.2 → 2.0.1

package/dist/core/architecture.js

@@ -0,0 +1,355 @@
+/**
+ * Core Architecture for Enhanced CLI Experience
+ * Implements the layered architecture for state management, interaction, and presentation
+ */
+import { EventEmitter } from 'events';
+import chalk from 'chalk';
+// State Management Layer
+export class StateManager extends EventEmitter {
+    navigationStack = [];
+    userContext;
+    sessionMemory;
+    preferences;
+    constructor() {
+        super();
+        this.userContext = this.initializeUserContext();
+        this.sessionMemory = this.initializeSessionMemory();
+        this.preferences = this.loadPreferences();
+    }
+    initializeUserContext() {
+        return {
+            preferences: this.loadPreferences(),
+            sessionStarted: new Date(),
+            history: []
+        };
+    }
+    initializeSessionMemory() {
+        return {
+            recentCommands: [],
+            recentMemories: [],
+            searchHistory: [],
+            clipboardHistory: [],
+            undoStack: []
+        };
+    }
+    loadPreferences() {
+        // Load from config file or use defaults
+        return {
+            theme: 'default',
+            outputFormat: 'table',
+            verbosity: 'normal',
+            expertMode: false,
+            shortcuts: true,
+            animations: true,
+            autoComplete: true,
+            confirmDestructive: true
+        };
+    }
+    // Navigation methods
+    pushNavigation(state) {
+        this.navigationStack.push(state);
+        this.emit('navigation:push', state);
+        this.renderBreadcrumb();
+    }
+    popNavigation() {
+        if (this.navigationStack.length > 1) {
+            const state = this.navigationStack.pop();
+            this.emit('navigation:pop', state);
+            this.renderBreadcrumb();
+            return state;
+        }
+        return undefined;
+    }
+    getCurrentNavigation() {
+        return this.navigationStack[this.navigationStack.length - 1];
+    }
+    renderBreadcrumb() {
+        if (this.navigationStack.length > 0) {
+            const path = this.navigationStack.map(s => s.name).join(' > ');
+            console.log(chalk.dim(path));
+        }
+    }
+    // Context methods
+    updateUserContext(updates) {
+        this.userContext = { ...this.userContext, ...updates };
+        this.emit('context:update', this.userContext);
+    }
+    getUserContext() {
+        return this.userContext;
+    }
+    // Session memory methods
+    addToHistory(command) {
+        this.sessionMemory.recentCommands.push(command);
+        if (this.sessionMemory.recentCommands.length > 100) {
+            this.sessionMemory.recentCommands.shift();
+        }
+        this.userContext.history.push(command);
+    }
+    getRecentCommands(limit = 10) {
+        return this.sessionMemory.recentCommands.slice(-limit);
+    }
+    // Preferences methods
+    updatePreference(key, value) {
+        this.preferences[key] = value;
+        this.savePreferences();
+        this.emit('preferences:update', { key, value });
+    }
+    getPreferences() {
+        return this.preferences;
+    }
+    savePreferences() {
+        // Save to config file
+        // Implementation would write to ~/.onasis/preferences.json
+    }
+    // Undo/Redo functionality
+    pushToUndoStack(action) {
+        this.sessionMemory.undoStack.push(action);
+        if (this.sessionMemory.undoStack.length > 50) {
+            this.sessionMemory.undoStack.shift();
+        }
+    }
+    popFromUndoStack() {
+        return this.sessionMemory.undoStack.pop();
+    }
+}
+// Interaction Engine
+export class InteractionEngine {
+    stateManager;
+    promptSystem;
+    validationEngine;
+    feedbackLoop;
+    helpSystem;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+        this.promptSystem = new AdaptivePromptSystem(stateManager);
+        this.validationEngine = new ContextualValidator();
+        this.feedbackLoop = new RealTimeFeedback();
+        this.helpSystem = new InlineHelpProvider(stateManager);
+    }
+    async prompt(config) {
+        return this.promptSystem.prompt(config);
+    }
+    validate(value, rules) {
+        return this.validationEngine.validate(value, rules);
+    }
+    showFeedback(message, type) {
+        this.feedbackLoop.show(message, type);
+    }
+    getContextualHelp() {
+        return this.helpSystem.getHelp();
+    }
+}
+// Adaptive Prompt System
+export class AdaptivePromptSystem {
+    stateManager;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    async prompt(config) {
+        const preferences = this.stateManager.getPreferences();
+        // Adapt prompt based on user preferences and context
+        if (preferences.expertMode) {
+            return this.expertPrompt(config);
+        }
+        else {
+            return this.guidedPrompt(config);
+        }
+    }
+    async expertPrompt(config) {
+        // Minimal, streamlined prompt for expert users
+        // Implementation would use minimal UI elements
+        return null;
+    }
+    async guidedPrompt(config) {
+        // Rich, guided prompt with helpful hints
+        // Implementation would use enhanced UI elements
+        return null;
+    }
+}
+// Contextual Validator
+export class ContextualValidator {
+    validate(value, rules) {
+        const errors = [];
+        const warnings = [];
+        const suggestions = [];
+        for (const rule of rules) {
+            const result = rule.validate(value);
+            if (!result.valid) {
+                if (result.severity === 'error') {
+                    errors.push(result.message);
+                }
+                else if (result.severity === 'warning') {
+                    warnings.push(result.message);
+                }
+                if (result.suggestion) {
+                    suggestions.push(result.suggestion);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            suggestions
+        };
+    }
+}
+// Real-time Feedback System
+export class RealTimeFeedback {
+    icons = {
+        success: chalk.green('✓'),
+        error: chalk.red('✖'),
+        warning: chalk.yellow('⚠'),
+        info: chalk.cyan('ℹ'),
+        loading: chalk.blue('◐')
+    };
+    show(message, type) {
+        const icon = this.icons[type];
+        const colorFn = this.getColorFunction(type);
+        console.log(`${icon} ${colorFn(message)}`);
+    }
+    getColorFunction(type) {
+        switch (type) {
+            case 'success': return chalk.green;
+            case 'error': return chalk.red;
+            case 'warning': return chalk.yellow;
+            case 'info': return chalk.cyan;
+            default: return chalk.white;
+        }
+    }
+}
+// Inline Help Provider
+export class InlineHelpProvider {
+    stateManager;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    getHelp() {
+        const currentState = this.stateManager.getCurrentNavigation();
+        const context = this.stateManager.getUserContext();
+        // Return contextual help based on current state
+        return this.generateHelpText(currentState, context);
+    }
+    generateHelpText(state, context) {
+        if (!state) {
+            return 'Type "help" for available commands';
+        }
+        // Generate context-specific help
+        const helps = {
+            'home': 'Main dashboard - choose an action or type a command',
+            'memory:create': 'Creating a new memory - provide title and content',
+            'memory:search': 'Search memories - use natural language or keywords',
+            'settings': 'Configure your preferences and authentication'
+        };
+        return helps[state.name] || 'Type "?" for help, "←" to go back';
+    }
+}
+// Presentation Layer
+export class PresentationLayer {
+    themeEngine;
+    layoutManager;
+    animationController;
+    constructor() {
+        this.themeEngine = new AdaptiveThemeEngine();
+        this.layoutManager = new ResponsiveLayoutManager();
+        this.animationController = new SubtleAnimationController();
+    }
+    applyTheme(theme) {
+        this.themeEngine.setTheme(theme);
+    }
+    renderLayout(content, layout) {
+        this.layoutManager.render(content, layout);
+    }
+    animate(element, animation) {
+        this.animationController.animate(element, animation);
+    }
+}
+// Theme Engine
+export class AdaptiveThemeEngine {
+    currentTheme = 'default';
+    themes = {
+        default: {
+            primary: chalk.blue.bold,
+            secondary: chalk.gray,
+            success: chalk.green,
+            warning: chalk.yellow,
+            error: chalk.red,
+            info: chalk.cyan,
+            accent: chalk.magenta,
+            muted: chalk.dim,
+            highlight: chalk.white.bold
+        },
+        dark: {
+            primary: chalk.cyanBright.bold,
+            secondary: chalk.gray,
+            success: chalk.greenBright,
+            warning: chalk.yellowBright,
+            error: chalk.redBright,
+            info: chalk.blueBright,
+            accent: chalk.magentaBright,
+            muted: chalk.dim,
+            highlight: chalk.whiteBright.bold
+        }
+    };
+    setTheme(theme) {
+        if (theme in this.themes) {
+            this.currentTheme = theme;
+        }
+    }
+    getColors() {
+        return this.themes[this.currentTheme];
+    }
+}
+// Layout Manager
+export class ResponsiveLayoutManager {
+    render(content, layout) {
+        // Implement different layout strategies
+        switch (layout) {
+            case 'card':
+                this.renderCard(content);
+                break;
+            case 'table':
+                this.renderTable(content);
+                break;
+            case 'dashboard':
+                this.renderDashboard(content);
+                break;
+            default:
+                console.log(content);
+        }
+    }
+    renderCard(content) {
+        // Render content in card layout
+        console.log('╭─────────────────────────────────────────╮');
+        console.log(`│ ${content.title || ''}`.padEnd(42) + '│');
+        console.log('├─────────────────────────────────────────┤');
+        console.log(`│ ${content.body || ''}`.padEnd(42) + '│');
+        console.log('╰─────────────────────────────────────────╯');
+    }
+    renderTable(content) {
+        // Render content in table layout
+        // Implementation here
+    }
+    renderDashboard(content) {
+        // Render dashboard layout
+        // Implementation here
+    }
+}
+// Animation Controller
+export class SubtleAnimationController {
+    animate(element, animation) {
+        // Implement subtle animations for CLI
+        // This would handle progress bars, spinners, etc.
+    }
+}
+// Factory to create the complete architecture
+export function createCLIArchitecture() {
+    const stateManager = new StateManager();
+    const interactionEngine = new InteractionEngine(stateManager);
+    const presentationLayer = new PresentationLayer();
+    return {
+        stateManager,
+        interactionEngine,
+        presentationLayer
+    };
+}

package/dist/core/dashboard.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Main Dashboard Command Center
+ * The central hub for all CLI operations after authentication
+ */
+import { StateManager } from './architecture.js';
+export interface DashboardStats {
+    totalMemories: number;
+    totalTopics: number;
+    apiKeys: number;
+    recentActivity: ActivityItem[];
+}
+export interface ActivityItem {
+    action: string;
+    target: string;
+    timestamp: string;
+}
+export declare class DashboardCommandCenter {
+    private stateManager;
+    private stats;
+    constructor(stateManager: StateManager);
+    show(): Promise<void>;
+    private render;
+    private renderHeader;
+    private renderStatsAndActivity;
+    private renderQuickStats;
+    private renderRecentActivity;
+    private renderMainMenu;
+    private renderFooter;
+    private handleUserInput;
+    private processInput;
+    private handleNumberedOption;
+    private createMemory;
+    private searchMemories;
+    private browseTopics;
+    private viewAnalytics;
+    private manageApiKeys;
+    private openSettings;
+    private showHelp;
+    private interpretSmartCommand;
+    private loadStats;
+}
+/**
+ * Interactive Memory Creator
+ */
+export declare class InteractiveMemoryCreator {
+    private stateManager;
+    constructor(stateManager: StateManager);
+    create(): Promise<void>;
+    createQuick(content: string): Promise<void>;
+    private analyzeContent;
+    private showPreview;
+}
+/**
+ * Interactive Search Experience
+ */
+export declare class InteractiveSearch {
+    private stateManager;
+    constructor(stateManager: StateManager);
+    search(initialQuery?: string): Promise<void>;
+    private displayResults;
+    private simulateDelay;
+}
+/**
+ * Analytics View
+ */
+export declare class AnalyticsView {
+    private stateManager;
+    constructor(stateManager: StateManager);
+    show(): Promise<void>;
+    private renderChart;
+}