@mmmbuto/nexuscrew 0.2.4 → 0.4.0

package/lib/services/engine-discovery.js

@@ -1,317 +0,0 @@
-/**
- * LauncherDiscovery — environment-agnostic launcher detection
- *
- * 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 path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const KNOWN_FAMILIES = ['claude', 'codex', 'gemini', 'qwen'];
-
-class EngineDiscovery {
-  constructor(config = {}) {
-    this.preferredShell = config.preferredShell || '';
-    this.extraShellSources = Array.isArray(config.extraShellSources) ? config.extraShellSources : [];
-    this.tmux = config.tmux || null;
-    this._cache = new Map();
-  }
-
-  discover(host = null) {
-    const hostKey = this._hostKey(host);
-    if (this._cache.has(hostKey)) return this._cache.get(hostKey);
-
-    const runtime = this.getRuntimeInfo(host);
-    const shellPath = runtime.shell || this.getShellPath();
-    const shellName = path.basename(shellPath || '/bin/sh');
-    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,
-        bucket: launcher.bucket || this._classifyBucket(launcher)
-      });
-    };
-
-    this._discoverPathBinaries(host).forEach(addLauncher);
-    this._discoverLiveShell(shellPath, host).forEach(addLauncher);
-    this._discoverShellFiles(shellName, host).forEach(addLauncher);
-
-    launchers.sort((a, b) => a.label.localeCompare(b.label));
-    const discovery = {
-      shell: shellPath,
-      homeDir: runtime.homeDir,
-      platform: runtime.platform,
-      host: hostKey,
-      launchers,
-      buckets: this._bucketize(launchers)
-    };
-    this._cache.set(hostKey, discovery);
-    return discovery;
-  }
-
-  getLaunchers(host = null) {
-    return this.discover(host).launchers;
-  }
-
-  getBuckets(host = null) {
-    return this.discover(host).buckets;
-  }
-
-  getLauncher(id, host = null) {
-    return this.getLaunchers(host).find((launcher) => launcher.id === id) || null;
-  }
-
-  getShellPath() {
-    return this.preferredShell || process.env.SHELL || '/bin/sh';
-  }
-
-  getRuntimeInfo(host = null) {
-    if (this.tmux) {
-      return this.tmux.getRuntimeInfo(host);
-    }
-    return {
-      homeDir: os.homedir(),
-      shell: this.getShellPath(),
-      platform: process.platform,
-      host: this._hostKey(host)
-    };
-  }
-
-  clearCache() {
-    this._cache.clear();
-  }
-
-  _discoverPathBinaries(host = null) {
-    return KNOWN_FAMILIES.flatMap((family) => {
-      const binPath = this._resolveCommand(family, host);
-      if (!binPath) return [];
-      return [{
-        id: `binary:${family}`,
-        label: family,
-        family,
-        kind: 'binary',
-        command: binPath,
-        commandPreview: binPath,
-        source: 'path',
-        runnable: true
-      }];
-    });
-  }
-
-  _discoverLiveShell(shellPath, host = null) {
-    const shellName = path.basename(shellPath);
-    if (!this._fileExists(shellPath, host)) 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 = this._runInteractiveShell(shellPath, shellName, script, host);
-      return this._parseShellDump(output, shellName, 'live-shell');
-    } catch {
-      return [];
-    }
-  }
-
-  _discoverShellFiles(shellName, host = null) {
-    const homeDir = this.getRuntimeInfo(host).homeDir || os.homedir();
-    const shellFiles = new Set();
-
-    for (const candidate of this._defaultShellFiles(shellName)) {
-      shellFiles.add(path.join(homeDir, candidate));
-    }
-    for (const candidate of this.extraShellSources) {
-      if (candidate) shellFiles.add(candidate);
-    }
-
-    const discovered = [];
-    for (const filePath of shellFiles) {
-      if (!this._fileExists(filePath, host)) continue;
-      try {
-        const content = this._readFile(filePath, host);
-        discovered.push(...this._parseShellFile(content, shellName, filePath));
-      } catch {}
-    }
-    return discovered;
-  }
-
-  _parseShellDump(content, shellName, source) {
-    const [aliasSection = '', functionSection = ''] = content.split('\n__NEXUSCREW_FUNCTIONS__\n');
-    return [
-      ...this._parseAliases(aliasSection, shellName, source),
-      ...this._parseFunctions(functionSection, shellName, source)
-    ];
-  }
-
-  _parseShellFile(content, shellName, filePath) {
-    return [
-      ...this._parseAliases(content, shellName, `shell-file:${filePath}`),
-      ...this._parseFunctions(content, shellName, `shell-file:${filePath}`)
-    ];
-  }
-
-  _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 aliases;
-  }
-
-  _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;
-  }
-
-  _isLauncherCandidate(name, body = '') {
-    const haystack = `${name} ${body}`.toLowerCase();
-    return KNOWN_FAMILIES.some((family) => haystack.includes(family));
-  }
-
-  _detectFamily(name, body = '') {
-    const haystack = `${name || ''} ${body}`.toLowerCase();
-    return KNOWN_FAMILIES.find((family) => haystack.includes(family)) || 'custom';
-  }
-
-  _resolveCommand(command, host = null) {
-    if (this.tmux) {
-      return this.tmux.resolveCommand(command, host);
-    }
-    try {
-      const { execSync } = require('child_process');
-      const resolved = execSync(`command -v ${command} 2>/dev/null`, {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore']
-      }).trim();
-      return resolved || null;
-    } catch {
-      return null;
-    }
-  }
-
-  _defaultShellFiles(shellName) {
-    switch (shellName) {
-      case 'zsh':
-        return ['.zshrc', '.zprofile', '.zshenv'];
-      case 'bash':
-        return ['.bashrc', '.bash_profile', '.profile'];
-      default:
-        return ['.profile'];
-    }
-  }
-
-  _shellArgs(shellName, script) {
-    if (shellName === 'bash' || shellName === 'zsh') {
-      return ['-ilc', script];
-    }
-    return ['-lc', script];
-  }
-
-  _runInteractiveShell(shellPath, shellName, script, host = null) {
-    if (this.tmux) {
-      return this.tmux.runInteractiveShell(shellPath, script, host);
-    }
-    const { execFileSync } = require('child_process');
-    return execFileSync(shellPath, this._shellArgs(shellName, script), {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-  }
-
-  _fileExists(filePath, host = null) {
-    if (this.tmux) {
-      return this.tmux.fileExists(filePath, host);
-    }
-    return fs.existsSync(filePath);
-  }
-
-  _readFile(filePath, host = null) {
-    if (this.tmux) {
-      return this.tmux.readFile(filePath, host);
-    }
-    return fs.readFileSync(filePath, 'utf8');
-  }
-
-  _hostKey(host) {
-    if (!host || host === 'local') return 'local';
-    if (typeof host === 'string') return host;
-    return host.name || 'remote';
-  }
-
-  _classifyBucket(launcher) {
-    const name = String(launcher.label || launcher.name || launcher.command || '').trim();
-    if (name.startsWith('_')) return 'internal';
-    if (launcher.kind === 'function' && /(^_|_bin$|_run$|_cmd$|_provider_|_chutes$)/.test(name)) {
-      return 'internal';
-    }
-    if (launcher.runnable === false) return 'detectedOnly';
-    return 'runnable';
-  }
-
-  _bucketize(launchers) {
-    return {
-      runnable: launchers.filter((launcher) => launcher.bucket === 'runnable'),
-      detectedOnly: launchers.filter((launcher) => launcher.bucket === 'detectedOnly'),
-      internal: launchers.filter((launcher) => launcher.bucket === 'internal')
-    };
-  }
-}
-
-module.exports = EngineDiscovery;

package/lib/services/log-watcher.js

@@ -1,279 +0,0 @@
-/**
- * LogWatcher — Monitor tmux tee log files for structured output
- *
- * Watches log files created by `tee` in tmux windows.
- * Parses output per-engine and emits events.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { EventEmitter } = require('events');
-
-class LogWatcher extends EventEmitter {
-  constructor() {
-    super();
-    this.watchers = new Map(); // logPath → { watcher, offset, parser }
-    this.pollIntervals = new Map(); // logPath → intervalId
-  }
-
-  /**
-   * Start watching a log file
-   * @param {string} logPath - Path to the tee log file
-   * @param {string} engine - Engine type (claude, codex, gemini, qwen)
-   * @param {string} conversationId - Associated conversation
-   */
-  watch(logPath, engine, conversationId) {
-    if (this.watchers.has(logPath)) return;
-
-    const state = {
-      offset: 0,
-      engine,
-      conversationId,
-      buffer: '',
-      parser: this._getParser(engine)
-    };
-
-    // Read existing content (in case log already has data)
-    if (fs.existsSync(logPath)) {
-      state.offset = fs.statSync(logPath).size;
-    }
-
-    // Poll-based watching (more reliable than fs.watch for log files)
-    const intervalId = setInterval(() => this._poll(logPath, state), 200);
-    this.pollIntervals.set(logPath, intervalId);
-
-    // Also use fs.watch for immediate responsiveness
-    try {
-      const watcher = fs.watch(path.dirname(logPath), (eventType, filename) => {
-        if (filename === path.basename(logPath)) {
-          this._poll(logPath, state);
-        }
-      });
-      this.watchers.set(logPath, { ...state, watcher });
-    } catch {
-      // fs.watch may fail in some environments, polling still works
-      this.watchers.set(logPath, state);
-    }
-
-    this.emit('watching', { logPath, engine, conversationId });
-  }
-
-  /**
-   * Stop watching a log file
-   */
-  unwatch(logPath) {
-    const state = this.watchers.get(logPath);
-    if (state?.watcher) state.watcher.close();
-    this.watchers.delete(logPath);
-
-    const intervalId = this.pollIntervals.get(logPath);
-    if (intervalId) {
-      clearInterval(intervalId);
-      this.pollIntervals.delete(logPath);
-    }
-  }
-
-  /**
-   * Stop all watchers
-   */
-  unwatchAll() {
-    for (const logPath of this.watchers.keys()) {
-      this.unwatch(logPath);
-    }
-  }
-
-  // --- Polling ---
-
-  _poll(logPath, state) {
-    try {
-      if (!fs.existsSync(logPath)) return;
-
-      const stat = fs.statSync(logPath);
-      if (stat.size <= state.offset) return;
-
-      const fd = fs.openSync(logPath, 'r');
-      const buf = Buffer.alloc(stat.size - state.offset);
-      fs.readSync(fd, buf, 0, buf.length, state.offset);
-      fs.closeSync(fd);
-
-      state.offset = stat.size;
-      const chunk = buf.toString('utf8');
-      state.buffer += chunk;
-
-      // Process complete lines
-      this._processBuffer(state);
-    } catch (err) {
-      // File might be temporarily unavailable
-    }
-  }
-
-  _processBuffer(state) {
-    const lines = state.buffer.split('\n');
-    state.buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const events = state.parser(line, state);
-        for (const event of events) {
-          this.emit('data', {
-            ...event,
-            conversationId: state.conversationId,
-            engine: state.engine
-          });
-        }
-      } catch {
-        // Emit raw text if parser fails
-        this.emit('data', {
-          type: 'raw',
-          content: line,
-          conversationId: state.conversationId,
-          engine: state.engine
-        });
-      }
-    }
-  }
-
-  // --- Parsers ---
-
-  _getParser(engine) {
-    switch (engine) {
-      case 'claude': return this._parseClaude.bind(this);
-      case 'codex': return this._parseCodex.bind(this);
-      case 'gemini': return this._parseGemini.bind(this);
-      case 'qwen': return this._parseQwen.bind(this);
-      default: return this._parseGeneric.bind(this);
-    }
-  }
-
-  /**
-   * Claude Code JSON output parser
-   * Claude emits JSON objects per-line when --output-format json is used
-   */
-  _parseClaude(line, state) {
-    const events = [];
-
-    // Try JSON parse (Claude --output-format json)
-    try {
-      const obj = JSON.parse(line);
-
-      if (obj.type === 'assistant') {
-        events.push({ type: 'status', content: 'thinking...' });
-      } else if (obj.type === 'content_block_delta') {
-        events.push({ type: 'chunk', content: obj.delta?.text || '' });
-      } else if (obj.type === 'message_stop') {
-        events.push({ type: 'done' });
-      } else if (obj.type === 'tool_use') {
-        events.push({ type: 'status', content: `tool: ${obj.name || 'unknown'}` });
-      } else if (obj.result !== undefined) {
-        // Final result
-        events.push({
-          type: 'message_done',
-          content: typeof obj.result === 'string' ? obj.result : JSON.stringify(obj.result),
-          usage: obj.usage
-        });
-      }
-      return events;
-    } catch {}
-
-    // Fallback: plain text parsing
-    if (line.includes('thinking...') || line.includes('Thinking...')) {
-      events.push({ type: 'status', content: 'thinking...' });
-    } else if (line.includes('tool:')) {
-      events.push({ type: 'status', content: line.trim() });
-    } else if (line.trim()) {
-      events.push({ type: 'chunk', content: line });
-    }
-
-    return events;
-  }
-
-  /**
-   * Codex exec --json output parser (JSONL)
-   */
-  _parseCodex(line) {
-    const events = [];
-
-    try {
-      const obj = JSON.parse(line);
-      if (obj.type === 'status') {
-        events.push({ type: 'status', content: obj.message || obj.status });
-      } else if (obj.type === 'response' || obj.type === 'result') {
-        events.push({
-          type: 'message_done',
-          content: obj.content || obj.result || obj.text || '',
-          usage: obj.usage
-        });
-      } else if (obj.type === 'tool_use' || obj.type === 'patch') {
-        events.push({ type: 'status', content: `${obj.type}: ${obj.name || obj.path || ''}` });
-      } else if (obj.delta) {
-        events.push({ type: 'chunk', content: obj.delta });
-      } else if (obj.content) {
-        events.push({ type: 'chunk', content: typeof obj.content === 'string' ? obj.content : JSON.stringify(obj.content) });
-      }
-    } catch {
-      if (line.trim()) {
-        events.push({ type: 'chunk', content: line });
-      }
-    }
-
-    return events;
-  }
-
-  /**
-   * Gemini output parser
-   */
-  _parseGemini(line) {
-    const events = [];
-
-    try {
-      const obj = JSON.parse(line);
-      if (obj.type === 'status') {
-        events.push({ type: 'status', content: obj.message });
-      } else if (obj.content) {
-        events.push({ type: 'chunk', content: obj.content });
-      }
-    } catch {
-      // Detect Gemini status markers
-      if (line.match(/^(⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏)/)) {
-        events.push({ type: 'status', content: line.trim() });
-      } else if (line.trim()) {
-        events.push({ type: 'chunk', content: line });
-      }
-    }
-
-    return events;
-  }
-
-  /**
-   * Qwen output parser
-   */
-  _parseQwen(line) {
-    const events = [];
-
-    try {
-      const obj = JSON.parse(line);
-      if (obj.type === 'status') {
-        events.push({ type: 'status', content: obj.message });
-      } else if (obj.content) {
-        events.push({ type: 'chunk', content: obj.content });
-      }
-    } catch {
-      if (line.trim()) {
-        events.push({ type: 'chunk', content: line });
-      }
-    }
-
-    return events;
-  }
-
-  /**
-   * Generic fallback parser
-   */
-  _parseGeneric(line) {
-    if (!line.trim()) return [];
-    return [{ type: 'chunk', content: line }];
-  }
-}
-
-module.exports = LogWatcher;