lsh-framework 0.5.4

package/dist/lib/database-schema.js

@@ -0,0 +1,259 @@
+/**
+ * Database Schema Definitions for LSH
+ * Defines tables and types for shell data persistence
+ */
+// SQL schema for creating tables
+export const CREATE_TABLES_SQL = `
+-- Shell History Table
+CREATE TABLE IF NOT EXISTS shell_history (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  session_id TEXT NOT NULL,
+  command TEXT NOT NULL,
+  working_directory TEXT NOT NULL,
+  exit_code INTEGER,
+  timestamp TIMESTAMPTZ NOT NULL,
+  duration_ms INTEGER,
+  hostname TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Shell Jobs Table
+CREATE TABLE IF NOT EXISTS shell_jobs (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  session_id TEXT NOT NULL,
+  job_id TEXT NOT NULL,
+  command TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('running', 'stopped', 'completed', 'failed')),
+  pid INTEGER,
+  working_directory TEXT NOT NULL,
+  started_at TIMESTAMPTZ NOT NULL,
+  completed_at TIMESTAMPTZ,
+  exit_code INTEGER,
+  output TEXT,
+  error TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Shell Configuration Table
+CREATE TABLE IF NOT EXISTS shell_configuration (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  config_key TEXT NOT NULL,
+  config_value TEXT NOT NULL,
+  config_type TEXT NOT NULL CHECK (config_type IN ('string', 'number', 'boolean', 'array', 'object')),
+  description TEXT,
+  is_default BOOLEAN DEFAULT FALSE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(user_id, config_key)
+);
+
+-- Shell Sessions Table
+CREATE TABLE IF NOT EXISTS shell_sessions (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  session_id TEXT NOT NULL UNIQUE,
+  hostname TEXT NOT NULL,
+  working_directory TEXT NOT NULL,
+  environment_variables JSONB,
+  started_at TIMESTAMPTZ NOT NULL,
+  ended_at TIMESTAMPTZ,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Shell Aliases Table
+CREATE TABLE IF NOT EXISTS shell_aliases (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  alias_name TEXT NOT NULL,
+  alias_value TEXT NOT NULL,
+  description TEXT,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(user_id, alias_name)
+);
+
+-- Shell Functions Table
+CREATE TABLE IF NOT EXISTS shell_functions (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  function_name TEXT NOT NULL,
+  function_body TEXT NOT NULL,
+  description TEXT,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(user_id, function_name)
+);
+
+-- Shell Completions Table
+CREATE TABLE IF NOT EXISTS shell_completions (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  command TEXT NOT NULL,
+  completion_type TEXT NOT NULL CHECK (completion_type IN ('file', 'directory', 'command', 'variable', 'function', 'option')),
+  completion_pattern TEXT NOT NULL,
+  description TEXT,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(user_id, command, completion_pattern)
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_shell_history_session_id ON shell_history(session_id);
+CREATE INDEX IF NOT EXISTS idx_shell_history_timestamp ON shell_history(timestamp);
+CREATE INDEX IF NOT EXISTS idx_shell_history_user_id ON shell_history(user_id);
+
+CREATE INDEX IF NOT EXISTS idx_shell_jobs_session_id ON shell_jobs(session_id);
+CREATE INDEX IF NOT EXISTS idx_shell_jobs_status ON shell_jobs(status);
+CREATE INDEX IF NOT EXISTS idx_shell_jobs_user_id ON shell_jobs(user_id);
+
+CREATE INDEX IF NOT EXISTS idx_shell_configuration_user_id ON shell_configuration(user_id);
+CREATE INDEX IF NOT EXISTS idx_shell_configuration_key ON shell_configuration(config_key);
+
+CREATE INDEX IF NOT EXISTS idx_shell_sessions_user_id ON shell_sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_shell_sessions_active ON shell_sessions(is_active);
+
+CREATE INDEX IF NOT EXISTS idx_shell_aliases_user_id ON shell_aliases(user_id);
+CREATE INDEX IF NOT EXISTS idx_shell_aliases_name ON shell_aliases(alias_name);
+
+CREATE INDEX IF NOT EXISTS idx_shell_functions_user_id ON shell_functions(user_id);
+CREATE INDEX IF NOT EXISTS idx_shell_functions_name ON shell_functions(function_name);
+
+CREATE INDEX IF NOT EXISTS idx_shell_completions_user_id ON shell_completions(user_id);
+CREATE INDEX IF NOT EXISTS idx_shell_completions_command ON shell_completions(command);
+
+-- ML Training Jobs Table
+CREATE TABLE IF NOT EXISTS ml_training_jobs (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  job_name TEXT NOT NULL,
+  model_type TEXT NOT NULL,
+  dataset_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'failed', 'cancelled')),
+  hyperparameters JSONB NOT NULL,
+  feature_names TEXT[] NOT NULL,
+  target_variable TEXT NOT NULL,
+  train_rmse FLOAT,
+  train_mae FLOAT,
+  train_r2 FLOAT,
+  test_rmse FLOAT,
+  test_mae FLOAT,
+  test_r2 FLOAT,
+  mape FLOAT,
+  cv_scores FLOAT[],
+  cv_mean FLOAT,
+  cv_std FLOAT,
+  model_path TEXT,
+  scaler_path TEXT,
+  started_at TIMESTAMPTZ,
+  completed_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  error_message TEXT,
+  notes TEXT,
+  metadata_json JSONB,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ML Model Versions Table
+CREATE TABLE IF NOT EXISTS ml_model_versions (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  training_job_id UUID REFERENCES ml_training_jobs(id) ON DELETE CASCADE,
+  model_name TEXT NOT NULL,
+  version TEXT NOT NULL,
+  model_type TEXT NOT NULL,
+  test_rmse FLOAT NOT NULL,
+  test_mae FLOAT NOT NULL,
+  test_r2 FLOAT NOT NULL,
+  test_mape FLOAT,
+  feature_importance JSONB,
+  rank_by_rmse INTEGER,
+  rank_by_r2 INTEGER,
+  is_deployed BOOLEAN DEFAULT FALSE,
+  deployed_at TIMESTAMPTZ,
+  model_path TEXT NOT NULL,
+  predictions_file TEXT,
+  residuals_file TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(model_name, version)
+);
+
+-- ML Feature Sets Table
+CREATE TABLE IF NOT EXISTS ml_feature_sets (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  feature_set_name TEXT NOT NULL,
+  version TEXT NOT NULL,
+  features JSONB NOT NULL,
+  feature_count INTEGER NOT NULL,
+  correlation_with_target JSONB,
+  used_in_models TEXT[],
+  description TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  UNIQUE(feature_set_name, version)
+);
+
+-- ML Predictions Table
+CREATE TABLE IF NOT EXISTS ml_predictions (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  model_version_id UUID REFERENCES ml_model_versions(id) ON DELETE CASCADE,
+  prediction_date TIMESTAMPTZ NOT NULL,
+  target_date TIMESTAMPTZ,
+  predicted_value FLOAT NOT NULL,
+  actual_value FLOAT,
+  confidence_score FLOAT,
+  features_json JSONB NOT NULL,
+  residual FLOAT,
+  absolute_error FLOAT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ML Model Comparisons Table
+CREATE TABLE IF NOT EXISTS ml_model_comparisons (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID,
+  comparison_name TEXT NOT NULL,
+  model_ids UUID[] NOT NULL,
+  comparison_results JSONB NOT NULL,
+  best_model_id UUID NOT NULL,
+  best_model_metric TEXT NOT NULL CHECK (best_model_metric IN ('rmse', 'mae', 'r2')),
+  notes TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Indexes for ML tables
+CREATE INDEX IF NOT EXISTS idx_ml_training_jobs_user_id ON ml_training_jobs(user_id);
+CREATE INDEX IF NOT EXISTS idx_ml_training_jobs_status ON ml_training_jobs(status);
+CREATE INDEX IF NOT EXISTS idx_ml_training_jobs_created ON ml_training_jobs(created_at);
+
+CREATE INDEX IF NOT EXISTS idx_ml_model_versions_user_id ON ml_model_versions(user_id);
+CREATE INDEX IF NOT EXISTS idx_ml_model_versions_training_job ON ml_model_versions(training_job_id);
+CREATE INDEX IF NOT EXISTS idx_ml_model_versions_deployed ON ml_model_versions(is_deployed);
+CREATE INDEX IF NOT EXISTS idx_ml_model_versions_performance ON ml_model_versions(test_r2 DESC, test_rmse ASC);
+
+CREATE INDEX IF NOT EXISTS idx_ml_feature_sets_user_id ON ml_feature_sets(user_id);
+CREATE INDEX IF NOT EXISTS idx_ml_feature_sets_name ON ml_feature_sets(feature_set_name);
+
+CREATE INDEX IF NOT EXISTS idx_ml_predictions_user_id ON ml_predictions(user_id);
+CREATE INDEX IF NOT EXISTS idx_ml_predictions_model ON ml_predictions(model_version_id);
+CREATE INDEX IF NOT EXISTS idx_ml_predictions_date ON ml_predictions(prediction_date);
+
+CREATE INDEX IF NOT EXISTS idx_ml_model_comparisons_user_id ON ml_model_comparisons(user_id);
+CREATE INDEX IF NOT EXISTS idx_ml_model_comparisons_created ON ml_model_comparisons(created_at);
+`;
+export default {
+    CREATE_TABLES_SQL,
+};

package/dist/lib/enhanced-history-system.js

@@ -0,0 +1,246 @@
+/**
+ * Enhanced History System with Supabase Integration
+ * Extends the base history system with cloud persistence
+ */
+import HistorySystem from './history-system.js';
+import DatabasePersistence from './database-persistence.js';
+import * as os from 'os';
+import * as path from 'path';
+export class EnhancedHistorySystem extends HistorySystem {
+    databasePersistence;
+    enhancedConfig;
+    syncTimer;
+    pendingSync = false;
+    constructor(config = {}) {
+        const defaultConfig = {
+            maxSize: 10000,
+            filePath: path.join(os.homedir(), '.lsh_history'),
+            shareHistory: true,
+            ignoreDups: true,
+            ignoreSpace: true,
+            expireDuplicatesFirst: true,
+            enableCloudSync: true,
+            userId: undefined,
+            syncInterval: 30000, // 30 seconds
+            ...config,
+        };
+        super(defaultConfig);
+        this.enhancedConfig = defaultConfig;
+        this.databasePersistence = new DatabasePersistence(defaultConfig.userId);
+        if (this.enhancedConfig.enableCloudSync) {
+            this.initializeCloudSync();
+        }
+    }
+    /**
+     * Initialize cloud synchronization
+     */
+    async initializeCloudSync() {
+        try {
+            const isConnected = await this.databasePersistence.testConnection();
+            if (isConnected) {
+                console.log('✅ Cloud history sync enabled');
+                await this.loadCloudHistory();
+                this.startSyncTimer();
+            }
+            else {
+                console.log('⚠️  Cloud history sync disabled - database not available');
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize cloud sync:', error);
+        }
+    }
+    /**
+     * Load history from cloud database
+     */
+    async loadCloudHistory() {
+        try {
+            const cloudEntries = await this.databasePersistence.getHistoryEntries(1000);
+            // Convert cloud entries to local format
+            const localEntries = cloudEntries.map((entry, index) => ({
+                lineNumber: index + 1,
+                command: entry.command,
+                timestamp: new Date(entry.timestamp).getTime(),
+                exitCode: entry.exit_code,
+            }));
+            // Merge with local history (avoid duplicates)
+            this.mergeHistoryEntries(localEntries);
+        }
+        catch (error) {
+            console.error('Failed to load cloud history:', error);
+        }
+    }
+    /**
+     * Merge cloud history entries with local history
+     */
+    mergeHistoryEntries(cloudEntries) {
+        const localEntries = this.getAllEntries();
+        const mergedEntries = [];
+        // Create a map of local entries by command and timestamp
+        const localMap = new Map();
+        localEntries.forEach(entry => {
+            const key = `${entry.command}_${entry.timestamp}`;
+            localMap.set(key, entry);
+        });
+        // Add cloud entries that don't exist locally
+        cloudEntries.forEach(entry => {
+            const key = `${entry.command}_${entry.timestamp}`;
+            if (!localMap.has(key)) {
+                mergedEntries.push(entry);
+            }
+        });
+        // Add all local entries
+        mergedEntries.push(...localEntries);
+        // Sort by timestamp and update line numbers
+        mergedEntries.sort((a, b) => a.timestamp - b.timestamp);
+        mergedEntries.forEach((entry, index) => {
+            entry.lineNumber = index + 1;
+        });
+        // Update internal entries
+        this.entries = mergedEntries;
+    }
+    /**
+     * Start periodic synchronization timer
+     */
+    startSyncTimer() {
+        this.syncTimer = setInterval(() => {
+            this.syncToCloud();
+        }, this.enhancedConfig.syncInterval);
+    }
+    /**
+     * Stop synchronization timer
+     */
+    stopSyncTimer() {
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = undefined;
+        }
+    }
+    /**
+     * Synchronize local history to cloud
+     */
+    async syncToCloud() {
+        if (this.pendingSync || !this.enhancedConfig.enableCloudSync) {
+            return;
+        }
+        this.pendingSync = true;
+        try {
+            const localEntries = this.getAllEntries();
+            const recentEntries = localEntries.slice(-50); // Sync last 50 entries
+            for (const entry of recentEntries) {
+                await this.databasePersistence.saveHistoryEntry({
+                    session_id: this.databasePersistence.getSessionId(),
+                    command: entry.command,
+                    working_directory: process.cwd(),
+                    exit_code: entry.exitCode,
+                    timestamp: new Date(entry.timestamp).toISOString(),
+                    hostname: os.hostname(),
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to sync history to cloud:', error);
+        }
+        finally {
+            this.pendingSync = false;
+        }
+    }
+    /**
+     * Override addCommand to include cloud sync
+     */
+    addCommand(command, exitCode) {
+        super.addCommand(command, exitCode);
+        // Sync to cloud if enabled
+        if (this.enhancedConfig.enableCloudSync) {
+            this.syncToCloud().catch(error => {
+                console.error('Failed to sync command to cloud:', error);
+            });
+        }
+    }
+    /**
+     * Search history across local and cloud data
+     */
+    async searchHistoryCloud(query, limit = 20) {
+        const localResults = this.searchHistory(query).slice(0, limit);
+        if (!this.enhancedConfig.enableCloudSync) {
+            return localResults;
+        }
+        try {
+            // Search cloud history
+            const cloudEntries = await this.databasePersistence.getHistoryEntries(1000);
+            const cloudResults = cloudEntries
+                .filter(entry => entry.command.toLowerCase().includes(query.toLowerCase()))
+                .slice(0, limit)
+                .map((entry, index) => ({
+                lineNumber: index + 1,
+                command: entry.command,
+                timestamp: new Date(entry.timestamp).getTime(),
+                exitCode: entry.exit_code,
+            }));
+            // Merge and deduplicate results
+            const allResults = [...localResults, ...cloudResults];
+            const uniqueResults = allResults.filter((entry, index, arr) => arr.findIndex(e => e.command === entry.command && e.timestamp === entry.timestamp) === index);
+            return uniqueResults.slice(0, limit);
+        }
+        catch (error) {
+            console.error('Failed to search cloud history:', error);
+            return localResults;
+        }
+    }
+    /**
+     * Get history statistics
+     */
+    async getHistoryStats() {
+        const localEntries = this.getAllEntries();
+        let cloudEntries = 0;
+        if (this.enhancedConfig.enableCloudSync) {
+            try {
+                const cloudData = await this.databasePersistence.getHistoryEntries(10000);
+                cloudEntries = cloudData.length;
+            }
+            catch (error) {
+                console.error('Failed to get cloud history stats:', error);
+            }
+        }
+        // Calculate statistics
+        const commandCounts = new Map();
+        let totalLength = 0;
+        localEntries.forEach(entry => {
+            commandCounts.set(entry.command, (commandCounts.get(entry.command) || 0) + 1);
+            totalLength += entry.command.length;
+        });
+        const mostUsedCommand = Array.from(commandCounts.entries())
+            .sort(([, a], [, b]) => b - a)[0]?.[0] || '';
+        return {
+            localEntries: localEntries.length,
+            cloudEntries,
+            totalCommands: localEntries.length + cloudEntries,
+            mostUsedCommand,
+            averageCommandLength: localEntries.length > 0 ? totalLength / localEntries.length : 0,
+        };
+    }
+    /**
+     * Enable or disable cloud sync
+     */
+    setCloudSyncEnabled(enabled) {
+        this.enhancedConfig.enableCloudSync = enabled;
+        if (enabled) {
+            this.initializeCloudSync();
+        }
+        else {
+            this.stopSyncTimer();
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        this.stopSyncTimer();
+        if (this.enhancedConfig.enableCloudSync) {
+            this.syncToCloud().catch(error => {
+                console.error('Failed to final sync on destroy:', error);
+            });
+        }
+    }
+}
+export default EnhancedHistorySystem;