@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/cli/model-selector.js

@@ -0,0 +1,270 @@
+#!/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 || process.env.OPENAI_OAUTH_TOKEN),
+    'GEMINI_API_KEY':    !!process.env.GEMINI_API_KEY,
+    'XIAOMI_API_KEY':    !!process.env.XIAOMI_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

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { spawn, fork } from 'child_process';
 import { EventEmitter } from 'events';
 
 /**
@@ -73,6 +73,63 @@ export class BackgroundProcessManager extends EventEmitter {
     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
    */
@@ -175,7 +232,12 @@ export class BackgroundProcessManager extends EventEmitter {
 
     metadata.exitCode = code;
     metadata.exitSignal = signal;
-    metadata.status = code === 0 ? 'exited' : 'crashed';
+
+    // 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,
@@ -184,6 +246,15 @@ export class BackgroundProcessManager extends EventEmitter {
       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);
   }
 
   /**

package/cli/prompt-logger.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+
+export class PromptLogger {
+  /**
+   * @param {string} projectRoot  - absolute path to .avc parent
+   * @param {string} ceremony     - e.g. 'sprint-planning', 'sponsor-call'
+   */
+  constructor(projectRoot, ceremony) {
+    this.ceremony = ceremony;
+    this.callCount = 0;
+    this.runDir = null;
+
+    const avcDir = path.join(projectRoot, '.avc');
+    if (!fs.existsSync(avcDir)) return; // not an AVC project — silently skip
+
+    const runTs = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+    this.runDir = path.join(avcDir, 'logs', 'prompts', `${ceremony}-${runTs}`);
+    fs.mkdirSync(this.runDir, { recursive: true });
+
+    this._pruneOldRuns(path.join(avcDir, 'logs', 'prompts'), ceremony, 5);
+  }
+
+  /**
+   * Write one call record. Called by _trackTokens in LLMProvider.
+   * @param {object} payload
+   */
+  write(payload) {
+    if (!this.runDir) return;
+    this.callCount += 1;
+    const seq = String(this.callCount).padStart(3, '0');
+    const stage = (payload.stage || 'unknown').replace(/\s+/g, '-');
+    const timeStr = new Date().toISOString().substring(11, 19).replace(/:/g, '-');
+    const filename = `${seq}-${stage}-${timeStr}.json`;
+    try {
+      fs.writeFileSync(
+        path.join(this.runDir, filename),
+        JSON.stringify(payload, null, 2),
+        'utf8'
+      );
+    } catch { /* non-fatal */ }
+  }
+
+  _pruneOldRuns(promptsDir, ceremony, keep) {
+    if (!fs.existsSync(promptsDir)) return;
+    const dirs = fs.readdirSync(promptsDir)
+      .filter(d => d.startsWith(`${ceremony}-`))
+      .map(d => ({ name: d, full: path.join(promptsDir, d) }))
+      .sort((a, b) => a.name.localeCompare(b.name)); // oldest first
+    while (dirs.length >= keep) {
+      const oldest = dirs.shift();
+      try {
+        fs.rmSync(oldest.full, { recursive: true, force: true });
+      } catch { /* non-fatal */ }
+    }
+  }
+}