lemonade-interactive-loader 1.0.0

package/src/cli/menu.js

@@ -0,0 +1,359 @@
+const inquirer = require('inquirer');
+const { loadConfig } = require('../config');
+const { getAllInstalledAssets, getLlamaServerPath, downloadAndExtractLlamaCpp, deleteInstalledAsset } = require('../services/asset-manager');
+const { selectLlamaCppRelease, selectAsset, askLaunchServer } = require('./prompts');
+const { runSetupWizard } = require('./setup-wizard');
+const { launchLemonadeServer } = require('../services/server');
+const { inferBackendType, formatBytes } = require('../utils/system');
+
+/**
+ * Display and handle main menu selection
+ * @returns {Promise<string>} Selected command
+ */
+async function showMainMenu() {
+  console.log('');
+  console.log('╔════════════════════════════════════════════════════════╗');
+  console.log('║            🍋 Lemonade Interactive Launcher            ║');
+  console.log('╚════════════════════════════════════════════════════════╝');
+  console.log('');
+  
+  // Check if configuration exists
+  const config = loadConfig();
+  const hasConfig = Object.keys(config).length > 0;
+  
+  // Show message if no configuration exists
+  if (!hasConfig) {
+    console.log('⚠️  No configuration found. Please run Setup first.\n');
+  }
+  
+  // Build choices based on whether config exists
+  let choices;
+  if (hasConfig) {
+    choices = [
+      { name: '▶️  Start Server with Current Config', value: 'serve' },
+      { name: '✏️  Edit Configuration', value: 'edit' },
+      { name: '👁️  View Configuration', value: 'view' },
+      { name: '🔄 Reset Configuration', value: 'reset' },
+      new inquirer.Separator(' ──────────────────────────────────────'),
+      { name: '🚀 Setup - Configure Lemonade Server', value: 'setup' },
+      { name: '📦 Download Custom llama.cpp Builds', value: 'manage' }
+    ];
+  } else {
+    choices = [
+      { name: '🚀 Setup - Configure Lemonade Server', value: 'setup' },
+      { name: '📦 Download Custom llama.cpp Builds', value: 'manage' }
+    ];
+  }
+  
+  const { command } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'command',
+      message: 'What would you like to do?',
+      choices: choices
+    }
+  ]);
+  
+  return command;
+}
+
+/**
+ * Display and handle manage submenu selection
+ * @returns {Promise<string>} Selected action
+ */
+async function showManageMenu() {
+  const { manageAction } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'manageAction',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '👁️  View installed builds', value: 'view' },
+        { name: '🗑️  Delete installed build', value: 'delete' },
+        { name: '⬇️  Download new build', value: 'download' },
+        { name: '← Back to main menu', value: 'back' }
+      ]
+    }
+  ]);
+  
+  return manageAction;
+}
+
+/**
+ * View all installed builds
+ */
+async function viewInstalledBuilds() {
+  const installedAssets = getAllInstalledAssets();
+  
+  if (installedAssets.length === 0) {
+    console.log('\nNo custom llama.cpp builds installed.');
+    return;
+  }
+  
+  console.log('\n=== Installed Custom Builds ===\n');
+  installedAssets.forEach((asset, index) => {
+    const serverPath = getLlamaServerPath(asset.installPath);
+    console.log(`${index + 1}. ${asset.assetName}`);
+    console.log(`   Path: ${asset.installPath}`);
+    console.log(`   Backend: ${asset.backendType.toUpperCase()}`);
+    console.log(`   Installed: ${new Date(asset.installTime).toLocaleString()}`);
+    console.log(`   Server Binary: ${serverPath || 'Not found'}`);
+    console.log('');
+  });
+}
+
+/**
+ * Delete installed builds interactively
+ */
+async function deleteInstalledBuild() {
+  let continueDeleting = true;
+  
+  while (continueDeleting) {
+    const installedAssets = getAllInstalledAssets();
+    
+    if (installedAssets.length === 0) {
+      console.log('\nNo custom llama.cpp builds installed.');
+      break;
+    }
+    
+    const choices = installedAssets.map((asset, index) => ({
+      name: `${asset.assetName} | Backend: ${asset.backendType.toUpperCase()} | ${new Date(asset.installTime).toLocaleDateString()}`,
+      value: index
+    }));
+    
+    choices.unshift({
+      name: '← Cancel',
+      value: -1
+    });
+    
+    const { deleteIndex } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'deleteIndex',
+        message: 'Select a build to delete:',
+        choices: choices
+      }
+    ]);
+    
+    if (deleteIndex < 0) {
+      break;
+    }
+    
+    const assetToDelete = installedAssets[deleteIndex];
+    const { confirmDelete } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmDelete',
+        message: `Are you sure you want to delete "${assetToDelete.assetName}"? This cannot be undone.`,
+        default: false
+      }
+    ]);
+    
+    if (confirmDelete) {
+      const success = deleteInstalledAsset(assetToDelete.installPath);
+      if (success) {
+        console.log(`✓ Deleted: ${assetToDelete.assetName}`);
+      }
+    }
+    
+    const { deleteAnother } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'deleteAnother',
+        message: 'Do you want to delete another build?',
+        default: false
+      }
+    ]);
+    
+    if (!deleteAnother) {
+      continueDeleting = false;
+    }
+  }
+}
+
+/**
+ * Download a new build interactively
+ */
+async function downloadNewBuild() {
+  console.log('\nFetching recent llama.cpp builds...');
+  const release = await selectLlamaCppRelease();
+  const asset = await selectAsset(release);
+  const version = release.tag_name;
+  const installPath = await downloadAndExtractLlamaCpp(asset, version);
+  
+  console.log(`\n✓ Build ready at: ${installPath}`);
+  console.log(`  Backend Type: ${inferBackendType(asset.name).toUpperCase()}`);
+  
+  const { downloadAnother } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'downloadAnother',
+      message: 'Do you want to download another build?',
+      default: false
+    }
+  ]);
+  
+  if (downloadAnother) {
+    await downloadNewBuild();
+  }
+}
+
+/**
+ * View current configuration
+ */
+async function viewConfiguration() {
+  const config = loadConfig();
+  
+  if (Object.keys(config).length === 0) {
+    console.log('No configuration found. Run "setup" to configure.');
+    return;
+  }
+  
+  console.log('\n=== Current Configuration ===\n');
+  console.log(`Host: ${config.host}`);
+  console.log(`Port: ${config.port}`);
+  console.log(`Log Level: ${config.logLevel}`);
+  console.log(`Backend: ${config.backend}`);
+  console.log(`Model Directory: ${config.modelDir}`);
+  console.log(`Run Mode: ${config.runMode}`);
+  console.log(`llama.cpp Args: ${config.llamacppArgs || 'None'}`);
+  
+  if (config.customLlamacppPath) {
+    console.log(`Custom llama.cpp Build: ${config.customLlamacppPath}`);
+    console.log(`  Backend Type: ${config.customBackendType?.toUpperCase() || 'Unknown'}`);
+    console.log(`  Server Binary: ${config.customServerPath || 'Not found'}`);
+  } else {
+    console.log(`Custom llama.cpp Build: Using bundled build`);
+  }
+  
+  const installedAssets = getAllInstalledAssets();
+  if (installedAssets.length > 0) {
+    console.log('\n=== All Installed Custom Builds ===\n');
+    installedAssets.forEach((asset, index) => {
+      const serverPath = getLlamaServerPath(asset.installPath);
+      console.log(`${index + 1}. ${asset.assetName}`);
+      console.log(`   Path: ${asset.installPath}`);
+      console.log(`   Backend: ${asset.backendType.toUpperCase()}`);
+      console.log(`   Installed: ${new Date(asset.installTime).toLocaleString()}`);
+      console.log(`   Server Binary: ${serverPath || 'Not found'}`);
+      console.log('');
+    });
+  }
+}
+
+/**
+ * Reset configuration
+ */
+async function resetConfiguration() {
+  const { confirmReset } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmReset',
+      message: 'Are you sure you want to reset all configuration? This cannot be undone.',
+      default: false
+    }
+  ]);
+  
+  if (confirmReset) {
+    const { resetConfig } = require('../config');
+    resetConfig();
+  }
+}
+
+/**
+ * Handle main menu command
+ * @param {string} command - Selected command
+ */
+async function handleCommand(command) {
+  switch (command) {
+    case 'setup':
+      await runSetupWizard(false);
+      if (await askLaunchServer()) {
+        const config = loadConfig();
+        if (Object.keys(config).length > 0) {
+          await launchLemonadeServer(config);
+        }
+      }
+      break;
+      
+    case 'edit':
+      await runSetupWizard(true);
+      if (await askLaunchServer()) {
+        const config = loadConfig();
+        if (Object.keys(config).length > 0) {
+          await launchLemonadeServer(config);
+        }
+      }
+      break;
+      
+    case 'view':
+      await viewConfiguration();
+      break;
+      
+    case 'reset':
+      await resetConfiguration();
+      break;
+      
+
+      
+    case 'manage':
+      let manageAction;
+      do {
+        manageAction = await showManageMenu();
+        
+        switch (manageAction) {
+          case 'view':
+            await viewInstalledBuilds();
+            break;
+          case 'delete':
+            await deleteInstalledBuild();
+            break;
+          case 'download':
+            await downloadNewBuild();
+            break;
+        }
+      } while (manageAction !== 'back');
+      break;
+      
+    case 'serve':
+      const config = loadConfig();
+      if (Object.keys(config).length === 0) {
+        console.log('No configuration found. Please run "setup" first.');
+        return;
+      }
+      await launchLemonadeServer(config);
+      break;
+  }
+}
+
+/**
+ * Run the main CLI loop
+ */
+async function runCLI() {
+  let continueRunning = true;
+  
+  while (continueRunning) {
+    const command = await showMainMenu();
+    await handleCommand(command);
+    
+    const { continueRunning: shouldContinue } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'continueRunning',
+        message: 'Would you like to return to the main menu?',
+        default: true
+      }
+    ]);
+    
+    continueRunning = shouldContinue;
+  }
+  
+  console.log('\n👋 Goodbye!\n');
+}
+
+module.exports = {
+  showMainMenu,
+  showManageMenu,
+  handleCommand,
+  runCLI
+};

package/src/cli/prompts.js

@@ -0,0 +1,247 @@
+const inquirer = require('inquirer');
+const { DEFAULTS, BACKEND_TYPES, LOG_LEVELS, RUN_MODES, HOSTS } = require('../config/constants');
+const { loadConfig } = require('../config');
+const { detectSystem, formatBytes, filterServerAssets, inferBackendType } = require('../utils/system');
+const { fetchAllReleases } = require('../services/github');
+const { getAllInstalledAssets, getLlamaServerPath, downloadAndExtractLlamaCpp, selectInstalledAsset, isAssetInstalled } = require('../services/asset-manager');
+
+/**
+ * Select a llama.cpp release from list
+ * @returns {Promise<Object>} Selected release
+ */
+async function selectLlamaCppRelease() {
+  console.log('\nFetching available releases...');
+  
+  let releases;
+  try {
+    releases = await fetchAllReleases(20);
+    console.log(`Found ${releases.length} releases.\n`);
+  } catch (error) {
+    console.error(`Error fetching releases: ${error.message}`);
+    process.exit(1);
+  }
+  
+  const releaseChoices = releases.map(release => {
+    const serverAssets = filterServerAssets(release.assets);
+    const installedCount = serverAssets.filter(asset => 
+      isAssetInstalled(release.tag_name, asset.name)
+    ).length;
+    
+    const totalAssets = serverAssets.length;
+    let status = '';
+    if (installedCount === totalAssets && totalAssets > 0) {
+      status = ' ✓ All assets installed';
+    } else if (installedCount > 0) {
+      status = ` (${installedCount}/${totalAssets} installed)`;
+    }
+    
+    return {
+      name: `${release.tag_name} - ${new Date(release.published_at).toLocaleDateString()}${status}`,
+      value: release
+    };
+  });
+  
+  const { selectedRelease } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedRelease',
+      message: 'Select a release:',
+      choices: releaseChoices
+    }
+  ]);
+  
+  return selectedRelease;
+}
+
+/**
+ * Select an asset from a release
+ * @param {Object} release - Release object
+ * @returns {Promise<Object>} Selected asset
+ */
+async function selectAsset(release) {
+  const systemInfo = detectSystem();
+  const serverAssets = filterServerAssets(release.assets);
+  
+  const byPlatform = {};
+  serverAssets.forEach(asset => {
+    let platform = 'Other';
+    const name = asset.name.toLowerCase();
+    
+    if (name.includes('win') || name.includes('windows')) platform = 'Windows';
+    else if (name.includes('ubuntu') || name.includes('linux')) platform = 'Linux';
+    else if (name.includes('macos') || name.includes('mac')) platform = 'macOS';
+    else if (name.includes('rocm')) platform = 'ROCm (Linux)';
+    else if (name.includes('cuda')) platform = 'CUDA (Linux)';
+    
+    if (!byPlatform[platform]) {
+      byPlatform[platform] = [];
+    }
+    byPlatform[platform].push(asset);
+  });
+  
+  const assetChoices = [];
+  for (const [platform, assets] of Object.entries(byPlatform)) {
+    assetChoices.push({
+      name: `── ${platform} ──`,
+      disabled: true
+    });
+    
+    assets.forEach(asset => {
+      const name = asset.name.toLowerCase();
+      let isCurrentPlatform = false;
+      
+      if (systemInfo.osType === 'windows' && platform === 'Windows') {
+        if (systemInfo.arch === 'x64' && name.includes('x64')) isCurrentPlatform = true;
+        else if (systemInfo.arch === 'arm64' && name.includes('arm64')) isCurrentPlatform = true;
+        else if (!name.includes('x64') && !name.includes('arm64')) isCurrentPlatform = true;
+      } else if (systemInfo.osType === 'linux' && platform === 'Linux') {
+        if (systemInfo.arch === 'x64' && name.includes('x64')) isCurrentPlatform = true;
+        else if (systemInfo.arch === 'arm64' && name.includes('aarch64')) isCurrentPlatform = true;
+        else if (!name.includes('x64') && !name.includes('aarch64')) isCurrentPlatform = true;
+      } else if (systemInfo.osType === 'macos' && platform === 'macOS') {
+        if (systemInfo.arch === 'arm64' && (name.includes('arm64') || name.includes('aarch64'))) isCurrentPlatform = true;
+        else if (systemInfo.arch === 'x64' && name.includes('x64')) isCurrentPlatform = true;
+        else if (!name.includes('arm64') && !name.includes('x64')) isCurrentPlatform = true;
+      } else if (systemInfo.osType === 'linux' && platform.includes('ROCm')) {
+        if (systemInfo.arch === 'x64') isCurrentPlatform = true;
+      } else if (systemInfo.osType === 'linux' && platform.includes('CUDA')) {
+        if (systemInfo.arch === 'x64') isCurrentPlatform = true;
+      }
+      
+      const version = release.tag_name;
+      const isInstalled = isAssetInstalled(version, asset.name);
+      
+      let marker = '';
+      if (isInstalled) {
+        marker = ' ✓ Already installed';
+      } else if (isCurrentPlatform) {
+        marker = ' ← Best match';
+      }
+      
+      assetChoices.push({
+        name: `${asset.name} (${formatBytes(asset.size)})${marker}`,
+        value: asset,
+        disabled: false
+      });
+    });
+  }
+  
+  const { selectedAsset } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedAsset',
+      message: 'Select the asset to download:',
+      choices: assetChoices
+    }
+  ]);
+  
+  return selectedAsset;
+}
+
+/**
+ * Select from installed assets
+ * @returns {Promise<Object|null>} Selected asset or null
+ */
+async function selectInstalledAssetPrompt() {
+  const installedAssets = getAllInstalledAssets();
+  
+  if (installedAssets.length === 0) {
+    console.log('\nNo custom llama.cpp builds installed.');
+    return null;
+  }
+  
+  const choices = installedAssets.map((asset, index) => {
+    const installDate = new Date(asset.installTime).toLocaleString();
+    const backendType = asset.backendType.toUpperCase();
+    const serverPath = getLlamaServerPath(asset.installPath);
+    const hasServer = serverPath ? '✓' : '✗';
+    
+    return {
+      name: `[${index + 1}] ${asset.assetName} | Backend: ${backendType} | Installed: ${installDate} | Server: ${hasServer}`,
+      value: asset
+    };
+  });
+  
+  choices.unshift({
+    name: '── Skip - Use bundled build ──',
+    value: null,
+    disabled: false
+  });
+  
+  const { selectedInstalled } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedInstalled',
+      message: 'Select an installed custom build (or skip):',
+      choices: choices
+    }
+  ]);
+  
+  if (selectedInstalled) {
+    const serverPath = getLlamaServerPath(selectedInstalled.installPath);
+    if (!serverPath) {
+      console.log('\n⚠️  Warning: llama-server binary not found in this installation.');
+      console.log('   If you selected "auto" backend, it may not use this binary.');
+    } else {
+      console.log(`\n✓ Selected: ${selectedInstalled.assetName}`);
+      console.log(`  Backend Type: ${selectedInstalled.backendType.toUpperCase()}`);
+      console.log(`  Server Binary: ${serverPath}`);
+      
+      return {
+        ...selectedInstalled,
+        serverPath
+      };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Ask if user wants to launch the server
+ * @returns {Promise<boolean>}
+ */
+async function askLaunchServer() {
+  const { launchNow } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'launchNow',
+      message: 'Would you like to launch the server now?',
+      default: true
+    }
+  ]);
+  
+  return launchNow;
+}
+
+/**
+ * Display configuration summary
+ * @param {Object} config - Configuration object
+ */
+function displayConfigSummary(config) {
+  console.log('\n=== Configuration Summary ===\n');
+  console.log(`Host: ${config.host}`);
+  console.log(`Port: ${config.port}`);
+  console.log(`Log Level: ${config.logLevel}`);
+  console.log(`Backend: ${config.backend}`);
+  console.log(`Model Directory: ${config.modelDir}`);
+  console.log(`Run Mode: ${config.runMode}`);
+  console.log(`llama.cpp Args: ${config.llamacppArgs || 'None'}`);
+  
+  if (config.customLlamacppPath) {
+    console.log(`Custom llama.cpp Build: ${config.customLlamacppPath}`);
+    console.log(`  Backend Type: ${config.customBackendType?.toUpperCase() || 'Unknown'}`);
+    console.log(`  Server Binary: ${config.customServerPath || 'Not found'}`);
+  } else {
+    console.log(`Custom llama.cpp Build: Using bundled build`);
+  }
+  console.log('');
+}
+
+module.exports = {
+  selectLlamaCppRelease,
+  selectAsset,
+  selectInstalledAssetPrompt,
+  askLaunchServer,
+  displayConfigSummary
+};