@edgible-team/cli 1.0.1

package/dist/commands/ai.js

@@ -0,0 +1,608 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAiCommands = setupAiCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+const SystemCapabilityDetector_1 = require("../detection/SystemCapabilityDetector");
+function setupAiCommands(program) {
+    const aiCommand = program
+        .command('ai')
+        .description('Manage Ollama AI service');
+    aiCommand
+        .command('setup')
+        .description('Setup Ollama: install, discover capabilities, and start with selected model')
+        .option('--model <model>', 'Model to use (skips interactive selection)')
+        .option('--auto-install', 'Automatically install Ollama without prompting')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        logger.info('Setting up Ollama AI service', { model: options.model, autoInstall: options.autoInstall });
+        console.log(chalk_1.default.blue('\n🤖 Ollama AI Setup'));
+        console.log(chalk_1.default.gray('This will install Ollama, check system capabilities, and start with a selected model.\n'));
+        // Step 1: Check if Ollama is installed
+        console.log(chalk_1.default.blue('Step 1: Checking Ollama installation...\n'));
+        const isOllamaInstalled = await checkOllamaInstalled();
+        if (!isOllamaInstalled) {
+            let shouldInstall = options.autoInstall || false;
+            if (!shouldInstall) {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'install',
+                        message: 'Ollama is not installed. Would you like to install it now?',
+                        default: true,
+                    },
+                ]);
+                shouldInstall = answer.install;
+            }
+            if (shouldInstall) {
+                console.log(chalk_1.default.yellow('Installing Ollama...\n'));
+                await installOllama();
+                console.log(chalk_1.default.green('✓ Ollama installed successfully\n'));
+            }
+            else {
+                throw new Error('Ollama is required but not installed. Please install it manually from https://ollama.com');
+            }
+        }
+        else {
+            console.log(chalk_1.default.green('✓ Ollama is already installed\n'));
+        }
+        // Step 2: Discover system capabilities
+        console.log(chalk_1.default.blue('Step 2: Discovering system capabilities...\n'));
+        const capabilities = await SystemCapabilityDetector_1.SystemCapabilityDetector.detectCapabilities();
+        // Show GPU driver support status
+        if (capabilities.gpuDriverSupport.ollamaGpuReady) {
+            console.log(chalk_1.default.green('✓ GPU acceleration is ready for Ollama'));
+            if (capabilities.gpuDriverSupport.ollamaGpuReason) {
+                console.log(chalk_1.default.gray(`  ${capabilities.gpuDriverSupport.ollamaGpuReason}\n`));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠ GPU acceleration not available - Ollama will run in CPU mode'));
+            if (capabilities.gpuDriverSupport.ollamaGpuReason) {
+                console.log(chalk_1.default.gray(`  ${capabilities.gpuDriverSupport.ollamaGpuReason}\n`));
+            }
+        }
+        // Step 3: Select model based on recommendations
+        console.log(chalk_1.default.blue('Step 3: Selecting model...\n'));
+        let selectedModel = options.model;
+        if (!selectedModel) {
+            // Filter to only excellent and good recommendations
+            const suitableModels = capabilities.recommendedModels.filter((m) => m.suitability === 'excellent' || m.suitability === 'good');
+            if (suitableModels.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No models are well-suited for your system.'));
+                console.log(chalk_1.default.yellow('You can still run smaller models, but performance may be limited.\n'));
+                const allModels = capabilities.recommendedModels.map((m) => ({
+                    name: `${m.modelName} (${m.size}) - ${m.suitability}`,
+                    value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+                }));
+                // Add custom model option
+                allModels.push({
+                    name: 'Enter custom model name',
+                    value: '__custom__',
+                });
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'model',
+                        message: 'Select a model to use:',
+                        choices: allModels,
+                    },
+                ]);
+                if (answer.model === '__custom__') {
+                    const customAnswer = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'model',
+                            message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                            validate: (input) => {
+                                if (!input || input.trim().length === 0) {
+                                    return 'Model name cannot be empty';
+                                }
+                                return true;
+                            },
+                        },
+                    ]);
+                    selectedModel = customAnswer.model.trim();
+                }
+                else {
+                    selectedModel = answer.model;
+                }
+            }
+            else {
+                console.log(chalk_1.default.green('Recommended models for your system:\n'));
+                suitableModels.forEach((model, index) => {
+                    const icon = model.suitability === 'excellent' ? '✓' : '•';
+                    const color = model.suitability === 'excellent' ? chalk_1.default.green : chalk_1.default.cyan;
+                    console.log(color(`  ${icon} ${model.modelName} (${model.size})`));
+                    console.log(chalk_1.default.gray(`    ${model.reasoning}\n`));
+                });
+                const modelChoices = suitableModels.map((m) => ({
+                    name: `${m.modelName} (${m.size}) - ${m.suitability === 'excellent' ? 'Recommended' : 'Good fit'}`,
+                    value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+                }));
+                // Add option to see all models
+                modelChoices.push({
+                    name: 'Show all models (including marginal/insufficient)',
+                    value: '__all__',
+                });
+                // Add custom model option
+                modelChoices.push({
+                    name: 'Enter custom model name',
+                    value: '__custom__',
+                });
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'model',
+                        message: 'Select a model to use:',
+                        choices: modelChoices,
+                    },
+                ]);
+                if (answer.model === '__custom__') {
+                    const customAnswer = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'model',
+                            message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                            validate: (input) => {
+                                if (!input || input.trim().length === 0) {
+                                    return 'Model name cannot be empty';
+                                }
+                                return true;
+                            },
+                        },
+                    ]);
+                    selectedModel = customAnswer.model.trim();
+                }
+                else if (answer.model === '__all__') {
+                    const allModels = capabilities.recommendedModels.map((m) => ({
+                        name: `${m.modelName} (${m.size}) - ${m.suitability}`,
+                        value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+                    }));
+                    // Add custom model option to all models list too
+                    allModels.push({
+                        name: 'Enter custom model name',
+                        value: '__custom__',
+                    });
+                    const allAnswer = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'model',
+                            message: 'Select a model to use:',
+                            choices: allModels,
+                        },
+                    ]);
+                    if (allAnswer.model === '__custom__') {
+                        const customAnswer = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'model',
+                                message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                                validate: (input) => {
+                                    if (!input || input.trim().length === 0) {
+                                        return 'Model name cannot be empty';
+                                    }
+                                    return true;
+                                },
+                            },
+                        ]);
+                        selectedModel = customAnswer.model.trim();
+                    }
+                    else {
+                        selectedModel = allAnswer.model;
+                    }
+                }
+                else {
+                    selectedModel = answer.model;
+                }
+            }
+        }
+        // Normalize model name (Ollama uses lowercase with dashes)
+        if (!selectedModel) {
+            throw new Error('No model selected');
+        }
+        // If it's already a custom model (contains : or /), use as-is
+        // Otherwise normalize it (recommended models need to be mapped to Ollama format)
+        let ollamaModelName;
+        if (selectedModel.includes(':') || selectedModel.includes('/')) {
+            // Custom model name format (e.g., deepseek-r1:14b, llama3.2:3b, or org/model:tag)
+            ollamaModelName = selectedModel;
+        }
+        else {
+            // Normalize recommended model names to Ollama format (e.g., deepseek-r1-14b -> deepseek-r1:14b)
+            ollamaModelName = normalizeModelName(selectedModel);
+        }
+        console.log(chalk_1.default.blue(`\nSelected model: ${ollamaModelName}\n`));
+        // Step 4: Check if model is already pulled
+        console.log(chalk_1.default.blue('Step 4: Checking if model is available...\n'));
+        const isModelAvailable = await checkModelAvailable(ollamaModelName);
+        if (!isModelAvailable) {
+            console.log(chalk_1.default.yellow(`Model ${ollamaModelName} is not available locally.`));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'pull',
+                    message: `Would you like to download ${ollamaModelName} now? (This may take a while)`,
+                    default: true,
+                },
+            ]);
+            if (answer.pull) {
+                console.log(chalk_1.default.yellow(`\nDownloading ${ollamaModelName}...\n`));
+                await pullModel(ollamaModelName);
+                console.log(chalk_1.default.green(`✓ Model ${ollamaModelName} downloaded successfully\n`));
+            }
+            else {
+                throw new Error(`Model ${ollamaModelName} is not available. Please pull it manually with: ollama pull ${ollamaModelName}`);
+            }
+        }
+        else {
+            console.log(chalk_1.default.green(`✓ Model ${ollamaModelName} is available\n`));
+        }
+        // Step 5: Start Ollama service
+        console.log(chalk_1.default.blue('Step 5: Starting Ollama service...\n'));
+        await startOllama();
+        // Step 6: Verify Ollama is running
+        console.log(chalk_1.default.blue('Step 6: Verifying Ollama is running...\n'));
+        const isRunning = await checkOllamaRunning();
+        if (isRunning) {
+            console.log(chalk_1.default.green('✓ Ollama is running\n'));
+            console.log(chalk_1.default.blue('Ollama Setup Complete!\n'));
+            console.log(chalk_1.default.white('You can now use Ollama with the following commands:'));
+            console.log(chalk_1.default.gray(`  ollama run ${ollamaModelName}`));
+            console.log(chalk_1.default.gray(`  ollama list`));
+            console.log(chalk_1.default.gray(`  edgible ai stop  # Stop Ollama service\n`));
+        }
+        else {
+            throw new Error('Ollama service failed to start. Please check the logs.');
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    aiCommand
+        .command('stop')
+        .description('Stop Ollama service')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        logger.info('Stopping Ollama service');
+        console.log(chalk_1.default.blue('\n🛑 Stopping Ollama service...\n'));
+        const isRunning = await checkOllamaRunning();
+        if (!isRunning) {
+            console.log(chalk_1.default.yellow('Ollama is not running\n'));
+            return;
+        }
+        await stopOllama();
+        console.log(chalk_1.default.green('✓ Ollama service stopped\n'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+/**
+ * Check if Ollama is installed
+ */
+async function checkOllamaInstalled() {
+    try {
+        (0, child_process_1.execSync)('ollama --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install Ollama based on platform
+ */
+async function installOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Use official Ollama install script
+            (0, child_process_1.execSync)('curl -fsSL https://ollama.com/install.sh | sh', {
+                encoding: 'utf8',
+                stdio: 'inherit',
+            });
+        }
+        else if (platform === 'darwin') {
+            // macOS - check for Homebrew
+            try {
+                (0, child_process_1.execSync)('brew --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                (0, child_process_1.execSync)('brew install ollama', {
+                    encoding: 'utf8',
+                    stdio: 'inherit',
+                });
+            }
+            catch {
+                // Fallback to manual install instructions
+                console.log(chalk_1.default.yellow('Homebrew not found. Please install Ollama manually:'));
+                console.log(chalk_1.default.gray('  Visit: https://ollama.com/download\n'));
+                throw new Error('Ollama installation requires Homebrew or manual installation');
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows - use winget or provide instructions
+            try {
+                (0, child_process_1.execSync)('winget --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                (0, child_process_1.execSync)('winget install Ollama.Ollama', {
+                    encoding: 'utf8',
+                    stdio: 'inherit',
+                });
+            }
+            catch {
+                console.log(chalk_1.default.yellow('winget not found. Please install Ollama manually:'));
+                console.log(chalk_1.default.gray('  Visit: https://ollama.com/download\n'));
+                throw new Error('Ollama installation requires winget or manual installation');
+            }
+        }
+        else {
+            throw new Error(`Unsupported platform: ${platform}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to install Ollama:'), error);
+        throw error;
+    }
+}
+/**
+ * Check if a model is available locally
+ */
+async function checkModelAvailable(modelName) {
+    try {
+        const output = (0, child_process_1.execSync)('ollama list', { encoding: 'utf8', timeout: 5000 });
+        // Check if model name appears in the list
+        return output.toLowerCase().includes(modelName.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Pull a model from Ollama
+ */
+async function pullModel(modelName) {
+    try {
+        (0, child_process_1.execSync)(`ollama pull ${modelName}`, {
+            encoding: 'utf8',
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Failed to pull model ${modelName}:`), error);
+        throw error;
+    }
+}
+/**
+ * Start Ollama service
+ */
+async function startOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Try systemd service first
+            try {
+                (0, child_process_1.execSync)('systemctl --user start ollama', { encoding: 'utf8', timeout: 3000 });
+                return;
+            }
+            catch {
+                // Fallback to running ollama serve in background
+            }
+            // Fallback: start ollama serve in background
+            try {
+                (0, child_process_1.execSync)('ollama serve > /dev/null 2>&1 &', { encoding: 'utf8', timeout: 1000 });
+                // Wait a bit for it to start
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            }
+            catch {
+                // Ignore - may already be running
+            }
+        }
+        else if (platform === 'darwin') {
+            // macOS - try launchctl or start directly
+            try {
+                (0, child_process_1.execSync)('launchctl start com.ollama.ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Fallback: start ollama serve
+                try {
+                    (0, child_process_1.execSync)('ollama serve > /dev/null 2>&1 &', { encoding: 'utf8', timeout: 1000 });
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows - Ollama typically runs as a service
+            try {
+                (0, child_process_1.execSync)('net start Ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Service might already be running or not installed as service
+                // Try to start it directly
+                try {
+                    (0, child_process_1.execSync)('start /B ollama serve', { encoding: 'utf8', timeout: 1000 });
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Ollama might already be running, which is fine
+        console.log(chalk_1.default.gray('Note: Ollama service may already be running\n'));
+    }
+}
+/**
+ * Check if Ollama is running
+ */
+async function checkOllamaRunning() {
+    try {
+        // Try to query Ollama API
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        try {
+            const response = await (0, node_fetch_1.default)('http://localhost:11434/api/tags', {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return response.ok;
+        }
+        catch {
+            clearTimeout(timeout);
+            throw new Error('Fetch failed');
+        }
+    }
+    catch {
+        // Try alternative: check if ollama process is running
+        try {
+            const platform = os.platform();
+            if (platform === 'linux' || platform === 'darwin') {
+                (0, child_process_1.execSync)('pgrep -f ollama', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                return true;
+            }
+            else if (platform === 'win32') {
+                (0, child_process_1.execSync)('tasklist /FI "IMAGENAME eq ollama.exe"', {
+                    encoding: 'utf8',
+                    timeout: 2000,
+                    stdio: 'ignore',
+                });
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+}
+/**
+ * Stop Ollama service
+ */
+async function stopOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Try systemd service first
+            try {
+                (0, child_process_1.execSync)('systemctl --user stop ollama', { encoding: 'utf8', timeout: 3000 });
+                return;
+            }
+            catch {
+                // Fallback to killing process
+            }
+            // Fallback: kill ollama processes
+            try {
+                (0, child_process_1.execSync)('pkill -f ollama', { encoding: 'utf8', timeout: 2000 });
+            }
+            catch {
+                // Process might not be running
+            }
+        }
+        else if (platform === 'darwin') {
+            // macOS
+            try {
+                (0, child_process_1.execSync)('launchctl stop com.ollama.ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Fallback
+                try {
+                    (0, child_process_1.execSync)('pkill -f ollama', { encoding: 'utf8', timeout: 2000 });
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows
+            try {
+                (0, child_process_1.execSync)('net stop Ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Fallback
+                try {
+                    (0, child_process_1.execSync)('taskkill /F /IM ollama.exe', { encoding: 'utf8', timeout: 2000 });
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.yellow('Warning: Error stopping Ollama service:'), error);
+    }
+}
+/**
+ * Normalize model name for Ollama (lowercase, dashes, no special chars)
+ * Maps recommended model names to their Ollama model names
+ */
+function normalizeModelName(modelName) {
+    const normalized = modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, '').replace(/\./g, '');
+    // Map model names to Ollama model names
+    const modelMap = {
+        'llama-3.2-1b': 'llama3.2:1b',
+        'llama-3.2-3b': 'llama3.2:3b',
+        'llama-3.1-8b': 'llama3.1:8b',
+        'llama-3.1-70b': 'llama3.1:70b',
+        'mistral-7b': 'mistral:7b',
+        'phi-3-mini-3.8b': 'phi3:mini',
+        'qwen2.5-0.5b': 'qwen2.5:0.5b',
+        'qwen2.5-7b': 'qwen2.5:7b',
+        'deepseek-r1-1.5b': 'deepseek-r1:1.5b',
+        'deepseek-r1-7b': 'deepseek-r1:7b',
+        'deepseek-r1-8b': 'deepseek-r1:8b',
+        'deepseek-r1-14b': 'deepseek-r1:14b',
+        'deepseek-r1-32b': 'deepseek-r1:32b',
+        'deepseek-r1-70b': 'deepseek-r1:70b',
+        'deepseek-r1-671b': 'deepseek-r1:671b',
+    };
+    return modelMap[normalized] || normalized;
+}
+//# sourceMappingURL=ai.js.map