llm-checker 3.4.2 → 3.5.1

package/bin/enhanced_cli.js

@@ -47,126 +47,31 @@ const {
     buildComplianceReport,
     serializeComplianceReport
 } = require('../src/policy/audit-reporter');
+const { renderCommandHeader, renderPersistentBanner } = require('../src/ui/cli-theme');
+const { launchInteractivePanel } = require('../src/ui/interactive-panel');
 const policyManager = new PolicyManager();
 const calibrationManager = new CalibrationManager();
 
-// ASCII Art for each command - Large text banners
-const ASCII_ART = {
-    'hw-detect': `
- ██╗  ██╗ █████╗ ██████╗ ██████╗ ██╗    ██╗ █████╗ ██████╗ ███████╗
- ██║  ██║██╔══██╗██╔══██╗██╔══██╗██║    ██║██╔══██╗██╔══██╗██╔════╝
- ███████║███████║██████╔╝██║  ██║██║ █╗ ██║███████║██████╔╝█████╗
- ██╔══██║██╔══██║██╔══██╗██║  ██║██║███╗██║██╔══██║██╔══██╗██╔══╝
- ██║  ██║██║  ██║██║  ██║██████╔╝╚███╔███╔╝██║  ██║██║  ██║███████╗
- ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝  ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝
-                      DETECTION`,
-
-    'smart-recommend': `
- ███████╗███╗   ███╗ █████╗ ██████╗ ████████╗
- ██╔════╝████╗ ████║██╔══██╗██╔══██╗╚══██╔══╝
- ███████╗██╔████╔██║███████║██████╔╝   ██║
- ╚════██║██║╚██╔╝██║██╔══██║██╔══██╗   ██║
- ███████║██║ ╚═╝ ██║██║  ██║██║  ██║   ██║
- ╚══════╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝
-          RECOMMEND - AI Powered`,
-
-    'search': `
- ███████╗███████╗ █████╗ ██████╗  ██████╗██╗  ██╗
- ██╔════╝██╔════╝██╔══██╗██╔══██╗██╔════╝██║  ██║
- ███████╗█████╗  ███████║██████╔╝██║     ███████║
- ╚════██║██╔══╝  ██╔══██║██╔══██╗██║     ██╔══██║
- ███████║███████╗██║  ██║██║  ██║╚██████╗██║  ██║
- ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
-            6900+ Models Available`,
-
-    'sync': `
- ███████╗██╗   ██╗███╗   ██╗ ██████╗
- ██╔════╝╚██╗ ██╔╝████╗  ██║██╔════╝
- ███████╗ ╚████╔╝ ██╔██╗ ██║██║
- ╚════██║  ╚██╔╝  ██║╚██╗██║██║
- ███████║   ██║   ██║ ╚████║╚██████╗
- ╚══════╝   ╚═╝   ╚═╝  ╚═══╝ ╚═════╝
-      Database Synchronization`,
-
-    'check': `
-  ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗
- ██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝
- ██║     ███████║█████╗  ██║     █████╔╝
- ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗
- ╚██████╗██║  ██║███████╗╚██████╗██║  ██╗
-  ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝
-       Compatibility Analysis`,
-
-    'installed': `
- ██╗███╗   ██╗███████╗████████╗ █████╗ ██╗     ██╗     ███████╗██████╗
- ██║████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██║     ██║     ██╔════╝██╔══██╗
- ██║██╔██╗ ██║███████╗   ██║   ███████║██║     ██║     █████╗  ██║  ██║
- ██║██║╚██╗██║╚════██║   ██║   ██╔══██║██║     ██║     ██╔══╝  ██║  ██║
- ██║██║ ╚████║███████║   ██║   ██║  ██║███████╗███████╗███████╗██████╔╝
- ╚═╝╚═╝  ╚═══╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚═════╝
-                     Local Models`,
-
-    'ai-check': `
-  █████╗ ██╗      ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗
- ██╔══██╗██║     ██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝
- ███████║██║     ██║     ███████║█████╗  ██║     █████╔╝
- ██╔══██║██║     ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗
- ██║  ██║██║     ╚██████╗██║  ██║███████╗╚██████╗██║  ██╗
- ╚═╝  ╚═╝╚═╝      ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝
-          AI-Powered Evaluation`,
-
-    'ai-run': `
-  █████╗ ██╗    ██████╗ ██╗   ██╗███╗   ██╗
- ██╔══██╗██║    ██╔══██╗██║   ██║████╗  ██║
- ███████║██║    ██████╔╝██║   ██║██╔██╗ ██║
- ██╔══██║██║    ██╔══██╗██║   ██║██║╚██╗██║
- ██║  ██║██║    ██║  ██║╚██████╔╝██║ ╚████║
- ╚═╝  ╚═╝╚═╝    ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝
-        Launch & Execute Model`,
-
-    'demo': `
- ██████╗ ███████╗███╗   ███╗ ██████╗
- ██╔══██╗██╔════╝████╗ ████║██╔═══██╗
- ██║  ██║█████╗  ██╔████╔██║██║   ██║
- ██║  ██║██╔══╝  ██║╚██╔╝██║██║   ██║
- ██████╔╝███████╗██║ ╚═╝ ██║╚██████╔╝
- ╚═════╝ ╚══════╝╚═╝     ╚═╝ ╚═════╝
-       Interactive Preview`,
-
-    'ollama': `
-  ██████╗ ██╗     ██╗      █████╗ ███╗   ███╗ █████╗
- ██╔═══██╗██║     ██║     ██╔══██╗████╗ ████║██╔══██╗
- ██║   ██║██║     ██║     ███████║██╔████╔██║███████║
- ██║   ██║██║     ██║     ██╔══██║██║╚██╔╝██║██╔══██║
- ╚██████╔╝███████╗███████╗██║  ██║██║ ╚═╝ ██║██║  ██║
-  ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝
-            Status & Integration`,
-
-    'recommend': `
- ██████╗ ███████╗ ██████╗ ██████╗ ███╗   ███╗███╗   ███╗███████╗███╗   ██╗██████╗
- ██╔══██╗██╔════╝██╔════╝██╔═══██╗████╗ ████║████╗ ████║██╔════╝████╗  ██║██╔══██╗
- ██████╔╝█████╗  ██║     ██║   ██║██╔████╔██║██╔████╔██║█████╗  ██╔██╗ ██║██║  ██║
- ██╔══██╗██╔══╝  ██║     ██║   ██║██║╚██╔╝██║██║╚██╔╝██║██╔══╝  ██║╚██╗██║██║  ██║
- ██║  ██║███████╗╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ╚═╝ ██║███████╗██║ ╚████║██████╔╝
- ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═══╝╚═════╝
-                         Top Picks For You`,
-
-    'list-models': `
- ███╗   ███╗ ██████╗ ██████╗ ███████╗██╗     ███████╗
- ████╗ ████║██╔═══██╗██╔══██╗██╔════╝██║     ██╔════╝
- ██╔████╔██║██║   ██║██║  ██║█████╗  ██║     ███████╗
- ██║╚██╔╝██║██║   ██║██║  ██║██╔══╝  ██║     ╚════██║
- ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗███████╗███████║
- ╚═╝     ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚══════╝
-            Browse All Available`
+const COMMAND_HEADER_LABELS = {
+    'hw-detect': 'Hardware Detection',
+    'smart-recommend': 'Smart Recommend',
+    search: 'Model Search',
+    sync: 'Database Sync',
+    'mcp-setup': 'Claude MCP Setup',
+    check: 'Compatibility Check',
+    installed: 'Installed Models',
+    'ai-check': 'AI Check',
+    'ai-run': 'AI Run',
+    demo: 'Demo',
+    ollama: 'Ollama Integration',
+    recommend: 'Recommendations',
+    'list-models': 'Model Catalog'
 };
 
-// Function to display ASCII art for a command
+// Kept as function name for backwards compatibility in command handlers.
 function showAsciiArt(command) {
-    if (ASCII_ART[command]) {
-        console.log(chalk.cyan(ASCII_ART[command]));
-        console.log('');
-    }
+    const label = COMMAND_HEADER_LABELS[command] || command;
+    renderCommandHeader(label);
 }
 
 // Function to search Ollama models by use case
@@ -487,6 +392,123 @@ program
 
 const logger = getLogger({ console: false });
 
+function canRenderColoredHelp() {
+    if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') return true;
+    if (process.env.NO_COLOR) return false;
+    if (process.env.FORCE_COLOR === '0') return false;
+    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
+}
+
+function colorizeHelpInformation(helpText) {
+    const raw = String(helpText || '');
+    if (!raw || !canRenderColoredHelp()) {
+        return raw;
+    }
+
+    const sectionColor = chalk.hex('#22D3EE').bold;
+    const usageLabelColor = chalk.hex('#60A5FA').bold;
+    const usageValueColor = chalk.hex('#F8FAFC').bold;
+    const optionColor = chalk.hex('#A7F3D0');
+    const commandColor = chalk.hex('#93C5FD').bold;
+    const placeholderColor = chalk.hex('#F59E0B');
+    const descriptionColor = chalk.hex('#D1D5DB');
+    const defaultColor = chalk.hex('#C7D2FE');
+
+    const colorizePlaceholders = (value) =>
+        String(value || '').replace(/(\[[^\]]+\]|<[^>]+>)/g, (token) => placeholderColor(token));
+
+    return raw
+        .split('\n')
+        .map((line) => {
+            if (!line.trim()) return line;
+
+            const usageMatch = line.match(/^(\s*)(Usage:)(\s*)(.+)$/);
+            if (usageMatch) {
+                return `${usageMatch[1]}${usageLabelColor(usageMatch[2])}${usageMatch[3]}${usageValueColor(usageMatch[4])}`;
+            }
+
+            const sectionMatch = line.match(/^(\s*)(Options:|Commands:|Enterprise policy examples:|Calibrated routing examples:)\s*$/);
+            if (sectionMatch) {
+                return `${sectionMatch[1]}${sectionColor(sectionMatch[2])}`;
+            }
+
+            if (/^\s*\$ /.test(line.trimStart())) {
+                return line.replace(/\$ .+$/, (commandText) => chalk.hex('#60A5FA')(commandText));
+            }
+
+            if (/^\s*-/.test(line)) {
+                const optionLine = line.match(/^(\s+)(.+?)(\s{2,})(.+)$/);
+                if (optionLine) {
+                    return (
+                        optionLine[1] +
+                        optionColor(colorizePlaceholders(optionLine[2])) +
+                        optionLine[3] +
+                        descriptionColor(optionLine[4])
+                    );
+                }
+            }
+
+            if (/^\s+[a-z0-9]/i.test(line)) {
+                const commandLine = line.match(/^(\s+)(.+?)(\s{2,})(.+)$/);
+                if (commandLine) {
+                    return (
+                        commandLine[1] +
+                        commandColor(colorizePlaceholders(commandLine[2])) +
+                        commandLine[3] +
+                        descriptionColor(commandLine[4])
+                    );
+                }
+            }
+
+            return defaultColor(line);
+        })
+        .join('\n');
+}
+
+function findCommandByName(commandName) {
+    const requested = String(commandName || '').trim();
+    if (!requested) return null;
+
+    return program.commands.find((cmd) => {
+        if (cmd.name() === requested) return true;
+        try {
+            return cmd.aliases().includes(requested);
+        } catch {
+            return false;
+        }
+    }) || null;
+}
+
+if (!program.commands.some((cmd) => cmd.name() === 'help')) {
+    program
+        .command('help [command]')
+        .description('Show all commands and how to use them')
+        .action((commandName) => {
+            renderPersistentBanner();
+            console.log('');
+
+            if (!commandName) {
+                console.log(colorizeHelpInformation(program.helpInformation()));
+                return;
+            }
+
+            const target = findCommandByName(commandName);
+            if (!target) {
+                const available = program.commands
+                    .map((cmd) => cmd.name())
+                    .filter((name) => name !== 'help')
+                    .sort((a, b) => a.localeCompare(b))
+                    .join(', ');
+                console.error(chalk.red(`Unknown command: ${commandName}`));
+                console.log(chalk.gray(`Available commands: ${available}`));
+                process.exitCode = 1;
+                return;
+            }
+
+            console.log(colorizeHelpInformation(target.helpInformation()));
+        });
+}
+
 // Ollama installation helper
 function getOllamaInstallInstructions() {
     const platform = os.platform();
@@ -591,6 +613,60 @@ async function checkOllamaAndExit() {
     }
 }
 
+function quoteCliArg(value) {
+    const stringValue = String(value ?? '');
+    if (!stringValue) return '""';
+    if (/^[A-Za-z0-9._:/=-]+$/.test(stringValue)) return stringValue;
+    return `"${stringValue.replace(/(["\\$`])/g, '\\$1')}"`;
+}
+
+function getClaudeDesktopConfigPath() {
+    const homeDir = os.homedir();
+    if (process.platform === 'darwin') {
+        return path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+        return path.join(appData, 'Claude', 'claude_desktop_config.json');
+    }
+    return path.join(homeDir, '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function buildClaudeMcpSetup(useNpx = false, serverName = 'llm-checker') {
+    const normalizedServerName = String(serverName || 'llm-checker').trim() || 'llm-checker';
+    const runner = useNpx ? ['npx', 'llm-checker-mcp'] : ['llm-checker-mcp'];
+    const claudeArgs = ['mcp', 'add', normalizedServerName, '--', ...runner];
+    const commandLine = ['claude', ...claudeArgs].map(quoteCliArg).join(' ');
+    const desktopServerConfig = useNpx
+        ? { command: 'npx', args: ['llm-checker-mcp'] }
+        : { command: 'llm-checker-mcp', args: [] };
+
+    return {
+        serverName: normalizedServerName,
+        useNpx: Boolean(useNpx),
+        claudeArgs,
+        commandLine,
+        desktopConfigPath: getClaudeDesktopConfigPath(),
+        desktopConfig: {
+            mcpServers: {
+                [normalizedServerName]: desktopServerConfig
+            }
+        }
+    };
+}
+
+async function runExternalCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            env: process.env
+        });
+
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code));
+    });
+}
+
 function parsePositiveIntegerOption(rawValue, optionName) {
     const parsed = Number(rawValue);
     if (!Number.isFinite(parsed) || parsed <= 0) {
@@ -608,13 +684,32 @@ function parseNonNegativeNumberOption(rawValue, optionName) {
 }
 
 function selectModelsForPlan(installedModels, requestedModels = []) {
+    const runnableModels = (installedModels || []).filter((model) => {
+        const name = String(model?.name || '').toLowerCase();
+        const source = String(model?.source || '').toLowerCase();
+        const type = String(model?.type || model?.model_type || '').toLowerCase();
+        const fileSizeGB = Number(model?.fileSizeGB) || 0;
+
+        const cloudTagged = (
+            name.includes('-cloud') ||
+            name.endsWith(':cloud') ||
+            source.includes('cloud') ||
+            type === 'cloud' ||
+            type === 'remote' ||
+            type === 'hosted'
+        );
+
+        // Keep only models that are actually present locally for memory planning.
+        return !(cloudTagged && fileSizeGB <= 0);
+    });
+
     const requested = Array.isArray(requestedModels)
         ? requestedModels.map((model) => String(model || '').trim()).filter(Boolean)
         : [];
 
     if (!requested.length) {
         return {
-            selected: installedModels.slice(),
+            selected: runnableModels.slice(),
             missing: []
         };
     }
@@ -626,24 +721,24 @@ function selectModelsForPlan(installedModels, requestedModels = []) {
     for (const request of requested) {
         const normalized = request.toLowerCase();
 
-        let match = installedModels.find(
+        let match = runnableModels.find(
             (model) => String(model.name || '').toLowerCase() === normalized
         );
 
         if (!match) {
-            match = installedModels.find((model) =>
+            match = runnableModels.find((model) =>
                 String(model.name || '').toLowerCase().startsWith(`${normalized}:`)
             );
         }
 
         if (!match) {
-            match = installedModels.find(
+            match = runnableModels.find(
                 (model) => String(model.family || '').toLowerCase() === normalized
             );
         }
 
         if (!match) {
-            match = installedModels.find((model) =>
+            match = runnableModels.find((model) =>
                 String(model.name || '').toLowerCase().includes(normalized)
             );
         }
@@ -2418,6 +2513,78 @@ function displayPolicySummary(commandName, policyConfig, evaluation, enforcement
     console.log(chalk.magenta('╰' + '─'.repeat(65)));
 }
 
+program
+    .command('mcp-setup')
+    .description('Show or apply Claude MCP setup for llm-checker')
+    .option('--name <server-name>', 'MCP server name in Claude', 'llm-checker')
+    .option('--npx', 'Use npx llm-checker-mcp instead of global llm-checker-mcp')
+    .option('--apply', 'Run `claude mcp add ...` automatically')
+    .option('-j, --json', 'Output setup details as JSON')
+    .action(async (options) => {
+        const primarySetup = buildClaudeMcpSetup(Boolean(options.npx), options.name);
+        const alternateSetup = buildClaudeMcpSetup(!Boolean(options.npx), options.name);
+
+        if (options.json) {
+            console.log(JSON.stringify({
+                recommended: {
+                    command: 'claude',
+                    args: primarySetup.claudeArgs,
+                    commandLine: primarySetup.commandLine
+                },
+                alternatives: [
+                    {
+                        command: 'claude',
+                        args: alternateSetup.claudeArgs,
+                        commandLine: alternateSetup.commandLine
+                    }
+                ],
+                claudeDesktop: {
+                    configPath: primarySetup.desktopConfigPath,
+                    snippet: primarySetup.desktopConfig
+                }
+            }, null, 2));
+            return;
+        }
+
+        showAsciiArt('mcp-setup');
+
+        console.log(chalk.blue.bold('\nClaude Code MCP Setup'));
+        console.log(chalk.white('\nRecommended command:'));
+        console.log(chalk.cyan(`  ${primarySetup.commandLine}`));
+
+        console.log(chalk.white('\nAlternative command:'));
+        console.log(chalk.gray(`  ${alternateSetup.commandLine}`));
+
+        console.log(chalk.white('\nClaude Desktop config path (manual):'));
+        console.log(chalk.gray(`  ${primarySetup.desktopConfigPath}`));
+        console.log(chalk.white('\nConfig snippet:'));
+        console.log(chalk.gray(JSON.stringify(primarySetup.desktopConfig, null, 2)));
+
+        if (!options.apply) {
+            console.log(chalk.green('\nTip: run with --apply to execute the command automatically.'));
+            return;
+        }
+
+        console.log(chalk.blue('\nApplying MCP setup via Claude CLI...\n'));
+        try {
+            const exitCode = await runExternalCommand('claude', primarySetup.claudeArgs);
+            if (exitCode === 0) {
+                console.log(chalk.green('\nClaude MCP setup applied successfully.'));
+            } else {
+                console.error(chalk.red(`\nClaude command exited with code ${exitCode}.`));
+                process.exit(exitCode || 1);
+            }
+        } catch (error) {
+            if (error && error.code === 'ENOENT') {
+                console.error(chalk.red('Could not find `claude` in PATH.'));
+                console.log(chalk.yellow('Run the printed command manually once Claude CLI is installed.'));
+            } else {
+                console.error(chalk.red(`Failed to apply MCP setup: ${error.message}`));
+            }
+            process.exit(1);
+        }
+    });
+
 const policyCommand = program
     .command('policy')
     .description('Manage enterprise policy files (policy.yaml)')
@@ -3255,140 +3422,6 @@ program
         }
     });
 
-program
-    .command('gpu-plan')
-    .description('Recommend multi-GPU placement strategies for selected local models')
-    .option('--models <models...>', 'Model tags/families to include (default: all local models)')
-    .option('--ctx <tokens>', 'Target context window in tokens', '8192')
-    .option('--concurrency <n>', 'Target parallel request count', '2')
-    .option('--objective <mode>', 'Optimization objective (latency|balanced|throughput)', 'balanced')
-    .option('--reserve-gb <gb>', 'Memory reserve to subtract from available GPU memory', '1')
-    .option('--json', 'Output plan as JSON')
-    .action(async (options) => {
-        const spinner = options.json ? null : ora('Building GPU placement plan...').start();
-
-        try {
-            const requestedObjective = String(options.objective || 'balanced').toLowerCase();
-            const supportedObjectives = new Set(['latency', 'balanced', 'throughput']);
-            if (!supportedObjectives.has(requestedObjective)) {
-                throw new Error(`Invalid objective "${options.objective}". Use latency, balanced, or throughput.`);
-            }
-
-            const targetContext = parsePositiveIntegerOption(options.ctx, '--ctx');
-            const targetConcurrency = parsePositiveIntegerOption(options.concurrency, '--concurrency');
-            const reserveGB = parseNonNegativeNumberOption(options.reserveGb, '--reserve-gb');
-
-            const OllamaClient = require('../src/ollama/client');
-            const UnifiedDetector = require('../src/hardware/unified-detector');
-            const OllamaGPUPlacementPlanner = require('../src/ollama/gpu-placement-planner');
-
-            const ollamaClient = new OllamaClient();
-            const availability = await ollamaClient.checkOllamaAvailability();
-            if (!availability.available) {
-                throw new Error(availability.error || 'Ollama is not available');
-            }
-
-            const localModels = await ollamaClient.getLocalModels();
-            if (!localModels || localModels.length === 0) {
-                throw new Error('No local Ollama models found. Install one with: ollama pull llama3.2:3b');
-            }
-
-            const { selected, missing } = selectModelsForPlan(localModels, options.models || []);
-            if (selected.length === 0) {
-                throw new Error(
-                    `No matching local models found for: ${(options.models || []).join(', ')}`
-                );
-            }
-
-            const detector = new UnifiedDetector();
-            const hardware = await detector.detect();
-            const planner = new OllamaGPUPlacementPlanner();
-
-            const plan = planner.plan({
-                hardware,
-                models: selected,
-                targetContext,
-                targetConcurrency,
-                objective: requestedObjective,
-                reserveGB
-            });
-
-            if (options.json) {
-                console.log(JSON.stringify({
-                    generated_at: new Date().toISOString(),
-                    selection: {
-                        requested: options.models || [],
-                        selected: selected.map((model) => model.name),
-                        missing
-                    },
-                    plan
-                }, null, 2));
-                return;
-            }
-
-            if (spinner) spinner.succeed('GPU placement plan generated');
-
-            console.log('\n' + chalk.bgMagenta.white.bold(' GPU PLACEMENT PLAN '));
-            console.log(chalk.magenta('Backend:'), `${plan.hardware.backend_name} (${plan.hardware.backend})`);
-            console.log(
-                chalk.magenta('GPU inventory:'),
-                `${plan.hardware.gpu_count} device(s), ${plan.hardware.total_usable_memory_gb}GB usable (reserve ${plan.hardware.reserve_gb}GB)`
-            );
-            console.log(
-                chalk.magenta('Target envelope:'),
-                `ctx=${plan.inputs.target_context}, concurrency=${plan.inputs.target_concurrency}, objective=${plan.objective}`
-            );
-
-            if (missing.length > 0) {
-                console.log(chalk.yellow('Missing model filters:'), missing.join(', '));
-            }
-
-            if (!plan.hardware.is_multi_gpu) {
-                console.log(chalk.yellow('Only one GPU detected: replica/spread are included for simulation but may be infeasible.'));
-            }
-
-            for (const modelPlan of plan.models) {
-                const recommended = modelPlan.recommended || {};
-                const recFit = recommended.feasible ? chalk.green('fit') : chalk.red('no-fit');
-                const recRisk = recommended.risk ? `${recommended.risk.level.toUpperCase()} (${recommended.risk.score})` : 'N/A';
-
-                console.log(chalk.magenta.bold(`\nModel: ${modelPlan.name} (${modelPlan.size})`));
-                console.log(
-                    `  Recommended: ${chalk.bold((recommended.strategy || 'unknown').toUpperCase())} | ${recFit} | ~${recommended.estimated_tps || 0} tok/s | risk ${recRisk}`
-                );
-
-                if (recommended.device_env_var && recommended.visible_devices) {
-                    console.log(`  Device pinning hint: export ${recommended.device_env_var}=${recommended.visible_devices}`);
-                }
-
-                console.log(chalk.magenta('  Strategies:'));
-                for (const strategy of modelPlan.strategies) {
-                    const fit = strategy.feasible ? chalk.green('fit') : chalk.red('no-fit');
-                    const risk = strategy.risk ? `${strategy.risk.level} (${strategy.risk.score})` : 'n/a';
-                    console.log(
-                        `    - ${strategy.strategy.padEnd(7)} ${fit} | ~${strategy.estimated_tps} tok/s | ${strategy.memory_per_gpu_gb}GB/GPU | risk ${risk}`
-                    );
-                }
-            }
-
-            if (plan.notes && plan.notes.length > 0) {
-                console.log(chalk.magenta.bold('\nNotes:'));
-                for (const note of plan.notes) {
-                    console.log(`  - ${note}`);
-                }
-            }
-
-            console.log('');
-        } catch (error) {
-            if (spinner) spinner.fail('Failed to build GPU placement plan');
-            console.error(chalk.red('Error:'), error.message);
-            if (process.env.DEBUG) {
-                console.error(error.stack);
-            }
-            process.exit(1);
-        }
-    });
-
 program
     .command('recommend')
     .description('Get intelligent model recommendations for your hardware')
@@ -4317,4 +4350,37 @@ program
         }
     });
 
-program.parse();
+async function bootstrapCli() {
+    const userArgs = process.argv.slice(2);
+    const shouldLaunchPanel =
+        userArgs.length === 0 &&
+        process.stdin.isTTY &&
+        process.stdout.isTTY &&
+        process.env.LLM_CHECKER_DISABLE_PANEL !== '1';
+
+    if (shouldLaunchPanel) {
+        await launchInteractivePanel({
+            program,
+            binaryPath: __filename,
+            appName: 'llm-checker'
+        });
+        return;
+    }
+
+    if (userArgs.length === 0) {
+        renderPersistentBanner();
+        console.log('');
+        program.outputHelp();
+        return;
+    }
+
+    await program.parseAsync(process.argv);
+}
+
+bootstrapCli().catch((error) => {
+    console.error(chalk.red('CLI bootstrap failed:'), error.message);
+    if (process.env.DEBUG) {
+        console.error(error.stack);
+    }
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
     "llm-checker": "bin/cli.js",

package/src/models/ai-check-selector.js

@@ -10,7 +10,7 @@ const { OllamaNativeScraper } = require('../ollama/native-scraper');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
-const fetch = require('node-fetch');
+const fetch = require('../utils/fetch');
 
 class AICheckSelector {
     constructor() {
@@ -803,4 +803,4 @@ Return JSON with this structure:
     }
 }
 
-module.exports = AICheckSelector;
+module.exports = AICheckSelector;