@agile-vibe-coding/avc 0.1.0 → 0.2.3

package/cli/model-selector.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * Model Selector - Multi-Provider Model Evaluation Tool
+ * Queries Claude, OpenAI, and Gemini with evaluation prompts
+ * to collect model recommendations for each AVC stage
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { EVALUATION_PROMPTS, getPromptStats } from './evaluation-prompts.js';
+import { ModelQueryEngine } from './model-query-engine.js';
+import { ModelRecommendationAnalyzer } from './model-recommendation-analyzer.js';
+import { sendError, sendWarning, sendSuccess, sendInfo, sendOutput, sendIndented, sendSectionHeader } from './messaging-api.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Ensure _temp directory exists
+ */
+function ensureTempDir() {
+  const tempDir = path.join(process.cwd(), '_temp');
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+  return tempDir;
+}
+
+/**
+ * Display banner
+ */
+function displayBanner() {
+  console.log('\n╔══════════════════════════════════════════════════════════════╗');
+  console.log('║      Multi-Provider Model Selection Evaluator               ║');
+  console.log('║      Queries Claude, OpenAI, and Gemini for recommendations  ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝\n');
+}
+
+/**
+ * Display environment check
+ */
+function displayEnvironmentCheck() {
+  sendSectionHeader('Checking API keys');
+
+  const keys = {
+    'ANTHROPIC_API_KEY': !!process.env.ANTHROPIC_API_KEY,
+    'OPENAI_API_KEY': !!process.env.OPENAI_API_KEY,
+    'GEMINI_API_KEY': !!process.env.GEMINI_API_KEY
+  };
+
+  for (const [key, available] of Object.entries(keys)) {
+    if (available) {
+      sendIndented(`${key}: Found`, 1);
+    } else {
+      sendIndented(`${key}: Not found`, 1);
+    }
+  }
+
+  const availableCount = Object.values(keys).filter(v => v).length;
+
+  sendOutput(`\n   ${availableCount}/3 providers available`);
+
+  if (availableCount === 0) {
+    sendError('No API keys found. Please add at least one to your .env file.');
+    process.exit(1);
+  }
+
+  return availableCount;
+}
+
+/**
+ * Display prompt statistics
+ */
+function displayPromptStats() {
+  const stats = getPromptStats();
+
+  sendSectionHeader('Evaluation Overview');
+  sendIndented(`Total prompts: ${stats.totalPrompts}`, 1);
+  sendIndented(`Ceremonies: ${stats.ceremonies} (${stats.ceremonyList.join(', ')})`, 1);
+  sendIndented(`Estimated total API calls: ${stats.estimatedTotalCalls} per provider`, 1);
+  sendIndented('Impact distribution:', 1);
+  sendIndented(`- CRITICAL: ${stats.impactDistribution.CRITICAL}`, 2);
+  sendIndented(`- VERY HIGH: ${stats.impactDistribution['VERY HIGH']}`, 2);
+  sendIndented(`- HIGH: ${stats.impactDistribution.HIGH}`, 2);
+  sendIndented(`- MEDIUM: ${stats.impactDistribution.MEDIUM}`, 2);
+}
+
+/**
+ * Progress callback for query engine
+ */
+function createProgressCallback() {
+  let currentPrompt = 0;
+
+  return (progress) => {
+    if (progress.type === 'prompt-start') {
+      currentPrompt = progress.current;
+      sendOutput(`\n[${progress.current}/${progress.total}] Processing: ${progress.ceremony}/${progress.stage}`);
+    } else if (progress.type === 'prompt-complete') {
+      const { successCount, failureCount, totalTime } = progress;
+      sendIndented(`Complete: ${successCount} success, ${failureCount} failed (${totalTime.toFixed(1)}s)`, 1);
+    }
+  };
+}
+
+/**
+ * Write JSON output file
+ */
+function writeJSONOutput(data, outputPath) {
+  sendInfo(`Writing JSON output to ${outputPath}...`);
+  fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf-8');
+  sendIndented('JSON file written', 1);
+}
+
+/**
+ * Write Markdown output file
+ */
+function writeMarkdownOutput(content, outputPath) {
+  sendInfo(`Writing Markdown report to ${outputPath}...`);
+  fs.writeFileSync(outputPath, content, 'utf-8');
+  sendIndented('Markdown report written', 1);
+}
+
+/**
+ * Display summary
+ */
+function displaySummary(summary) {
+  console.log('\n╔══════════════════════════════════════════════════════════════╗');
+  console.log('║                    Execution Summary                         ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝\n');
+
+  console.log(`Total prompts evaluated: ${summary.totalPrompts}`);
+  console.log(`Successful queries: ${summary.successfulQueries}`);
+  console.log(`Failed queries: ${summary.failedQueries}`);
+  console.log(`\nExecution time: ${summary.executionTime}`);
+
+  console.log('\nCost breakdown:');
+  for (const [provider, cost] of Object.entries(summary.totalCost)) {
+    if (provider !== 'total') {
+      console.log(`   ${provider}: $${cost.toFixed(4)}`);
+    }
+  }
+  console.log(`   TOTAL: $${summary.totalCost.total.toFixed(4)}`);
+}
+
+/**
+ * Display analysis summary
+ */
+function displayAnalysisSummary(statistics) {
+  console.log('\n╔══════════════════════════════════════════════════════════════╗');
+  console.log('║                   Analysis Summary                           ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝\n');
+
+  console.log('Consensus Statistics:');
+  console.log(`   Full consensus: ${statistics.consensus.full} (${statistics.consensusRate.full})`);
+  console.log(`   Partial consensus: ${statistics.consensus.partial} (${statistics.consensusRate.partial})`);
+  console.log(`   No consensus: ${statistics.consensus.none} (${statistics.consensusRate.none})`);
+
+  console.log('\nDefault Alignment:');
+  console.log(`   Perfect: ${statistics.defaultAlignment.perfect} stages`);
+  console.log(`   Partial: ${statistics.defaultAlignment.partial} stages`);
+  console.log(`   None: ${statistics.defaultAlignment.none} stages`);
+
+  console.log('\nRecommendations:');
+  console.log(`   Upgrade suggestions: ${statistics.upgradeRecommendations} stages`);
+  console.log(`   Downgrade suggestions: ${statistics.downgradeRecommendations} stages`);
+}
+
+/**
+ * Main execution function
+ */
+async function main() {
+  try {
+    displayBanner();
+
+    // Check environment
+    const availableProviders = displayEnvironmentCheck();
+
+    // Display stats
+    displayPromptStats();
+
+    // Confirm execution
+    sendWarning('This will execute multiple API calls to all available providers.');
+    sendIndented('Estimated cost: $0.15-0.30 depending on available providers.', 1);
+    sendIndented('Press Ctrl+C to cancel, or wait 5 seconds to continue...', 1);
+
+    // Wait 5 seconds for user to cancel
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
+    sendInfo('Starting evaluation...');
+
+    // Initialize query engine
+    const engine = new ModelQueryEngine();
+
+    sendInfo('Initializing providers...');
+    const initResult = await engine.initializeProviders();
+
+    sendIndented(`${initResult.readyCount} provider(s) initialized`, 1);
+
+    if (initResult.errors) {
+      sendWarning('Some providers failed to initialize:');
+      for (const error of initResult.errors) {
+        sendIndented(`- ${error.provider}: ${error.error}`, 1);
+      }
+    }
+
+    // Run evaluation
+    sendInfo('Querying providers (this may take several minutes)...');
+
+    const progressCallback = createProgressCallback();
+    const results = await engine.evaluateAll(EVALUATION_PROMPTS, progressCallback);
+
+    sendSuccess('All evaluations complete!');
+
+    // Analyze results
+    sendInfo('Analyzing results...');
+    const analyzer = new ModelRecommendationAnalyzer(results.evaluations);
+    const analysis = analyzer.analyze();
+    sendIndented('Analysis complete', 1);
+
+    // Ensure _temp directory exists
+    const tempDir = ensureTempDir();
+
+    // Write JSON output
+    const jsonPath = path.join(tempDir, 'model-recommendations.json');
+    const jsonOutput = {
+      ...results,
+      analysis: analysis.analyses,
+      statistics: analysis.statistics
+    };
+    writeJSONOutput(jsonOutput, jsonPath);
+
+    // Write Markdown report
+    const markdownPath = path.join(tempDir, 'MODEL_RECOMMENDATIONS_REPORT.md');
+    const markdownReport = analyzer.generateMarkdownReport();
+    writeMarkdownOutput(markdownReport, markdownPath);
+
+    // Display summaries
+    displaySummary(results.summary);
+    displayAnalysisSummary(analysis.statistics);
+
+    // Final message
+    sendOutput('\n╔══════════════════════════════════════════════════════════════╗');
+    sendOutput('║                    Evaluation Complete!                      ║');
+    sendOutput('╚══════════════════════════════════════════════════════════════╝');
+    sendSectionHeader('Output files');
+    sendIndented(`- JSON: ${jsonPath}`, 1);
+    sendIndented(`- Report: ${markdownPath}`, 1);
+
+    sendSectionHeader('Next steps');
+    sendIndented('1. Review the markdown report for provider recommendations', 1);
+    sendIndented('2. Compare consensus vs current defaults', 1);
+    sendIndented('3. Consider cost vs quality trade-offs', 1);
+    sendIndented('4. Update model configurations in AVC if desired', 1);
+
+  } catch (error) {
+    sendError(`ERROR: ${error.message}`);
+    sendOutput(`\nStack trace: ${error.stack}`);
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { main };

package/cli/output-buffer.js

@@ -0,0 +1,107 @@
+/**
+ * OutputBuffer - Manages accumulated output as item array for Static rendering
+ *
+ * Each append() call creates one item with a unique ID, compatible with
+ * Ink's <Static> component which requires stable keys and never erases items.
+ *
+ * Items accumulate across commands (like a natural terminal log).
+ * The clear() method inserts a blank separator line between commands
+ * instead of erasing — Static committed content cannot be removed.
+ */
+export class OutputBuffer {
+  constructor() {
+    this.items = [];
+    this.itemCounter = 0;
+    this.listeners = [];
+  }
+
+  /**
+   * Append content as a new item
+   * @param {string} content - Content to append (may contain newlines)
+   * @param {string|null} type - Optional message type: 'ERROR'|'WARNING'|'SUCCESS'|'INFO'|null
+   */
+  append(content, type = null) {
+    if (!content) return;
+
+    this.items.push({ id: ++this.itemCounter, content, type });
+    this.notifyListeners();
+  }
+
+  /**
+   * Insert a blank separator between commands.
+   * Items cannot be removed from Static rendering, so this adds a
+   * visual separator instead of erasing previous content.
+   */
+  clear() {
+    if (this.items.length > 0) {
+      this.items.push({ id: ++this.itemCounter, content: '' });
+      this.notifyListeners();
+    }
+  }
+
+  /**
+   * Get all items (for Static rendering)
+   * @returns {{id: number, content: string}[]} Copy of items array
+   */
+  getItems() {
+    return [...this.items];
+  }
+
+  /**
+   * Get item count
+   * @returns {number} Number of items
+   */
+  getItemCount() {
+    return this.items.length;
+  }
+
+  /**
+   * Get all lines as flat string array (for test compatibility)
+   * @returns {string[]} All content split by newlines
+   */
+  getLines() {
+    return this.items.flatMap(item => item.content.split('\n'));
+  }
+
+  /**
+   * Get line count (for backward compatibility)
+   * @returns {number} Total number of lines across all items
+   */
+  getLineCount() {
+    return this.getLines().length;
+  }
+
+  /**
+   * Reset buffer completely - removes all items.
+   * Used in tests for isolation between test cases.
+   */
+  reset() {
+    this.items = [];
+    this.itemCounter = 0;
+    this.notifyListeners();
+  }
+
+  /**
+   * Subscribe to buffer changes
+   * @param {Function} listener - Callback function (items) => void
+   * @returns {Function} Unsubscribe function
+   */
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners = this.listeners.filter(l => l !== listener);
+    };
+  }
+
+  /**
+   * Notify all listeners of buffer change
+   * @private
+   */
+  notifyListeners() {
+    const items = this.getItems();
+    this.listeners.forEach(listener => listener(items));
+  }
+}
+
+// Singleton instance
+export const outputBuffer = new OutputBuffer();

package/cli/process-manager.js

@@ -0,0 +1,332 @@
+import { spawn, fork } from 'child_process';
+import { EventEmitter } from 'events';
+
+/**
+ * Background Process Manager
+ * Manages lifecycle of long-running background processes
+ */
+export class BackgroundProcessManager extends EventEmitter {
+  constructor() {
+    super();
+    this.processes = new Map(); // id -> processMetadata
+    this.maxOutputLines = 500; // Keep last 500 lines per process
+  }
+
+  /**
+   * Start a background process
+   * @param {Object} options
+   * @param {string} options.name - Human-readable name
+   * @param {string} options.command - Command to execute
+   * @param {string[]} options.args - Command arguments
+   * @param {string} options.cwd - Working directory
+   * @param {Object} options.env - Environment variables
+   * @returns {string} Process ID
+   */
+  startProcess({ name, command, args = [], cwd, env = process.env }) {
+    const id = `${this.sanitizeName(name)}-${Date.now()}`;
+
+    const childProcess = spawn(command, args, {
+      cwd,
+      env,
+      stdio: 'pipe',
+      detached: false
+    });
+
+    const metadata = {
+      id,
+      name,
+      command: `${command} ${args.join(' ')}`,
+      cwd,
+      pid: childProcess.pid,
+      status: 'running',
+      startTime: new Date().toISOString(),
+      exitCode: null,
+      exitSignal: null,
+      output: [],
+      process: childProcess
+    };
+
+    this.processes.set(id, metadata);
+
+    // Capture stdout
+    childProcess.stdout.on('data', (data) => {
+      this.appendOutput(id, 'stdout', data.toString());
+    });
+
+    // Capture stderr
+    childProcess.stderr.on('data', (data) => {
+      this.appendOutput(id, 'stderr', data.toString());
+    });
+
+    // Handle process exit
+    childProcess.on('exit', (code, signal) => {
+      this.handleProcessExit(id, code, signal);
+    });
+
+    // Handle process error
+    childProcess.on('error', (error) => {
+      this.handleProcessError(id, error);
+    });
+
+    this.emit('process-started', { id, name });
+
+    return id;
+  }
+
+  /**
+   * Fork a background process with an IPC channel.
+   * Identical metadata schema to startProcess(); also registers an IPC message handler.
+   * @param {string} name - Human-readable name
+   * @param {string} modulePath - Absolute path to the Node.js module to fork
+   * @param {string[]} args - Module arguments
+   * @param {Function} onMessage - Called with each IPC message from the child
+   * @returns {{ id: string, child: ChildProcess }}
+   */
+  forkProcess(name, modulePath, args = [], onMessage) {
+    const id = `${this.sanitizeName(name)}-${Date.now()}`;
+
+    const child = fork(modulePath, args, {
+      stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+    });
+
+    const metadata = {
+      id,
+      name,
+      command: modulePath,
+      pid: child.pid,
+      status: 'running',
+      startTime: new Date().toISOString(),
+      exitCode: null,
+      exitSignal: null,
+      output: [],
+      process: child
+    };
+
+    this.processes.set(id, metadata);
+
+    // Capture stdout / stderr (same as startProcess)
+    child.stdout?.on('data', (data) => {
+      this.appendOutput(id, 'stdout', data.toString());
+    });
+
+    child.stderr?.on('data', (data) => {
+      this.appendOutput(id, 'stderr', data.toString());
+    });
+
+    // Handle process exit / error
+    child.on('exit', (code, signal) => {
+      this.handleProcessExit(id, code, signal);
+    });
+
+    child.on('error', (error) => {
+      this.handleProcessError(id, error);
+    });
+
+    // Register IPC message handler
+    if (onMessage) child.on('message', onMessage);
+
+    this.emit('process-started', { id, name });
+
+    return { id, child };
+  }
+
+  /**
+   * Stop a running process
+   */
+  stopProcess(id) {
+    const metadata = this.processes.get(id);
+    if (!metadata) return false;
+
+    if (metadata.status === 'running' && metadata.process) {
+      metadata.process.kill('SIGTERM');
+      metadata.status = 'stopped';
+      this.emit('process-stopped', { id, name: metadata.name });
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Find process by PID
+   * @param {number} pid - Process ID to search for
+   * @returns {Object|null} Process metadata or null if not found
+   */
+  findProcessByPid(pid) {
+    for (const metadata of this.processes.values()) {
+      if (metadata.pid === pid) {
+        return metadata;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Remove process from manager by PID
+   * Used when external kill is performed on a managed process
+   * @param {number} pid - Process ID to remove
+   * @returns {boolean} True if process was found and removed
+   */
+  removeProcessByPid(pid) {
+    const process = this.findProcessByPid(pid);
+    if (process) {
+      this.processes.delete(process.id);
+      this.emit('process-removed', { id: process.id, name: process.name, pid });
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get process metadata
+   */
+  getProcess(id) {
+    return this.processes.get(id);
+  }
+
+  /**
+   * Get all processes
+   */
+  getAllProcesses() {
+    return Array.from(this.processes.values());
+  }
+
+  /**
+   * Get running processes only
+   */
+  getRunningProcesses() {
+    return this.getAllProcesses().filter(p => p.status === 'running');
+  }
+
+  /**
+   * Append output to process buffer
+   */
+  appendOutput(id, type, text) {
+    const metadata = this.processes.get(id);
+    if (!metadata) return;
+
+    const lines = text.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      metadata.output.push({
+        timestamp: new Date().toISOString(),
+        type,
+        text: line
+      });
+    }
+
+    // Trim to max lines
+    if (metadata.output.length > this.maxOutputLines) {
+      metadata.output = metadata.output.slice(-this.maxOutputLines);
+    }
+
+    this.emit('output', { id, type, text });
+  }
+
+  /**
+   * Handle process exit
+   */
+  handleProcessExit(id, code, signal) {
+    const metadata = this.processes.get(id);
+    if (!metadata) return;
+
+    metadata.exitCode = code;
+    metadata.exitSignal = signal;
+
+    // Don't overwrite 'stopped' status (intentional termination via stopProcess)
+    // Only set crashed/exited if process wasn't manually stopped
+    if (metadata.status !== 'stopped') {
+      metadata.status = code === 0 ? 'exited' : 'crashed';
+    }
+
+    this.emit('process-exited', {
+      id,
+      name: metadata.name,
+      code,
+      signal,
+      status: metadata.status
+    });
+
+    // Auto-cleanup finished processes after 3 seconds
+    // Gives user time to see final status before removal
+    setTimeout(() => {
+      if (this.processes.has(id)) {
+        this.processes.delete(id);
+        this.emit('process-removed', { id, name: metadata.name });
+      }
+    }, 3000);
+  }
+
+  /**
+   * Handle process error
+   */
+  handleProcessError(id, error) {
+    const metadata = this.processes.get(id);
+    if (!metadata) return;
+
+    metadata.status = 'crashed';
+    this.appendOutput(id, 'stderr', `Process error: ${error.message}`);
+
+    this.emit('process-error', { id, name: metadata.name, error });
+  }
+
+  /**
+   * Clean up finished processes
+   * Removes processes with status: exited, crashed, or stopped
+   */
+  cleanupFinished() {
+    const finished = this.getAllProcesses().filter(
+      p => p.status === 'exited' || p.status === 'crashed' || p.status === 'stopped'
+    );
+
+    for (const process of finished) {
+      this.processes.delete(process.id);
+    }
+
+    return finished.length;
+  }
+
+  /**
+   * Stop all running processes
+   */
+  stopAll() {
+    const running = this.getRunningProcesses();
+
+    for (const process of running) {
+      this.stopProcess(process.id);
+    }
+
+    return running.length;
+  }
+
+  /**
+   * Get process uptime in seconds
+   */
+  getUptime(id) {
+    const metadata = this.processes.get(id);
+    if (!metadata) return 0;
+
+    const start = new Date(metadata.startTime);
+    const now = new Date();
+    return Math.floor((now - start) / 1000);
+  }
+
+  /**
+   * Format uptime as human-readable string
+   */
+  formatUptime(seconds) {
+    if (seconds < 60) return `${seconds}s`;
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    return `${hours}h ${minutes}m`;
+  }
+
+  /**
+   * Sanitize name for use as ID prefix
+   */
+  sanitizeName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  }
+}