@mmmbuto/nexuscrew 0.2.0 → 0.2.2

package/lib/services/engine-discovery.js

@@ -1,504 +1,251 @@
 /**
- * EngineDiscovery — Auto-detect AI CLIs and parse providers.zsh aliases
+ * LauncherDiscovery — environment-agnostic launcher detection
  *
- * Discovers:
- * - Standard CLIs: claude, codex, gemini, qwen (via PATH + common paths)
- * - Custom aliases/functions from providers.zsh (e.g. claude-glm-a, codex-alibaba-qwen35)
- * - Each engine gets: path, type, available, aliases[], models[]
+ * Discovers launchers from:
+ * - the current runtime shell via live introspection
+ * - generic shell rc/profile files as fallback
+ * - PATH binaries
+ *
+ * No user-specific config is assumed and no model catalog is hardcoded.
  */
 
-const { execSync } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 
-const CLI_SEARCH_PATHS = {
-  claude: [
-    '${HOME}/.local/bin/claude',
-    '${HOME}/.claude/local/claude',
-    '/usr/local/bin/claude',
-    '/usr/bin/claude',
-    '${PREFIX}/bin/claude'
-  ],
-  codex: [
-    '${HOME}/.local/codex-lts/bin/codex',
-    '${HOME}/.local/codex-lts/node_modules/.bin/codex',
-    '${HOME}/.local/codex-lts/package/bin/android-arm64/codex',
-    '/usr/local/bin/codex'
-  ],
-  gemini: [
-    '${HOME}/.local/bin/gemini',
-    '${HOME}/.gemini/bin/gemini',
-    '/usr/local/bin/gemini'
-  ],
-  qwen: [
-    '${HOME}/.local/bin/qwen',
-    '${HOME}/.qwen/bin/qwen',
-    '/usr/local/bin/qwen'
-  ]
-};
-
-const SHELL_SOURCES = [
-  '${HOME}/.zshrc',
-  '${HOME}/.bashrc',
-  '${HOME}/.bash_profile',
-  '${HOME}/.profile',
-  '${HOME}/.zprofile',
-  '${HOME}/.config/ai-shell/providers.zsh',
-  '${HOME}/.config/zsh/chutes-wrapper.zsh',
-  '${HOME}/.nexuscrew/providers.zsh'
-];
-
-const ENGINE_PREFIXES = ['claude', 'codex', 'gemini', 'qwen'];
-
-/**
- * Engine types:
- * - interactive: runs as REPL, needs PTY-like handling (send text + Enter)
- * - exec: runs one-shot commands, returns structured output
- */
-const ENGINE_TYPES = {
-  claude: 'interactive',
-  codex: 'exec',
-  gemini: 'interactive',
-  qwen: 'interactive'
-};
-
-/**
- * Build command templates for each engine
- */
-const ENGINE_COMMANDS = {
-  claude: {
-    new: (bin, opts) => `${bin} --output-format json${opts.model ? ` --model ${opts.model}` : ''}`,
-    resume: (bin, opts) => `${bin} --output-format json -r ${opts.sessionId}${opts.model ? ` --model ${opts.model}` : ''}`,
-    interactive: (bin) => `${bin} --output-format json`
-  },
-  codex: {
-    new: (bin, opts) => `${bin} exec --json${opts.model ? ` -m ${opts.model}` : ''}${opts.reasoningEffort ? ` --reasoning ${opts.reasoningEffort}` : ''}`,
-    resume: (bin, opts) => `${bin} exec --json resume ${opts.threadId}`,
-    interactive: (bin) => bin
-  },
-  gemini: {
-    new: (bin, opts) => `${bin}${opts.model ? ` -m ${opts.model}` : ''}`,
-    resume: (bin, opts) => `${bin} --resume ${opts.threadId}${opts.model ? ` -m ${opts.model}` : ''}`,
-    interactive: (bin) => bin
-  },
-  qwen: {
-    new: (bin, opts) => `${bin}${opts.model ? ` -m ${opts.model}` : ''}`,
-    resume: (bin, opts) => `${bin} --resume ${opts.threadId}${opts.model ? ` -m ${opts.model}` : ''}`,
-    interactive: (bin) => bin
-  }
-};
+const KNOWN_FAMILIES = ['claude', 'codex', 'gemini', 'qwen'];
 
 class EngineDiscovery {
-  constructor(providersPath) {
-    this.providersPath = providersPath || '';
+  constructor(config = {}) {
+    this.preferredShell = config.preferredShell || '';
+    this.extraShellSources = Array.isArray(config.extraShellSources) ? config.extraShellSources : [];
     this._cache = null;
   }
 
-  /**
-   * Discover all available engines, aliases, and models
-   * @returns {Object} engines map
-   */
   discover() {
     if (this._cache) return this._cache;
 
-    const engines = {};
+    const shellPath = this.getShellPath();
+    const shellName = path.basename(shellPath);
+    const launchers = [];
+    const seen = new Set();
+
+    const addLauncher = (launcher) => {
+      const id = launcher.id || `${launcher.kind}:${launcher.command}`;
+      if (!launcher.command || seen.has(id)) return;
+      seen.add(id);
+      launchers.push({
+        id,
+        label: launcher.label || launcher.name || launcher.command,
+        family: launcher.family || this._detectFamily(launcher.name || launcher.command),
+        kind: launcher.kind,
+        command: launcher.command,
+        commandPreview: launcher.commandPreview || launcher.command,
+        source: launcher.source,
+        shell: launcher.shell || shellName,
+        available: launcher.available !== false,
+        runnable: launcher.runnable !== false
+      });
+    };
 
-    // 1. Discover standard CLIs
-    for (const [name, searchPaths] of Object.entries(CLI_SEARCH_PATHS)) {
-      engines[name] = this._discoverCli(name, searchPaths);
-    }
+    this._discoverPathBinaries().forEach(addLauncher);
+    this._discoverLiveShell(shellPath).forEach(addLauncher);
+    this._discoverShellFiles(shellName).forEach(addLauncher);
 
-    // 2. Parse providers.zsh for aliases/functions
-    const aliases = this._parseProviders();
-    for (const alias of aliases) {
-      const baseEngine = this._detectBaseEngine(alias.name);
-      if (baseEngine && engines[baseEngine]) {
-        engines[baseEngine].aliases.push({
-          name: alias.name,
-          command: alias.command,
-          description: this._describeAlias(alias.name),
-          modelHint: this._extractModelHint(alias.command)
-        });
-      }
-    }
-
-    // 3. Build model lists for each engine
-    for (const [name, engine] of Object.entries(engines)) {
-      engine.models = this._buildModels(name, engine);
-    }
-
-    this._cache = engines;
-    return engines;
+    launchers.sort((a, b) => a.label.localeCompare(b.label));
+    this._cache = {
+      shell: shellPath,
+      homeDir: os.homedir(),
+      launchers
+    };
+    return this._cache;
   }
 
-  /**
-   * Get flat list of all available models across all engines
-   * @returns {Array<{id, name, engine, type, alias?}>}
-   */
-  getAllModels() {
-    const engines = this.discover();
-    const models = [];
-    for (const [engineName, engine] of Object.entries(engines)) {
-      for (const model of engine.models) {
-        models.push({ ...model, engine: engineName });
-      }
-    }
-    return models;
+  getLaunchers() {
+    return this.discover().launchers;
   }
 
-  /**
-   * Get engines formatted for the frontend model selector
-   */
-  getForFrontend() {
-    const engines = this.discover();
-    const result = {};
-    for (const [name, engine] of Object.entries(engines)) {
-      result[name] = {
-        available: engine.available,
-        type: engine.type,
-        path: engine.path,
-        models: engine.models,
-        aliases: engine.aliases,
-        endpoint: '/api/v1/send' // Single unified endpoint
-      };
-    }
-    return result;
+  getLauncher(id) {
+    return this.getLaunchers().find((launcher) => launcher.id === id) || null;
   }
 
-  // --- Internal ---
-
-  _discoverCli(name, searchPaths) {
-    const resolved = searchPaths.map(p =>
-      p.replace(/\$\{HOME\}/g, process.env.HOME || '')
-       .replace(/\$\{PREFIX\}/g, process.env.PREFIX || '')
-    );
-
-    let foundPath = null;
-    for (const p of resolved) {
-      try {
-        if (fs.existsSync(p) && fs.statSync(p).mode & 0o111) {
-          foundPath = p;
-          break;
-        }
-      } catch {}
-    }
-
-    // Fallback: which
-    if (!foundPath) {
-      try {
-        foundPath = execSync(`which ${name} 2>/dev/null`).toString().trim();
-      } catch {}
-    }
+  getShellPath() {
+    return this.preferredShell || process.env.SHELL || '/bin/sh';
+  }
 
+  getRuntimeInfo() {
     return {
-      available: !!foundPath,
-      path: foundPath,
-      type: ENGINE_TYPES[name] || 'interactive',
-      aliases: [],
-      models: []
+      homeDir: os.homedir(),
+      shell: this.getShellPath(),
+      platform: process.platform
     };
   }
 
-  _parseProviders() {
-    // Use universal shell discovery instead of single file
-    return this._discoverShellSources();
+  clearCache() {
+    this._cache = null;
   }
 
-  /**
-   * Discover shell aliases and functions from all standard shell config files
-   * Parses:
-   * - alias name='command' / alias name="command"
-   * - name() { ... } function definitions
-   * - Follows source/. directives (1 level)
-   * - Extracts model hints from env vars and command args
-   */
-  _discoverShellSources() {
-    const HOME = process.env.HOME || '';
-    const aliases = [];
-    const processedFiles = new Set();
-
-    const searchPaths = SHELL_SOURCES.map(p =>
-      p.replace(/\$\{HOME\}/g, HOME)
-    );
-
-    for (const filePath of searchPaths) {
-      if (!fs.existsSync(filePath) || processedFiles.has(filePath)) continue;
-      processedFiles.add(filePath);
-
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.split('\n');
-
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i].trim();
-
-          // Skip comments and empty lines
-          if (!line || line.startsWith('#')) continue;
-
-          // Follow source/. directives (1 level deep)
-          if (line.startsWith('source ') || line.startsWith('. ')) {
-            const sourcedFile = line.replace(/^source\s+|^\.\s+/, '').replace(/['"]/g, '').trim();
-            const resolvedPath = sourcedFile.startsWith('~')
-              ? path.join(HOME, sourcedFile.slice(1))
-              : sourcedFile;
-
-            if (fs.existsSync(resolvedPath) && !processedFiles.has(resolvedPath)) {
-              processedFiles.add(resolvedPath);
-              try {
-                const sourcedContent = fs.readFileSync(resolvedPath, 'utf8');
-                this._parseShellContent(sourcedContent, aliases, resolvedPath);
-              } catch (err) {
-                // Skip unreadable sourced files
-              }
-            }
-            continue;
-          }
-
-          // Parse current line
-          this._parseShellLine(line, aliases, filePath);
-        }
-      } catch (err) {
-        // Skip unreadable files
-      }
-    }
-
-    return aliases;
+  _discoverPathBinaries() {
+    return KNOWN_FAMILIES.flatMap((family) => {
+      const binPath = this._resolveCommand(family);
+      if (!binPath) return [];
+      return [{
+        id: `binary:${family}`,
+        label: family,
+        family,
+        kind: 'binary',
+        command: binPath,
+        commandPreview: binPath,
+        source: 'path',
+        runnable: true
+      }];
+    });
   }
 
-  /**
-   * Parse a single line for aliases or functions
-   */
-  _parseShellLine(line, aliases, source) {
-    // Match: alias name='command' or alias name="command"
-    const aliasRegex = /^alias\s+([a-z0-9][a-z0-9-]*)\s*=\s*['"]([^'"]+)['"]/;
-    const aliasMatch = line.match(aliasRegex);
-    if (aliasMatch) {
-      const name = aliasMatch[1];
-      if (this._isEngineAlias(name)) {
-        aliases.push({
-          name,
-          command: aliasMatch[2],
-          source,
-          modelHint: this._extractModelHint(aliasMatch[2])
-        });
-      }
-      return;
-    }
-
-    // Match: name() { ... } (function definition - single line)
-    const funcRegex = /^([a-z0-9][a-z0-9-]*)\(\)\s*\{([^}]*)\}/;
-    const funcMatch = line.match(funcRegex);
-    if (funcMatch) {
-      const name = funcMatch[1];
-      if (this._isEngineAlias(name)) {
-        aliases.push({
-          name,
-          command: funcMatch[2].trim(),
-          source,
-          modelHint: this._extractModelHint(funcMatch[2])
-        });
-      }
+  _discoverLiveShell(shellPath) {
+    const shellName = path.basename(shellPath);
+    if (!fs.existsSync(shellPath)) return [];
+
+    try {
+      const script = [
+        'alias -p 2>/dev/null || true',
+        'printf "\\n__NEXUSCREW_FUNCTIONS__\\n"',
+        'typeset -f 2>/dev/null || declare -f 2>/dev/null || true'
+      ].join('; ');
+
+      const output = execFileSync(shellPath, this._shellArgs(shellName, script), {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      return this._parseShellDump(output, shellName, 'live-shell');
+    } catch {
+      return [];
     }
   }
 
-  /**
-   * Parse full file content for aliases and functions
-   */
-  _parseShellContent(content, aliases, source) {
-    const lines = content.split('\n');
-
-    // Multi-line function buffer
-    let inFunction = false;
-    let funcName = null;
-    let funcBody = [];
-
-    for (const line of lines) {
-      const trimmed = line.trim();
+  _discoverShellFiles(shellName) {
+    const homeDir = os.homedir();
+    const shellFiles = new Set();
 
-      // Skip comments and empty lines
-      if (!trimmed || trimmed.startsWith('#')) continue;
-
-      // Function start
-      if (!inFunction) {
-        const funcStart = trimmed.match(/^([a-z0-9][a-z0-9-]*)\(\)\s*\{/);
-        if (funcStart) {
-          const name = funcStart[1];
-          if (this._isEngineAlias(name)) {
-            inFunction = true;
-            funcName = name;
-            funcBody = [];
-          }
-          continue;
-        }
-
-        // Single-line alias/function
-        this._parseShellLine(trimmed, aliases, source);
-      } else {
-        // Function end
-        if (trimmed === '}') {
-          inFunction = false;
-          if (funcName) {
-            aliases.push({
-              name: funcName,
-              command: funcBody.join(' ').trim(),
-              source,
-              modelHint: this._extractModelHint(funcBody.join(' '))
-            });
-            funcName = null;
-            funcBody = [];
-          }
-          continue;
-        }
+    for (const candidate of this._defaultShellFiles(shellName)) {
+      shellFiles.add(path.join(homeDir, candidate));
+    }
+    for (const candidate of this.extraShellSources) {
+      if (candidate) shellFiles.add(candidate);
+    }
 
-        // Accumulate function body
-        funcBody.push(trimmed);
-      }
+    const discovered = [];
+    for (const filePath of shellFiles) {
+      if (!fs.existsSync(filePath)) continue;
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        discovered.push(...this._parseShellFile(content, shellName, filePath));
+      } catch {}
     }
+    return discovered;
   }
 
-  /**
-   * Check if a name matches any engine prefix
-   */
-  _isEngineAlias(name) {
-    return ENGINE_PREFIXES.some(prefix => name.startsWith(prefix));
+  _parseShellDump(content, shellName, source) {
+    const [aliasSection = '', functionSection = ''] = content.split('\n__NEXUSCREW_FUNCTIONS__\n');
+    return [
+      ...this._parseAliases(aliasSection, shellName, source),
+      ...this._parseFunctions(functionSection, shellName, source)
+    ];
   }
 
-  _detectBaseEngine(name) {
-    if (name.startsWith('claude')) return 'claude';
-    if (name.startsWith('codex')) return 'codex';
-    if (name.startsWith('gemini')) return 'gemini';
-    if (name.startsWith('qwen')) return 'qwen';
-    return null;
+  _parseShellFile(content, shellName, filePath) {
+    return [
+      ...this._parseAliases(content, shellName, `shell-file:${filePath}`),
+      ...this._parseFunctions(content, shellName, `shell-file:${filePath}`)
+    ];
   }
 
-  _describeAlias(name) {
-    // Human-readable description from function name
-    const parts = name.split('-');
-    const engine = parts[0];
-    const rest = parts.slice(1);
-
-    const providerMap = {
-      'glm': 'Z.ai GLM',
-      'zai': 'Z.ai',
-      'alibaba': 'Alibaba',
-      'chutes': 'Chutes',
-      'minimax': 'MiniMax',
-      'minimax27': 'MiniMax M2.7'
-    };
-
-    const modelMap = {
-      'a': '(Key A)',
-      'p': '(Key P)',
-      'qwen35': 'Qwen 3.5',
-      'qwen3max': 'Qwen 3 Max',
-      'glm5': 'GLM-5',
-      'glm5ist': 'GLM-5 Turbo',
-      'kimi': 'Kimi K2.5',
-      'minimax': 'MiniMax',
-      'minimax27': 'MiniMax M2.7',
-      'qwencodex': 'Qwen Coder',
-      'qwennext': 'Qwen Coder Next',
-      'qwen3next': 'Qwen 3 Next',
-      'glm5turbo': 'GLM-5 Turbo',
-      'deepseek': 'DeepSeek V3.2'
-    };
-
-    const descriptions = [];
-    for (const part of rest) {
-      if (providerMap[part]) descriptions.push(providerMap[part]);
-      else if (modelMap[part]) descriptions.push(modelMap[part]);
-      else descriptions.push(part);
+  _parseAliases(content, shellName, source) {
+    const aliases = [];
+    const regex = /^alias\s+([A-Za-z0-9_.:-]+)=['"]([^'"]+)['"]$/gm;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      const body = match[2].trim();
+      if (!this._isLauncherCandidate(name, body)) continue;
+      aliases.push({
+        id: `alias:${name}`,
+        label: name,
+        name,
+        family: this._detectFamily(name, body),
+        kind: 'alias',
+        command: name,
+        commandPreview: body,
+        source,
+        shell: shellName,
+        runnable: source === 'live-shell'
+      });
     }
-
-    return `${engine} → ${descriptions.join(' / ')}`;
+    return aliases;
   }
 
-  _extractModelHint(command) {
-    if (!command) return null;
+  _parseFunctions(content, shellName, source) {
+    const functions = [];
+    const regex = /^([A-Za-z0-9_.:-]+)\s*(?:\(\))?\s*\{/gm;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      if (!this._isLauncherCandidate(name, name)) continue;
+      functions.push({
+        id: `function:${name}`,
+        label: name,
+        name,
+        family: this._detectFamily(name),
+        kind: 'function',
+        command: name,
+        commandPreview: `${name}()`,
+        source,
+        shell: shellName,
+        runnable: source === 'live-shell'
+      });
+    }
+    return functions;
+  }
 
-    // Try quoted string first
-    const quotedMatch = command.match(/["']([^"']+)["']/);
-    if (quotedMatch) {
-      return quotedMatch[1];
-    }
+  _isLauncherCandidate(name, body = '') {
+    const haystack = `${name} ${body}`.toLowerCase();
+    return KNOWN_FAMILIES.some((family) => haystack.includes(family));
+  }
 
-    // Extract from --model flag
-    const modelFlagMatch = command.match(/--model\s+(\S+)/);
-    if (modelFlagMatch) {
-      return modelFlagMatch[1];
-    }
+  _detectFamily(name, body = '') {
+    const haystack = `${name || ''} ${body}`.toLowerCase();
+    return KNOWN_FAMILIES.find((family) => haystack.includes(family)) || 'custom';
+  }
 
-    // Extract from ANTHROPIC_MODEL env var
-    const anthropicMatch = command.match(/ANTHROPIC_MODEL\s*=\s*["']?([^"'\s]+)["']?/);
-    if (anthropicMatch) {
-      return anthropicMatch[1];
+  _resolveCommand(command) {
+    try {
+      const resolved = execSync(`command -v ${command} 2>/dev/null`, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+      }).trim();
+      return resolved || null;
+    } catch {
+      return null;
     }
+  }
 
-    // Extract from OPENAI_API_BASE (indicates provider)
-    const openaiBaseMatch = command.match(/OPENAI_API_BASE\s*=\s*["']?([^"'\s]+)["']?/);
-    if (openaiBaseMatch) {
-      // Derive model from base URL if it's a known provider
-      const base = openaiBaseMatch[1];
-      if (base.includes('deepseek')) return 'deepseek';
-      if (base.includes('z.ai') || base.includes('glm')) return 'glm';
-      if (base.includes('alibaba') || base.includes('dashscope')) return 'qwen';
+  _defaultShellFiles(shellName) {
+    switch (shellName) {
+      case 'zsh':
+        return ['.zshrc', '.zprofile', '.zshenv'];
+      case 'bash':
+        return ['.bashrc', '.bash_profile', '.profile'];
+      default:
+        return ['.profile'];
     }
-
-    return null;
   }
 
-  _buildModels(engineName, engine) {
-    const models = [];
-
-    if (!engine.available) return models;
-
-    // Native models per engine
-    const nativeModels = {
-      claude: [
-        { id: 'sonnet', name: 'Claude Sonnet', lane: 'native' },
-        { id: 'opus', name: 'Claude Opus', lane: 'native' },
-        { id: 'haiku', name: 'Claude Haiku', lane: 'native' }
-      ],
-      codex: [
-        { id: 'gpt-5.4', name: 'GPT-5.4', lane: 'native' },
-        { id: 'gpt-5.3-codex', name: 'GPT-5.3 Codex', lane: 'native' },
-        { id: 'codex-mini-latest', name: 'Codex Mini', lane: 'native' }
-      ],
-      gemini: [
-        { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro', lane: 'native' },
-        { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', lane: 'native' },
-        { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', lane: 'native' }
-      ],
-      qwen: [
-        { id: 'qwen3-coder-plus', name: 'Qwen 3 Coder Plus', lane: 'native' },
-        { id: 'qwen3.5-plus', name: 'Qwen 3.5 Plus', lane: 'native' },
-        { id: 'qwen3-max', name: 'Qwen 3 Max', lane: 'native' }
-      ]
-    };
-
-    models.push(...(nativeModels[engineName] || []));
-
-    // Alias-based custom models
-    for (const alias of engine.aliases) {
-      if (alias.modelHint) {
-        models.push({
-          id: `${engineName}-${alias.name}`,
-          name: alias.description || alias.name,
-          lane: 'custom',
-          alias: alias.name,
-          modelHint: alias.modelHint
-        });
-      } else {
-        models.push({
-          id: `${engineName}-${alias.name}`,
-          name: alias.description || alias.name,
-          lane: 'custom',
-          alias: alias.name
-        });
-      }
+  _shellArgs(shellName, script) {
+    if (shellName === 'bash' || shellName === 'zsh') {
+      return ['-ilc', script];
     }
-
-    return models;
+    return ['-lc', script];
   }
 }