@thelapyae/geniclaw 1.1.11 → 1.2.2

package/bin/geniclaw.js

@@ -1,82 +1,139 @@
 #!/usr/bin/env node
-const { spawn, execSync } = require('child_process');
-const path = require('path');
+const { program } = require('commander');
 const fs = require('fs');
+const path = require('path');
 const os = require('os');
-const { program } = require('commander');
+const { spawn, execSync, fork } = require('child_process');
 const inquirer = require('inquirer');
-const https = require('https'); // For simple URL fetch if needed in TUI directly or via script
+const { ConfigManager } = require('../dist/config-manager');
 
-// Config Paths
+// Paths
 const LOCAL_DIR = path.join(process.cwd(), '.geniclaw');
 const GENICLAW_WORK_DIR = process.env.GENICLAW_WORK_DIR || (fs.existsSync(LOCAL_DIR) ? LOCAL_DIR : path.join(os.homedir(), '.geniclaw'));
 const CONFIG_FILE = path.join(GENICLAW_WORK_DIR, 'config.json');
 const SESSIONS_DIR = path.join(GENICLAW_WORK_DIR, 'sessions');
 const SKILLS_DIR = path.join(GENICLAW_WORK_DIR, 'skills');
+const { runDoctor } = require('../dist/doctor');
 
 const SCRIPT_PATH = path.join(__dirname, '../geniclaw.sh');
 
 // Helper to run shell script commands
 function runScript(args) {
-    const child = spawn(SCRIPT_PATH, args, {
-        stdio: 'inherit',
-        env: process.env
-    });
-    
-    return new Promise((resolve) => {
-        child.on('exit', (code) => {
-            resolve(code);
+    return new Promise((resolve, reject) => {
+        const child = spawn(SCRIPT_PATH, args, { stdio: 'inherit' });
+        child.on('close', (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`Script exited with code ${code}`));
         });
+        child.on('error', reject);
     });
 }
 
-// Load Config
+// Config Helpers
 function loadConfig() {
-    if (fs.existsSync(CONFIG_FILE)) {
-        try {
-            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-        } catch (e) {
-            return {};
-        }
-    }
-    return {};
+    return ConfigManager.load();
 }
 
-// Save Config
 function saveConfig(config) {
-    if (!fs.existsSync(GENICLAW_WORK_DIR)) {
-        fs.mkdirSync(GENICLAW_WORK_DIR, { recursive: true });
-    }
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+   ConfigManager.save(config);
+}
+
+// Ensure sessions dir exists
+if (!fs.existsSync(SESSIONS_DIR)) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+
+async function promptContinue() {
+    await inquirer.prompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
 
-// Helper: Get Skills
-function getSkills() {
+// Skill Management
+function listSkills() {
     if (!fs.existsSync(SKILLS_DIR)) return [];
     return fs.readdirSync(SKILLS_DIR)
         .filter(f => f.endsWith('.json'))
         .map(f => {
-            try { return JSON.parse(fs.readFileSync(path.join(SKILLS_DIR, f), 'utf8')); }
-            catch(e) { return null; }
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(SKILLS_DIR, f), 'utf8'));
+                return { name: data.name, filename: f, description: data.description };
+            } catch (e) { return null; }
         })
         .filter(s => s !== null);
 }
 
-// Helper: Install Skill
+async function manageSkills() {
+    const config = loadConfig();
+    const skills = listSkills();
+    const activeSkill = config.activeSkill || 'None';
+
+    console.clear();
+    console.log('🧠 Skill Manager');
+    console.log(`Active Skill: ${activeSkill}`);
+    console.log('----------------');
+
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Choose an action:',
+            choices: [
+                { name: 'Activate/Deactivate Skill', value: 'activate' },
+                { name: 'Install New Skill (URL)', value: 'install' },
+                { name: 'List Installed Skills', value: 'list' },
+                { name: 'Back', value: 'back' }
+            ]
+        }
+    ]);
+
+    if (action === 'back') return;
+
+    if (action === 'activate') {
+        const choices = [{ name: 'None (Disable Skills)', value: null }, ...skills.map(s => ({ name: `${s.name} - ${s.description}`, value: s.name }))];
+        const { skill } = await inquirer.prompt([
+            { type: 'list', name: 'skill', message: 'Select Skill to Activate:', choices }
+        ]);
+        config.activeSkill = skill; // null if None
+        saveConfig(config);
+        console.log(`✅ Active Skill set to: ${skill || 'None'}`);
+    }
+
+    if (action === 'install') {
+        const { url } = await inquirer.prompt([
+            { type: 'input', name: 'url', message: 'Enter Skill JSON URL:' }
+        ]);
+        try {
+            await installSkillFromUrl(url);
+            console.log('✅ Skill installed successfully.');
+        } catch (e) {
+            console.log(`❌ Error installing skill: ${e.message}`);
+        }
+    }
+
+    if (action === 'list') {
+        skills.forEach(s => console.log(`- ${s.name}: ${s.description}`));
+    }
+
+    await promptContinue();
+    return manageSkills();
+}
+
 async function installSkillFromUrl(url) {
+    // Simple fetch and save
+    // In a real app, use the SkillManager class from src/skill-manager.ts if possible, 
+    // but here we are in JS land (bin). 
+    // actually we can require the built JS from dist if needed, but let's keep it simple dependency-free if we can or use the one we have.
+    // The previous implementation used a fetch.
     return new Promise((resolve, reject) => {
+        const https = require('https');
         https.get(url, (res) => {
             let data = '';
             res.on('data', chunk => data += chunk);
             res.on('end', () => {
                 try {
                     const skill = JSON.parse(data);
-                    if (!skill.name || !skill.systemInstruction) {
-                        reject(new Error("Invalid skill JSON"));
-                        return;
-                    }
+                    if (!skill.name || !skill.prompts) throw new Error('Invalid Skill JSON');
                     if (!fs.existsSync(SKILLS_DIR)) fs.mkdirSync(SKILLS_DIR, { recursive: true });
-                    const safeName = skill.name.replace(/[^a-zA-Z0-9_-]/g, '_');
+                    const safeName = skill.name.replace(/[^a-z0-9]/gi, '_').toLowerCase();
                     fs.writeFileSync(path.join(SKILLS_DIR, `${safeName}.json`), JSON.stringify(skill, null, 2));
                     resolve(skill);
                 } catch(e) { reject(e); }
@@ -95,27 +152,35 @@ async function showMenu() {
     const config = loadConfig();
     const activeSession = config.activeSession || 'default';
     const activeSkill = config.activeSkill || 'None';
+    const activeProvider = config.activeProvider || 'gemini';
+
+    // Check if the ACTIVE provider has a key
+    const activeKeyField = `${activeProvider}ApiKey`;
+    const hasKey = config[activeKeyField] || process.env[activeKeyField.toUpperCase().replace(/([A-Z])/g, '_$1').toUpperCase()] || (activeProvider === 'gemini' && process.env.GEMINI_API_KEY);
 
-    if (!config.geminiApiKey) {
-        console.log('⚠️  Configuration Missing: No Gemini API Key found.');
+    if (!hasKey) {
+        console.log(`⚠️  Configuration Missing: No API Key found for active provider (${activeProvider}).`);
         const { runSetup } = await inquirer.prompt([
-            { type: 'confirm', name: 'runSetup', message: 'Would you like to run the setup wizard now?', default: true }
+            { type: 'confirm', name: 'runSetup', message: 'Would you like to configure keys now?', default: true }
         ]);
         
         if (runSetup) {
-            await runScript(['setup']);
-            await promptContinue();
+            // If they say yes, go to keys menu directly? Or setup? 
+            // Local setup script is gemini-focused. Let's send them to manageApiKey menu.
+            await manageApiKeys(activeProvider);
             return showMenu(); 
         }
     }
 
     // Show current status summary
     try {
-        console.log(`Current Model: ${config.geminiModel || 'Default'}`);
-        console.log(`Active Session: 📂 ${activeSession}`);
-        console.log(`Active Skill:   🧠 ${activeSkill}`);
-        if (config.geminiApiUrl) console.log(`API URL:        🔌 ${config.geminiApiUrl}`);
-        if (config.geminiGatewayKey) console.log(`Gateway Key:    🔑 Set`);
+        console.log(`Active Provider: ${config.activeProvider || 'gemini'} (${config.activeProvider === 'gemini' ? config.geminiModel : (config[config.activeProvider + 'Model'] || 'Default')})`);
+        console.log(`Active Session:  📂 ${activeSession}`);
+        console.log(`Active Skill:    🧠 ${activeSkill}`);
+        if (config.providerRouting && (config.providerRouting.chat !== config.activeProvider)) {
+             console.log(`Routing:         🔀 Custom`);
+        }
+        if (config.geminiApiUrl) console.log(`API URL:         🔌 ${config.geminiApiUrl}`);
     } catch (e) {}
     console.log('');
 
@@ -128,16 +193,22 @@ async function showMenu() {
                 { name: 'Start Daemon', value: 'start' },
                 { name: 'Stop Daemon', value: 'stop' },
                 { name: 'Restart Daemon', value: 'restart' },
-                { name: 'Check Status', value: 'status' },
                 { name: 'View Logs', value: 'logs' },
                 new inquirer.Separator(),
-                { name: '📂 Manage Sessions', value: 'sessions' },
+                { name: '🤖 Select AI Provider & Model', value: 'provider' },
+                { name: '🔑 Manage API Keys', value: 'keys' },
+                { name: '🔀 Task Routing (Chat/Heartbeat/Cron)', value: 'routing' },
+                { name: '🔎 Web Search Config', value: 'search' },
                 { name: '🧠 Manage Skills', value: 'skills' },
-                { name: '🤖 Change Gemini Model', value: 'model' },
-                { name: '🔌 Change API Base URL', value: 'apiUrl' },
+                { name: '📂 Switch Session', value: 'session' },
+                { name: '➕ Create New Session', value: 'new_session' },
+                { name: '🗑️ Delete Session', value: 'delete_session' },
+                new inquirer.Separator(),
+                { name: '🔌 Set Custom API URL', value: 'proxy' },
                 { name: '🔑 Set Gateway/Proxy Key', value: 'gatewayKey' },
                 new inquirer.Separator(),
                 { name: '✨ Update GeniClaw', value: 'update' },
+                { name: '🚑 Run Doctor (Fix Issues)', value: 'doctor' },
                 { name: 'Run Setup Wizard', value: 'setup' },
                 { name: 'Exit', value: 'exit' }
             ]
@@ -145,13 +216,20 @@ async function showMenu() {
     ]);
 
     if (action === 'exit') {
+        console.log('Bye! 👋');
         process.exit(0);
     }
-    
+
     if (action === 'update') {
         await performUpdate();
         return; // Exit after update to allow restart
     }
+
+    if (action === 'doctor') {
+        await runDoctor();
+        await promptContinue();
+        return showMenu();
+    }
     
     if (action === 'setup') {
         await runScript(['setup']);
@@ -159,125 +237,111 @@ async function showMenu() {
         return showMenu();
     }
 
-    if (action === 'model') {
-        await changeModel();
+    if (action === 'start' || action === 'stop' || action === 'restart') {
+        await runScript([action]);
         await promptContinue();
         return showMenu();
     }
 
-    if (action === 'apiUrl') {
-        await changeApiUrl();
+    if (action === 'logs') {
+        await runScript(['logs']);
         await promptContinue();
         return showMenu();
     }
 
-    if (action === 'gatewayKey') {
-        await changeGatewayKey();
-        await promptContinue();
+    if (action === 'session') {
+        await switchSession();
         return showMenu();
     }
 
-    if (action === 'sessions') {
-        await manageSessions();
+    if (action === 'new_session') {
+        await createSession();
         return showMenu();
     }
 
+    if (action === 'delete_session') {
+        await deleteSession();
+        return showMenu(); 
+    }
+
     if (action === 'skills') {
         await manageSkills();
         return showMenu();
     }
 
-    if (action === 'logs') {
-        await showLogsMenu();
+    if (action === 'provider') {
+        await selectProviderAndModel();
         return showMenu();
     }
 
-    // Process other actions via script
-    await runScript([action]);
-    await promptContinue();
-    return showMenu();
-}
+    if (action === 'keys') {
+        await manageApiKeys();
+        return showMenu();
+    }
 
-async function promptContinue() {
-    await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'continue',
-            message: 'Press Enter to continue...',
-        }
-    ]);
-}
+    if (action === 'routing') {
+        await manageTaskRouting();
+        return showMenu();
+    }
 
-async function changeModel() {
-    const config = loadConfig();
-    const currentModel = config.geminiModel || 'gemini-2.5-flash';
+    if (action === 'search') {
+        await configureWebSearch();
+        return showMenu();
+    }
 
-    const { model } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'model',
-            message: 'Select Gemini Model:',
-            default: currentModel,
-            choices: [
-                'gemini-2.5-flash',
-                'gemini-flash-lite-latest',
-                'gemini-2.5-pro',
-                'gemini-3-flash-preview',
-                'gemini-3-pro-preview',
-                new inquirer.Separator(),
-                { name: 'Custom (Enter manually)', value: 'custom' }
-            ]
-        }
-    ]);
+    if (action === 'proxy') {
+       await setCustomUrl();
+       return showMenu();
+    }
 
-    let selectedModel = model;
-    if (model === 'custom') {
-        const { customModel } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'customModel',
-                message: 'Enter model name:',
-                validate: input => input.length > 0
-            }
-        ]);
-        selectedModel = customModel;
+    if (action === 'gatewayKey') {
+       await setGatewayKey();
+       return showMenu();
     }
+}
 
-    config.geminiModel = selectedModel;
-    saveConfig(config);
-    console.log(`✅ Model updated to: ${selectedModel}`);
-    console.log('Note: You may need to restart the daemon for changes to take effect.');
+async function performUpdate() {
+    console.log('Checking for updates...');
+    try {
+        const updateCmd = spawn('npm', ['install', '-g', '@thelapyae/geniclaw@latest'], { stdio: 'inherit' });
+        updateCmd.on('close', (code) => {
+             if (code === 0) {
+                 console.log('✅ Update successful! Please restart GeniClaw.');
+                 process.exit(0);
+             } else {
+                 console.log('❌ Update failed.');
+             }
+        });
+    } catch (e) {
+        console.log('❌ Error updating: ' + e.message);
+    }
 }
 
-async function changeApiUrl() {
+async function setCustomUrl() {
     const config = loadConfig();
     const currentUrl = config.geminiApiUrl || 'Default (Google)';
-
+    
     const { url } = await inquirer.prompt([
         {
             type: 'input',
             name: 'url',
             message: `Enter Custom API Base URL (Current: ${currentUrl}):`,
-            suffix: '\n(Leave empty to reset to default Google API)',
+            suffix: '\n(Leave empty to reset to default)',
         }
     ]);
 
-    if (!url || url.trim() === '') {
-        delete config.geminiApiUrl;
-        console.log('✅ Reset to default Google API URL.');
-    } else {
-        // Basic validation
-        if (!url.startsWith('http')) {
-            console.log('⚠️  URL should start with http:// or https://');
-        }
+    if (url && url.trim() !== '') {
         config.geminiApiUrl = url.trim();
-        console.log(`✅ API URL updated to: ${config.geminiApiUrl}`);
+        console.log(`✅ API URL set to: ${url}`);
+    } else {
+        delete config.geminiApiUrl;
+        console.log('✅ API URL reset to default.');
     }
     saveConfig(config);
-    console.log('Note: Restart daemon to apply changes.');
+    await promptContinue();
 }
 
-async function changeGatewayKey() {
+async function setGatewayKey() {
     const config = loadConfig();
     const currentKey = config.geminiGatewayKey ? '********' : 'Not Set';
 
@@ -285,308 +349,398 @@ async function changeGatewayKey() {
         {
             type: 'password',
             name: 'key',
-            message: `Enter Gateway API Key (Current: ${currentKey}):`,
-            suffix: '\n(Leave empty to remove key)',
+            message: `Enter Gateway/Proxy Auth Key (Current: ${currentKey}):`,
+            suffix: '\n(Leave empty to remove/keep)',
             mask: '*'
         }
     ]);
 
-    if (!key || key.trim() === '') {
-        delete config.geminiGatewayKey;
-        console.log('✅ Gateway Key removed.');
-    } else {
+    if (key && key.trim() !== '') {
         config.geminiGatewayKey = key.trim();
+        saveConfig(config);
         console.log('✅ Gateway Key updated.');
+    } else if (key === '') {
+        // Ask if remove? Na, empty usually means keep or skip. 
+        // Let's add specific logic: if empty, do nothing. 
+        // If they want to clear, they might need a clear option. 
+        // For CLI simplicity, let's keep it as is.
+        console.log('No change.');
     }
-    saveConfig(config);
-    console.log('Note: Restart daemon to apply changes.');
+    await promptContinue();
 }
 
-async function manageSessions() {
+async function selectProviderAndModel() {
     const config = loadConfig();
-    const activeSession = config.activeSession || 'default';
-    const sessions = fs.existsSync(SESSIONS_DIR) 
-        ? fs.readdirSync(SESSIONS_DIR).filter(file => fs.statSync(path.join(SESSIONS_DIR, file)).isDirectory())
-        : ['default'];
+    let provider = config.activeProvider || 'gemini';
 
-    const { action } = await inquirer.prompt([
+    // 1. Select Provider
+    const { newProvider } = await inquirer.prompt([
         {
             type: 'list',
-            name: 'action',
-            message: `Manage Sessions (Active: ${activeSession})`,
+            name: 'newProvider',
+            message: 'Select Active AI Provider:',
+            default: provider,
             choices: [
-                { name: 'Switch Session', value: 'switch' },
-                { name: 'Create New Session', value: 'create' },
-                { name: 'Delete Session', value: 'delete' },
+                { name: 'Google Gemini', value: 'gemini' },
+                { name: 'OpenAI', value: 'openai' },
+                { name: 'Anthropic', value: 'anthropic' },
+                { name: 'Groq', value: 'groq' },
+                { name: 'Deepseek', value: 'deepseek' },
+                { name: 'xAI (Grok)', value: 'grok' },
                 { name: 'Back', value: 'back' }
             ]
         }
     ]);
 
-    if (action === 'back') return;
-
-    if (action === 'switch') {
-        const { session } = await inquirer.prompt([
+    if (newProvider === 'back') return;
+    config.activeProvider = newProvider;
+    saveConfig(config);
+    console.log(`✅ Active Provider set to: ${newProvider}`);
+    
+    // 2. Select Model for that Provider
+    if (newProvider === 'gemini') {
+        const { model } = await inquirer.prompt([
             {
                 type: 'list',
-                name: 'session',
-                message: 'Select session to switch to:',
-                choices: sessions.map(s => s === activeSession ? { name: `${s} (active)`, value: s } : s)
+                name: 'model',
+                message: 'Select Gemini Model:',
+                default: config.geminiModel,
+                choices: [
+                    { name: 'Gemini 3 Pro Preview', value: 'gemini-3-pro-preview' },
+                    { name: 'Gemini 3 Flash Preview', value: 'gemini-3-flash-preview' },
+                    { name: 'Gemini 2.5 Pro', value: 'gemini-2.5-pro' },
+                    { name: 'Gemini 2.5 Flash', value: 'gemini-2.5-flash' },
+                    { name: 'Gemini 2.5 Flash Lite', value: 'gemini-2.5-flash-lite' }
+                ]
             }
         ]);
-
-        if (session !== activeSession) {
-            config.activeSession = session;
-            saveConfig(config);
-            console.log(`✅ Switched to session: ${session}`);
-        } else {
-            console.log('Already on this session.');
-        }
-    }
-
-    if (action === 'create') {
-        const { name } = await inquirer.prompt([
+        config.geminiModel = model;
+    } else if (newProvider === 'openai') {
+        const { model } = await inquirer.prompt([
             {
-                type: 'input',
-                name: 'name',
-                message: 'Enter new session name (alphanumeric):',
-                validate: input => /^[a-zA-Z0-9_-]+$/.test(input) ? true : 'Invalid name.'
+                type: 'list',
+                name: 'model',
+                message: 'Select OpenAI Model:',
+                default: config.openaiModel,
+                choices: [
+                    { name: 'GPT-5.3 Codex (Best for Code)', value: 'gpt-5.3-codex' },
+                    { name: 'GPT-5.2 Pro', value: 'gpt-5.2-pro' },
+                    { name: 'GPT-5.2', value: 'gpt-5.2' },
+                    { name: 'GPT-4.1 Nano', value: 'gpt-4.1-nano' },
+                    { name: 'OpenAI o3-mini', value: 'o3-mini' }
+                ]
             }
         ]);
-
-        const sessionPath = path.join(SESSIONS_DIR, name);
-        if (fs.existsSync(sessionPath)) {
-            console.log('❌ Session already exists.');
-        } else {
-            fs.mkdirSync(sessionPath, { recursive: true });
-            console.log(`✅ Session '${name}' created.`);
-            const { switchTo } = await inquirer.prompt([
-                { type: 'confirm', name: 'switchTo', message: 'Switch to this session now?', default: true }
-            ]);
-            if (switchTo) {
-                config.activeSession = name;
-                saveConfig(config);
+        config.openaiModel = model;
+    } else if (newProvider === 'anthropic') {
+         const { model } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select Claude Model:',
+                default: config.anthropicModel,
+                choices: [
+                    { name: 'Claude Opus 4.6', value: 'claude-opus-4.6' },
+                    { name: 'Claude Sonnet 4.5', value: 'claude-sonnet-4.5' },
+                    { name: 'Claude Haiku 4.5', value: 'claude-haiku-4.5' }
+                ]
             }
-        }
+        ]);
+        config.anthropicModel = model;
+    } else if (newProvider === 'groq') {
+         const { model } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select Groq Model:',
+                default: config.groqModel,
+                choices: [
+                    { name: 'Llama 3.3 70B Versatile', value: 'llama-3.3-70b-versatile' },
+                    { name: 'Llama 3.1 8B Instant', value: 'llama-3.1-8b-instant' },
+                    { name: 'OpenAI GPT-OSS 120B', value: 'openai/gpt-oss-120b' },
+                    { name: 'Mixtral 8x7B', value: 'mixtral-8x7b-32768' }
+                ]
+            }
+        ]);
+        config.groqModel = model;
+    } else if (newProvider === 'deepseek') {
+         const { model } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select DeepSeek Model:',
+                default: config.deepseekModel,
+                choices: [
+                    { name: 'DeepSeek V3 (General)', value: 'deepseek-chat' },
+                    { name: 'DeepSeek R1 (Reasoning)', value: 'deepseek-reasoner' },
+                    { name: 'DeepSeek Coder V3', value: 'deepseek-coder' }
+                ]
+            }
+        ]);
+        config.deepseekModel = model;
+    } else if (newProvider === 'grok') {
+         const { model } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select Grok Model:',
+                default: config.grokModel,
+                choices: [
+                    { name: 'Grok 4', value: 'grok-4' },
+                    { name: 'Grok 4.1 Fast', value: 'grok-4-1-fast' },
+                    { name: 'Grok 3', value: 'grok-3' },
+                    { name: 'Grok 2', value: 'grok-2-1212' }
+                ]
+            }
+        ]);
+        config.grokModel = model;
     }
 
-    if (action === 'delete') {
-         const { session } = await inquirer.prompt([
+    saveConfig(config);
+    console.log(`✅ Model set to: ${config[newProvider + 'Model'] || config.geminiModel}`);
+    await promptContinue();
+}
+
+
+async function manageApiKeys(targetProvider = null) {
+    const config = loadConfig();
+    let provider = targetProvider;
+
+    if (!provider) {
+        const result = await inquirer.prompt([
             {
                 type: 'list',
-                name: 'session',
-                message: 'Select session to delete:',
-                choices: sessions.filter(s => s !== 'default' && s !== activeSession)
+                name: 'provider',
+                message: 'Select Provider to set API Key:',
+                choices: [
+                    { name: 'Google Gemini', value: 'gemini' },
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'Groq', value: 'groq' },
+                    { name: 'Deepseek', value: 'deepseek' },
+                    { name: 'xAI (Grok)', value: 'grok' },
+                    { name: 'Brave Search', value: 'brave' },
+                    { name: 'Back', value: 'back' }
+                ]
             }
         ]);
-        if (session) {
-             const { confirm } = await inquirer.prompt([
-                { type: 'confirm', name: 'confirm', message: `Delete '${session}' permanently?`, default: false }
-            ]);
-            if (confirm) {
-                fs.rmSync(path.join(SESSIONS_DIR, session), { recursive: true, force: true });
-                console.log(`🗑️ Session deleted.`);
-            }
+        if (result.provider === 'back') return;
+        provider = result.provider;
+    }
+
+    const keyField = `${provider}ApiKey`;
+    const currentKey = config[keyField] ? '********' : 'Not Set';
+    
+    const { key } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'key',
+            message: `Enter API Key for ${provider} (Current: ${currentKey}):`,
+            suffix: '\n(Leave empty to keep current)',
+            mask: '*'
         }
+    ]);
+
+    if (key && key.trim() !== '') {
+        config[keyField] = key.trim();
+        saveConfig(config);
+        console.log(`✅ API Key for ${provider} updated.`);
+    } else {
+        console.log('No change.');
     }
-    return manageSessions();
+    
+    if (!targetProvider) await promptContinue();
 }
 
-async function manageSkills() {
+async function manageTaskRouting() {
     const config = loadConfig();
-    const activeSkill = config.activeSkill || 'None';
-    const skills = getSkills();
-
-    const { action } = await inquirer.prompt([
+    const routing = config.providerRouting || { chat: 'gemini', heartbeat: 'gemini', cron: 'gemini' };
+    
+    const { task } = await inquirer.prompt([
         {
             type: 'list',
-            name: 'action',
-            message: `Manage Skills (Active: ${activeSkill})`,
+            name: 'task',
+            message: 'Select Task to Route:',
             choices: [
-                { name: 'Acivate/Deactivate Skill', value: 'activate' },
-                { name: 'Install Skill (from URL)', value: 'install' },
-                { name: 'Create New Skill', value: 'create' },
-                { name: 'List Installed Skills', value: 'list' },
-                { name: 'Delete Skill', value: 'delete' },
+                { name: `Chat (Current: ${routing.chat || 'default'})`, value: 'chat' },
+                { name: `Heartbeat (Current: ${routing.heartbeat || 'default'})`, value: 'heartbeat' },
+                { name: `Cron Jobs (Current: ${routing.cron || 'default'})`, value: 'cron' },
                 { name: 'Back', value: 'back' }
             ]
         }
     ]);
 
-    if (action === 'back') return;
+    if (task === 'back') return;
 
-    if (action === 'activate') {
-        const choices = [
-            { name: 'None (Deactivate)', value: null },
-            new inquirer.Separator(),
-            ...skills.map(s => ({ name: s.name, value: s.name }))
-        ];
-        const { skill } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'skill',
-                message: 'Select skill to activate:',
-                choices: choices,
-                default: activeSkill === 'None' ? null : activeSkill
-            }
-        ]);
+    const { provider } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'provider',
+            message: `Select Provider for ${task}:`,
+            choices: [
+                { name: 'Use Active Provider (Default)', value: null },
+                new inquirer.Separator(),
+                { name: 'Google Gemini', value: 'gemini' },
+                { name: 'OpenAI', value: 'openai' },
+                { name: 'Anthropic', value: 'anthropic' },
+                { name: 'Groq', value: 'groq' },
+                { name: 'Deepseek', value: 'deepseek' },
+                { name: 'xAI (Grok)', value: 'grok' }
+            ]
+        }
+    ]);
 
-        config.activeSkill = skill;
-        saveConfig(config);
-        console.log(skill ? `✅ Activated skill: ${skill}` : `✅ Skill deactivated.`);
+    if (provider) {
+        routing[task] = provider;
+    } else {
+        delete routing[task];
     }
+    
+    config.providerRouting = routing;
+    saveConfig(config);
+    console.log(`✅ Routing updated.`);
+    
+    return manageTaskRouting(); 
+}
 
-    if (action === 'install') {
-        const { url } = await inquirer.prompt([
-            { type: 'input', name: 'url', message: 'Enter Skill JSON URL:' }
-        ]);
-        try {
-            console.log('Downloading...');
-            const skill = await installSkillFromUrl(url);
-            console.log(`✅ Installed skill: ${skill.name}`);
-            const { activate } = await inquirer.prompt([
-                { type: 'confirm', name: 'activate', message: 'Activate this skill now?', default: true }
-            ]);
-            if (activate) {
-                config.activeSkill = skill.name;
-                saveConfig(config);
-            }
-        } catch(e) {
-            console.log(`❌ Failed: ${e.message}`);
+async function configureWebSearch() {
+    const config = loadConfig();
+    const currentKey = config.braveApiKey ? '********' : 'Not Set';
+    
+    console.log('configured Web Search uses Brave Search API.');
+    console.log('Get a free key at: https://brave.com/search/api/');
+    
+    const { key } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'key',
+            message: `Enter Brave Search API Key (Current: ${currentKey}):`,
+            suffix: '\n(Leave empty to remove/keep)',
+            mask: '*'
         }
+    ]);
+    
+    if (key && key.trim() !== '') {
+        config.braveApiKey = key.trim();
+        saveConfig(config);
+        console.log('✅ Brave API Key set.');
+    } else if (key === '') {
+        // do nothing
+        console.log('No change.');
+    } else {
+        // e.g. space to clear? For now TUI doesn't support clear easily.
     }
+    await promptContinue();
+}
 
-    if (action === 'create') {
-        // Simple creation wizard
-        const answers = await inquirer.prompt([
-            { type: 'input', name: 'name', message: 'Skill Name:', validate: i => /^[a-z0-9_-]+$/.test(i) },
-            { type: 'input', name: 'description', message: 'Description:' },
-            { type: 'editor', name: 'instruction', message: 'System Instruction (Persona):' }
-        ]);
-        
-        const skill = {
-            name: answers.name,
-            version: "1.0.0",
-            description: answers.description,
-            author: "local",
-            systemInstruction: answers.instruction,
-            examples: []
-        };
-        
-        if (!fs.existsSync(SKILLS_DIR)) fs.mkdirSync(SKILLS_DIR, { recursive: true });
-        fs.writeFileSync(path.join(SKILLS_DIR, `${skill.name}.json`), JSON.stringify(skill, null, 2));
-        console.log(`✅ Skill '${skill.name}' created.`);
-    }
 
-    if (action === 'list') {
-        console.log('\nInstalled Skills:');
-        skills.forEach(s => {
-            console.log(`- ${s.name}: ${s.description} (${s.active ? 'ACTIVE' : ''})`);
-        });
-        await promptContinue();
-    }
-    
-    if (action === 'delete') {
-        const { skill } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'skill',
-                message: 'Select skill to delete:',
-                choices: skills.map(s => ({ name: s.name, value: s.name}))
-            }
+// --- Main Logic ---
+
+function switchSession() {
+    const sessions = fs.readdirSync(SESSIONS_DIR).filter(f => fs.statSync(path.join(SESSIONS_DIR, f)).isDirectory());
+    const config = loadConfig();
+    const activeSession = config.activeSession || 'default';
+
+    return inquirer.prompt([
+        {
+            type: 'list',
+            name: 'session',
+            message: 'Select Session:',
+            choices: sessions.map(s => ({ name: s === activeSession ? `${s} (Active)` : s, value: s })).concat([{ name: 'Back', value: 'back' }])
+        }
+    ]).then(answer => {
+        if (answer.session === 'back') return;
+        config.activeSession = answer.session;
+        saveConfig(config);
+        console.log(`Switched to session: ${answer.session}`);
+    });
+}
+
+async function createSession() {
+    const config = loadConfig();
+    const { name } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Enter new session name (alphanumeric):',
+            validate: input => /^[a-zA-Z0-9_-]+$/.test(input) ? true : 'Invalid name.'
+        }
+    ]);
+
+    const sessionPath = path.join(SESSIONS_DIR, name);
+    if (fs.existsSync(sessionPath)) {
+        console.log('❌ Session already exists.');
+    } else {
+        fs.mkdirSync(sessionPath, { recursive: true });
+        console.log(`✅ Session '${name}' created.`);
+        const { switchTo } = await inquirer.prompt([
+            { type: 'confirm', name: 'switchTo', message: 'Switch to this session now?', default: true }
         ]);
-        if (skill) {
-             const { confirm } = await inquirer.prompt([
-                { type: 'confirm', name: 'confirm', message: `Delete '${skill}'?`, default: false }
-            ]);
-            if (confirm) {
-                fs.unlinkSync(path.join(SKILLS_DIR, `${skill}.json`));
-                if (config.activeSkill === skill) {
-                    delete config.activeSkill;
-                    saveConfig(config);
-                }
-                console.log(`🗑️ Skill deleted.`);
-            }
+        if (switchTo) {
+            config.activeSession = name;
+            saveConfig(config);
         }
     }
-
-    return manageSkills();
 }
 
-async function showLogsMenu() {
-    const { logType } = await inquirer.prompt([
+async function deleteSession() {
+     const config = loadConfig();
+     const activeSession = config.activeSession || 'default';
+     const sessions = fs.readdirSync(SESSIONS_DIR).filter(f => fs.statSync(path.join(SESSIONS_DIR, f)).isDirectory());
+     
+     const { session } = await inquirer.prompt([
         {
             type: 'list',
-            name: 'logType',
-            message: 'Which logs to view?',
-            choices: [
-                { name: 'Telegram', value: 'telegram' },
-                { name: 'Queue Processor', value: 'queue' },
-                { name: 'Daemon', value: 'daemon' },
-                { name: 'Back', value: 'back' }
-            ]
+            name: 'session',
+            message: 'Select session to delete:',
+            choices: sessions.filter(s => s !== 'default' && s !== activeSession).concat([{ name: 'Cancel', value: 'cancel' }])
         }
     ]);
 
-    if (logType === 'back') return;
-
-    console.log('Press Ctrl+C to exit logs.');
-    await runScript(['logs', logType]);
-}
-
-async function performUpdate() {
-    console.log('🔄 Checking for updates and installing latest version...');
-    console.log('📦 Running: npm install -g @thelapyae/geniclaw@latest');
+    if (session === 'cancel') return;
     
-    try {
-        execSync('npm install -g @thelapyae/geniclaw@latest', { stdio: 'inherit' });
-        console.log('\n✅ Update completed! Please restart geniclaw.');
-        process.exit(0);
-    } catch (error) {
-        console.error('\n❌ Update failed.');
-        console.error('Error details:', error.message);
-        console.log('Try running with sudo: sudo geniclaw update');
-        
-        const { trySudo } = await inquirer.prompt([
-            { type: 'confirm', name: 'trySudo', message: 'Try again with sudo?', default: false }
-        ]);
-        
-        if (trySudo) {
-            try {
-                execSync('sudo npm install -g @thelapyae/geniclaw@latest', { stdio: 'inherit' });
-                console.log('\n✅ Update completed! Please restart geniclaw.');
-                process.exit(0);
-            } catch (e) {
-                console.error('\n❌ Sudo update also failed.');
-            }
-        }
+    // confirm
+    const { confirm } = await inquirer.prompt([
+        { type: 'confirm', name: 'confirm', message: `Are you sure you want to delete '${session}' and all its history?`, default: false }
+    ]);
+
+    if (confirm) {
+        fs.rmSync(path.join(SESSIONS_DIR, session), { recursive: true, force: true });
+        console.log(`🗑️ Session '${session}' deleted.`);
     }
 }
 
 
-// CLI Configuration
-const packageJson = require('../package.json');
+// CLI Args Handling
 program
-    .version(packageJson.version)
-    .description('GeniClaw Management CLI')
-    .arguments('[command]')
-    .action(async (command) => {
+    .version(require('../package.json').version)
+    .argument('[command]', 'Command to run (start, stop, logs, etc)')
+    .argument('[args...]', 'Arguments for the command')
+    .action(async (command, args) => {
         if (!command) {
-            // No args -> TUI Mode
             await showMenu();
         } else {
-            if (command === 'model') {
-                 await changeModel();
-            } else if (command === 'sessions') {
-                 await manageSessions();
-            } else if (command === 'skills') {
-                 await manageSkills();
-            } else if (command === 'update') {
-                 await performUpdate();
-            } else {
-                 const args = process.argv.slice(2); 
-                 await runScript(args);
-            }
+             if (command === 'provider') {
+                  await selectProviderAndModel();
+             } else if (command === 'keys') {
+                  await manageApiKeys();
+             } else if (command === 'routing') {
+                  await manageTaskRouting();
+             } else if (command === 'search') {
+                  await configureWebSearch();
+             } else if (command === 'services') {
+                  // Not implemented directly yet, maybe mapping to start/stop?
+                  // Just fall through to script for now
+                  await runScript(args);
+             } else if (command === 'doctor') {
+                  await runDoctor();
+             } else if (command === 'update') {
+                  await performUpdate();
+             } else {
+                  // Pass through to shell script
+                  const allArgs = [command, ...args];
+                  await runScript(allArgs);
+             }
         }
     });