@agile-vibe-coding/avc 0.1.0 → 0.1.1

package/cli/llm-claude.js

@@ -0,0 +1,27 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { LLMProvider } from './llm-provider.js';
+
+export class ClaudeProvider extends LLMProvider {
+  constructor(model) { super('claude', model); }
+
+  _createClient() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error('ANTHROPIC_API_KEY not set. Add it to your .env file.');
+    return new Anthropic({ apiKey });
+  }
+
+  async _callProvider(prompt, maxTokens, systemInstructions) {
+    const params = {
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: 'user', content: prompt }]
+    };
+
+    if (systemInstructions) {
+      params.system = systemInstructions;
+    }
+
+    const response = await this._client.messages.create(params);
+    return response.content[0].text;
+  }
+}

package/cli/llm-gemini.js

@@ -0,0 +1,30 @@
+import { GoogleGenAI } from '@google/genai';
+import { LLMProvider } from './llm-provider.js';
+
+export class GeminiProvider extends LLMProvider {
+  constructor(model = 'gemini-2.5-flash') { super('gemini', model); }
+
+  _createClient() {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) throw new Error('GEMINI_API_KEY not set. Add it to your .env file.');
+    return new GoogleGenAI({ apiKey });
+  }
+
+  async _callProvider(prompt, maxTokens, systemInstructions) {
+    const params = {
+      model: this.model,
+      contents: prompt,
+      generationConfig: { maxOutputTokens: maxTokens }
+    };
+
+    if (systemInstructions) {
+      params.systemInstruction = systemInstructions;
+    }
+
+    const response = await this._client.models.generateContent(params);
+    if (!response.text) {
+      throw new Error('Gemini returned no text (possible safety filter block).');
+    }
+    return response.text;
+  }
+}

package/cli/llm-provider.js

@@ -0,0 +1,63 @@
+export class LLMProvider {
+  constructor(providerName, model) {
+    this.providerName = providerName;
+    this.model = model;
+    this._client = null;
+  }
+
+  // Factory — async because of dynamic import (only loads the SDK you need)
+  static async create(providerName, model) {
+    switch (providerName) {
+      case 'claude': {
+        const { ClaudeProvider } = await import('./llm-claude.js');
+        return new ClaudeProvider(model);
+      }
+      case 'gemini': {
+        const { GeminiProvider } = await import('./llm-gemini.js');
+        return new GeminiProvider(model);
+      }
+      default:
+        throw new Error(`Unknown LLM provider: "${providerName}". Supported: claude, gemini`);
+    }
+  }
+
+  // Public API — single method, callers never touch SDK objects
+  async generate(prompt, maxTokens = 256, systemInstructions = null) {
+    if (!this._client) {
+      this._client = this._createClient();
+    }
+    return this._callProvider(prompt, maxTokens, systemInstructions);
+  }
+
+  // Validate API key and provider connectivity with a minimal test call
+  async validateApiKey() {
+    try {
+      // Make a minimal API call (just asks for a single word)
+      await this.generate('Reply with only the word "ok"', 10);
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message,
+        code: error.status || error.code
+      };
+    }
+  }
+
+  // Static helper to validate a provider config
+  static async validate(providerName, model) {
+    try {
+      const provider = await LLMProvider.create(providerName, model);
+      return await provider.validateApiKey();
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Subclass hooks — throw if not overridden
+  _createClient() { throw new Error(`${this.constructor.name} must implement _createClient()`); }
+  async _callProvider(prompt, maxTokens, systemInstructions) { throw new Error(`${this.constructor.name} must implement _callProvider()`); }
+}

package/cli/logger.js

@@ -5,31 +5,48 @@ import os from 'os';
 /**
  * Logger - Writes debug and error logs to file
  *
- * Log location: ~/.avc/logs/avc.log
+ * Log location: <project>/.avc/logs/avc.log (or ~/.avc/logs/avc.log if no project)
  * Log rotation: Keeps last 10MB, rotates to avc.log.old
  */
 export class Logger {
-  constructor(componentName = 'AVC') {
+  constructor(componentName = 'AVC', projectRoot = null) {
     this.componentName = componentName;
-    this.logDir = path.join(os.homedir(), '.avc', 'logs');
+
+    // Only log if .avc folder exists - don't create it, don't use fallback
+    const baseDir = projectRoot || process.cwd();
+    const projectAvcDir = path.join(baseDir, '.avc');
+
+    if (!fs.existsSync(projectAvcDir)) {
+      // No .avc folder - disable logging
+      this.loggingDisabled = true;
+      return;
+    }
+
+    // .avc exists, set up logging
+    this.logDir = path.join(projectAvcDir, 'logs');
     this.logFile = path.join(this.logDir, 'avc.log');
     this.maxLogSize = 10 * 1024 * 1024; // 10MB
+    this.loggingDisabled = false;
 
     this.ensureLogDir();
   }
 
   ensureLogDir() {
+    if (this.loggingDisabled) return;
+
     try {
       if (!fs.existsSync(this.logDir)) {
         fs.mkdirSync(this.logDir, { recursive: true });
       }
     } catch (error) {
       // Silently fail if we can't create log directory
-      console.error('Failed to create log directory:', error.message);
+      this.loggingDisabled = true;
     }
   }
 
   rotateLogIfNeeded() {
+    if (this.loggingDisabled) return;
+
     try {
       if (fs.existsSync(this.logFile)) {
         const stats = fs.statSync(this.logFile);
@@ -71,13 +88,17 @@ export class Logger {
   }
 
   writeLog(level, message, data = null) {
+    // Skip logging if directory creation failed
+    if (this.loggingDisabled) return;
+
     try {
       this.rotateLogIfNeeded();
       const logMessage = this.formatMessage(level, message, data);
       fs.appendFileSync(this.logFile, logMessage, 'utf8');
     } catch (error) {
       // Silently fail if we can't write to log
-      console.error('Failed to write log:', error.message);
+      // Disable further logging attempts to avoid repeated errors
+      this.loggingDisabled = true;
     }
   }
 
@@ -99,6 +120,10 @@ export class Logger {
 
   // Read recent logs (last N lines)
   readRecentLogs(lines = 50) {
+    if (this.loggingDisabled) {
+      return 'No logs available (project not initialized).';
+    }
+
     try {
       if (!fs.existsSync(this.logFile)) {
         return 'No logs available yet.';
@@ -116,6 +141,8 @@ export class Logger {
 
   // Clear all logs
   clearLogs() {
+    if (this.loggingDisabled) return;
+
     try {
       if (fs.existsSync(this.logFile)) {
         fs.unlinkSync(this.logFile);

package/cli/process-manager.js

@@ -0,0 +1,261 @@
+import { spawn } 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;
+  }
+
+  /**
+   * 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;
+    metadata.status = code === 0 ? 'exited' : 'crashed';
+
+    this.emit('process-exited', {
+      id,
+      name: metadata.name,
+      code,
+      signal,
+      status: metadata.status
+    });
+  }
+
+  /**
+   * 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, '');
+  }
+}