@mmmbuto/nexuscli 0.5.0

package/lib/cli/config.js

@@ -0,0 +1,185 @@
+/**
+ * nexuscli config - Manage configuration
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+const {
+  isInitialized,
+  getConfig,
+  getConfigValue,
+  setConfigValue,
+  getConfigKeys
+} = require('../config/manager');
+const { PATHS } = require('../utils/paths');
+
+/**
+ * List all config values
+ */
+function listConfig() {
+  const keys = getConfigKeys();
+  const maxKeyLen = Math.max(...keys.map(k => k.length));
+
+  console.log(chalk.cyan('Configuration:'));
+  console.log(chalk.gray(`  File: ${PATHS.CONFIG_FILE}`));
+  console.log('');
+
+  for (const key of keys) {
+    const value = getConfigValue(key);
+    const displayValue = formatValue(value);
+    console.log(`  ${chalk.white(key.padEnd(maxKeyLen))}  ${displayValue}`);
+  }
+}
+
+/**
+ * Format a value for display
+ */
+function formatValue(value) {
+  if (value === null || value === undefined) {
+    return chalk.gray('null');
+  }
+  if (typeof value === 'boolean') {
+    return value ? chalk.green('true') : chalk.red('false');
+  }
+  if (typeof value === 'number') {
+    return chalk.yellow(String(value));
+  }
+  if (Array.isArray(value)) {
+    return chalk.cyan(JSON.stringify(value));
+  }
+  if (typeof value === 'string') {
+    // Hide sensitive values
+    if (value.length > 20 && (value.includes('-') || value.includes('$'))) {
+      return chalk.gray('***hidden***');
+    }
+    return chalk.white(value);
+  }
+  return chalk.gray(String(value));
+}
+
+/**
+ * Main config command
+ */
+async function config(action, key, value) {
+  console.log('');
+
+  if (!isInitialized()) {
+    console.log(chalk.yellow('NexusCLI is not configured.'));
+    console.log(`Run ${chalk.cyan('nexuscli init')} first.`);
+    console.log('');
+    return;
+  }
+
+  // No action = list all
+  if (!action || action === 'list') {
+    listConfig();
+    console.log('');
+    return;
+  }
+
+  // Get value
+  if (action === 'get') {
+    if (!key) {
+      console.log(chalk.red('Usage: nexuscli config get <key>'));
+      console.log('');
+      return;
+    }
+
+    const val = getConfigValue(key);
+    if (val === undefined) {
+      console.log(chalk.yellow(`Key not found: ${key}`));
+    } else {
+      console.log(formatValue(val));
+    }
+    console.log('');
+    return;
+  }
+
+  // Set value
+  if (action === 'set') {
+    if (!key || value === undefined) {
+      console.log(chalk.red('Usage: nexuscli config set <key> <value>'));
+      console.log('');
+      return;
+    }
+
+    // Confirm sensitive changes
+    const sensitiveKeys = ['auth.jwt_secret', 'auth.pass_hash'];
+    if (sensitiveKeys.includes(key)) {
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Changing ${key} may break authentication. Continue?`,
+        default: false
+      }]);
+
+      if (!confirm) {
+        console.log(chalk.yellow('Cancelled.'));
+        console.log('');
+        return;
+      }
+    }
+
+    if (setConfigValue(key, value)) {
+      console.log(chalk.green(`  ✓ ${key} = ${value}`));
+    } else {
+      console.log(chalk.red(`  ✗ Failed to set ${key}`));
+    }
+    console.log('');
+    return;
+  }
+
+  // Interactive editor
+  if (action === 'edit') {
+    const currentConfig = getConfig();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'number',
+        name: 'port',
+        message: 'Server port:',
+        default: currentConfig.server.port
+      },
+      {
+        type: 'list',
+        name: 'claudeModel',
+        message: 'Claude default model:',
+        choices: ['haiku', 'sonnet', 'opus'],
+        default: currentConfig.engines?.claude?.model || 'sonnet'
+      },
+      {
+        type: 'confirm',
+        name: 'wakeLock',
+        message: 'Enable wake-lock?',
+        default: currentConfig.termux?.wake_lock ?? true
+      },
+      {
+        type: 'confirm',
+        name: 'notifications',
+        message: 'Enable notifications?',
+        default: currentConfig.termux?.notifications ?? true
+      }
+    ]);
+
+    setConfigValue('server.port', answers.port);
+    setConfigValue('engines.claude.model', answers.claudeModel);
+    setConfigValue('termux.wake_lock', answers.wakeLock);
+    setConfigValue('termux.notifications', answers.notifications);
+
+    console.log(chalk.green('  ✓ Configuration updated'));
+    console.log('');
+    return;
+  }
+
+  // Unknown action
+  console.log(chalk.red(`Unknown action: ${action}`));
+  console.log('Usage:');
+  console.log('  nexuscli config           List all');
+  console.log('  nexuscli config get <k>   Get value');
+  console.log('  nexuscli config set <k> <v>  Set value');
+  console.log('  nexuscli config edit      Interactive editor');
+  console.log('');
+}
+
+module.exports = config;

package/lib/cli/engines.js

@@ -0,0 +1,257 @@
+/**
+ * nexuscli engines - Manage AI engines
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const { isInitialized, getConfig, setConfigValue } = require('../config/manager');
+const { HOME } = require('../utils/paths');
+
+/**
+ * Detect available engines (TRI CLI v0.4.0)
+ */
+function detectEngines() {
+  const engines = {
+    claude: { available: false, path: null, version: null },
+    codex: { available: false, path: null, version: null },
+    gemini: { available: false, path: null, version: null }
+  };
+
+  // Claude
+  try {
+    const claudePath = execSync('which claude 2>/dev/null', { encoding: 'utf8' }).trim();
+    const claudeVersion = execSync('claude --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+    engines.claude = { available: true, path: claudePath, version: claudeVersion };
+  } catch {}
+
+  // Codex
+  try {
+    const codexPath = execSync('which codex 2>/dev/null', { encoding: 'utf8' }).trim();
+    const codexVersion = execSync('codex --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+    engines.codex = { available: true, path: codexPath, version: codexVersion };
+  } catch {}
+
+  // Gemini
+  try {
+    const geminiPath = execSync('which gemini 2>/dev/null', { encoding: 'utf8' }).trim();
+    const geminiVersion = execSync('gemini --version 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+    engines.gemini = { available: true, path: geminiPath, version: geminiVersion };
+  } catch {}
+
+  return engines;
+}
+
+/**
+ * List engines status (TRI CLI v0.4.0)
+ */
+function listEngines() {
+  const config = getConfig();
+  const detected = detectEngines();
+
+  console.log(chalk.bold('╔═══════════════════════════════════════════╗'));
+  console.log(chalk.bold('║  AI Engines (TRI CLI)                     ║'));
+  console.log(chalk.bold('╠═══════════════════════════════════════════╣'));
+
+  // Claude
+  const claudeEnabled = config.engines?.claude?.enabled !== false;
+  const claudeModel = config.engines?.claude?.model || 'sonnet';
+  if (detected.claude.available) {
+    const status = claudeEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(chalk.bold(`║  Claude:  ${status} (${claudeModel})`));
+    console.log(chalk.gray(`║           ${detected.claude.version}`));
+  } else {
+    console.log(chalk.bold(`║  Claude:  ${chalk.red('✗ not installed')}`));
+  }
+
+  // Codex
+  const codexEnabled = config.engines?.codex?.enabled === true;
+  if (detected.codex.available) {
+    const status = codexEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(chalk.bold(`║  Codex:   ${status}`));
+    console.log(chalk.gray(`║           ${detected.codex.version}`));
+  } else {
+    console.log(chalk.bold(`║  Codex:   ${chalk.gray('○ not installed')}`));
+  }
+
+  // Gemini
+  const geminiEnabled = config.engines?.gemini?.enabled === true;
+  if (detected.gemini.available) {
+    const status = geminiEnabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(chalk.bold(`║  Gemini:  ${status}`));
+    console.log(chalk.gray(`║           ${detected.gemini.version}`));
+  } else {
+    console.log(chalk.bold(`║  Gemini:  ${chalk.gray('○ not installed')}`));
+  }
+
+  console.log(chalk.bold('╚═══════════════════════════════════════════╝'));
+}
+
+/**
+ * Test an engine
+ */
+async function testEngine(engine) {
+  console.log(chalk.cyan(`Testing ${engine}...`));
+
+  if (engine === 'claude') {
+    try {
+      execSync('claude --version', { stdio: 'inherit' });
+      console.log(chalk.green(`  ✓ Claude CLI is working`));
+      return true;
+    } catch {
+      console.log(chalk.red(`  ✗ Claude CLI failed`));
+      return false;
+    }
+  }
+
+  if (engine === 'codex') {
+    try {
+      execSync('codex --version', { stdio: 'inherit' });
+      console.log(chalk.green(`  ✓ Codex CLI is working`));
+      return true;
+    } catch {
+      console.log(chalk.red(`  ✗ Codex CLI not found`));
+      return false;
+    }
+  }
+
+  if (engine === 'gemini') {
+    try {
+      execSync('gemini --version', { stdio: 'inherit' });
+      console.log(chalk.green(`  ✓ Gemini CLI is working`));
+      return true;
+    } catch {
+      console.log(chalk.red(`  ✗ Gemini CLI not found`));
+      return false;
+    }
+  }
+
+  console.log(chalk.yellow(`  Engine ${engine} not testable`));
+  return false;
+}
+
+/**
+ * Add/configure an engine (TRI CLI v0.4.0)
+ */
+async function addEngine() {
+  const detected = detectEngines();
+
+  const choices = [];
+  if (detected.claude.available) {
+    choices.push({ name: `Claude (${detected.claude.version})`, value: 'claude' });
+  }
+  if (detected.codex.available) {
+    choices.push({ name: `Codex (${detected.codex.version})`, value: 'codex' });
+  }
+  if (detected.gemini.available) {
+    choices.push({ name: `Gemini (${detected.gemini.version})`, value: 'gemini' });
+  }
+
+  if (choices.length === 0) {
+    console.log(chalk.yellow('  No AI engines detected.'));
+    console.log(chalk.gray('  Install: claude, codex, or gemini CLI'));
+    return;
+  }
+
+  const { engine } = await inquirer.prompt([{
+    type: 'list',
+    name: 'engine',
+    message: 'Select engine to configure:',
+    choices
+  }]);
+
+  if (engine === 'claude') {
+    const { model } = await inquirer.prompt([{
+      type: 'list',
+      name: 'model',
+      message: 'Default Claude model:',
+      choices: [
+        { name: 'Haiku 4.5 (Fast)', value: 'haiku' },
+        { name: 'Sonnet 4.5 (Balanced)', value: 'sonnet' },
+        { name: 'Opus 4.5 (Most Intelligent)', value: 'opus' }
+      ],
+      default: 'sonnet'
+    }]);
+
+    setConfigValue('engines.claude.enabled', true);
+    setConfigValue('engines.claude.model', model);
+    console.log(chalk.green(`  ✓ Claude configured (${model})`));
+  }
+
+  if (engine === 'codex') {
+    const { model } = await inquirer.prompt([{
+      type: 'list',
+      name: 'model',
+      message: 'Default Codex model:',
+      choices: [
+        { name: 'GPT-5.1 Codex Max (Best)', value: 'gpt-5.1-codex-max' },
+        { name: 'GPT-5.1 Codex', value: 'gpt-5.1-codex' },
+        { name: 'GPT-5.1 Codex Mini (Fast)', value: 'gpt-5.1-codex-mini' },
+        { name: 'GPT-5.1 (General)', value: 'gpt-5.1' }
+      ],
+      default: 'gpt-5.1-codex-max'
+    }]);
+
+    setConfigValue('engines.codex.enabled', true);
+    setConfigValue('engines.codex.model', model);
+    console.log(chalk.green(`  ✓ Codex configured (${model})`));
+  }
+
+  if (engine === 'gemini') {
+    setConfigValue('engines.gemini.enabled', true);
+    setConfigValue('engines.gemini.model', 'gemini-3-pro-preview');
+    console.log(chalk.green(`  ✓ Gemini configured (gemini-3-pro-preview)`));
+  }
+}
+
+/**
+ * Main engines command
+ */
+async function engines(action) {
+  console.log('');
+
+  if (!isInitialized()) {
+    console.log(chalk.yellow('NexusCLI is not configured.'));
+    console.log(`Run ${chalk.cyan('nexuscli init')} first.`);
+    console.log('');
+    return;
+  }
+
+  // No action = list
+  if (!action || action === 'list') {
+    listEngines();
+    console.log('');
+    return;
+  }
+
+  // Add engine
+  if (action === 'add') {
+    await addEngine();
+    console.log('');
+    return;
+  }
+
+  // Test engine
+  if (action === 'test') {
+    const config = getConfig();
+    const active = config.engines?.active || ['claude'];
+
+    for (const eng of active) {
+      await testEngine(eng);
+    }
+    console.log('');
+    return;
+  }
+
+  console.log(chalk.red(`Unknown action: ${action}`));
+  console.log('Usage:');
+  console.log('  nexuscli engines         List engines');
+  console.log('  nexuscli engines add     Add/configure engine');
+  console.log('  nexuscli engines test    Test active engines');
+  console.log('');
+}
+
+module.exports = engines;