@agile-vibe-coding/avc 0.1.0

package/cli/update-checker.js

@@ -0,0 +1,218 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+import { updateLogger } from './logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * UpdateChecker - Checks npm registry for new versions
+ * Runs in background and updates state file
+ */
+export class UpdateChecker {
+  constructor() {
+    // Use user's home directory for state (works across installations)
+    this.stateDir = path.join(os.homedir(), '.avc');
+    this.stateFile = path.join(this.stateDir, 'update-state.json');
+    this.settingsFile = path.join(this.stateDir, 'settings.json');
+    this.packageName = '@agile-vibe-coding/avc';
+    this.defaultCheckInterval = 60 * 60 * 1000; // 1 hour default
+  }
+
+  // Initialize state directory
+  initStateDir() {
+    if (!existsSync(this.stateDir)) {
+      mkdirSync(this.stateDir, { recursive: true });
+    }
+  }
+
+  // Read settings
+  readSettings() {
+    if (!existsSync(this.settingsFile)) {
+      return {
+        autoUpdate: {
+          enabled: true,
+          checkInterval: this.defaultCheckInterval,
+          silent: true,
+          notifyUser: true
+        }
+      };
+    }
+
+    try {
+      return JSON.parse(readFileSync(this.settingsFile, 'utf8'));
+    } catch (error) {
+      return {
+        autoUpdate: {
+          enabled: true,
+          checkInterval: this.defaultCheckInterval,
+          silent: true,
+          notifyUser: true
+        }
+      };
+    }
+  }
+
+  // Write settings
+  writeSettings(settings) {
+    this.initStateDir();
+    writeFileSync(this.settingsFile, JSON.stringify(settings, null, 2));
+  }
+
+  // Get current version from package.json
+  getCurrentVersion() {
+    try {
+      const packageJsonPath = path.join(__dirname, '..', 'package.json');
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+      updateLogger.debug(`Current version: ${packageJson.version}`);
+      return packageJson.version;
+    } catch (error) {
+      updateLogger.error('Failed to read current version', error);
+      console.error('Failed to read current version:', error.message);
+      return null;
+    }
+  }
+
+  // Check npm registry for latest version
+  async getLatestVersion() {
+    try {
+      updateLogger.debug('Checking npm registry for latest version');
+      const result = execSync(`npm view ${this.packageName} version`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        stdio: ['pipe', 'pipe', 'ignore'] // Suppress stderr
+      });
+      const version = result.trim();
+      updateLogger.debug(`Latest version on npm: ${version}`);
+      return version;
+    } catch (error) {
+      updateLogger.error('Failed to check npm registry', error);
+      // Silently fail - will retry on next check
+      return null;
+    }
+  }
+
+  // Compare versions (returns true if remote is newer)
+  isNewerVersion(current, latest) {
+    if (!current || !latest) return false;
+
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+
+    for (let i = 0; i < 3; i++) {
+      if (latestParts[i] > currentParts[i]) return true;
+      if (latestParts[i] < currentParts[i]) return false;
+    }
+    return false;
+  }
+
+  // Read current state
+  readState() {
+    if (!existsSync(this.stateFile)) {
+      const currentVersion = this.getCurrentVersion();
+      return {
+        currentVersion: currentVersion,
+        latestVersion: null,
+        lastChecked: null,
+        updateAvailable: false,
+        updateReady: false,
+        downloadedVersion: null,
+        updateStatus: 'idle',
+        errorMessage: null,
+        userDismissed: false,
+        dismissedAt: null
+      };
+    }
+
+    try {
+      return JSON.parse(readFileSync(this.stateFile, 'utf8'));
+    } catch (error) {
+      return this.readState(); // Return default if parse fails
+    }
+  }
+
+  // Write state
+  writeState(state) {
+    this.initStateDir();
+    writeFileSync(this.stateFile, JSON.stringify(state, null, 2));
+  }
+
+  // Check for updates
+  async checkForUpdates() {
+    updateLogger.info('Checking for updates');
+    const settings = this.readSettings();
+
+    // Don't check if auto-update disabled
+    if (!settings.autoUpdate.enabled) {
+      updateLogger.info('Auto-update disabled in settings');
+      return { updateAvailable: false, disabled: true };
+    }
+
+    const currentVersion = this.getCurrentVersion();
+    const latestVersion = await this.getLatestVersion();
+
+    if (!currentVersion) {
+      updateLogger.error('Failed to read current version');
+      return { updateAvailable: false, error: 'Failed to read current version' };
+    }
+
+    if (!latestVersion) {
+      updateLogger.error('Failed to check for updates from npm');
+      return { updateAvailable: false, error: 'Failed to check for updates' };
+    }
+
+    const updateAvailable = this.isNewerVersion(currentVersion, latestVersion);
+
+    updateLogger.info(`Version check: current=${currentVersion}, latest=${latestVersion}, updateAvailable=${updateAvailable}`);
+
+    const state = this.readState();
+    state.currentVersion = currentVersion;
+    state.latestVersion = latestVersion;
+    state.lastChecked = new Date().toISOString();
+    state.updateAvailable = updateAvailable;
+
+    // Reset dismissed flag if new version available
+    if (updateAvailable && state.downloadedVersion !== latestVersion) {
+      updateLogger.info(`New version available: ${latestVersion}`);
+      state.userDismissed = false;
+      state.updateReady = false;
+      state.updateStatus = 'pending';
+    }
+
+    this.writeState(state);
+
+    return { updateAvailable, currentVersion, latestVersion };
+  }
+
+  // Start background checker
+  startBackgroundChecker() {
+    const settings = this.readSettings();
+
+    // Don't start if disabled
+    if (!settings.autoUpdate.enabled) {
+      return;
+    }
+
+    // Check immediately on start (async, don't block)
+    this.checkForUpdates().catch(() => {
+      // Silently fail
+    });
+
+    // Check at configured interval
+    const interval = settings.autoUpdate.checkInterval || this.defaultCheckInterval;
+    setInterval(() => {
+      this.checkForUpdates().catch(() => {
+        // Silently fail
+      });
+    }, interval);
+  }
+
+  // Get check interval from settings
+  getCheckInterval() {
+    const settings = this.readSettings();
+    return settings.autoUpdate.checkInterval || this.defaultCheckInterval;
+  }
+}

package/cli/update-installer.js

@@ -0,0 +1,184 @@
+import { spawn, execSync } from 'child_process';
+import { UpdateChecker } from './update-checker.js';
+import { installerLogger } from './logger.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * UpdateInstaller - Handles npm package installation
+ * Runs npm install in background
+ */
+export class UpdateInstaller {
+  constructor() {
+    this.checker = new UpdateChecker();
+    this.packageName = '@agile-vibe-coding/avc';
+  }
+
+  // Check if npm is available
+  checkNpmAvailable() {
+    try {
+      execSync('npm --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      installerLogger.error('npm availability check failed', error);
+      return false;
+    }
+  }
+
+  // Install update in background
+  async installUpdate(version) {
+    installerLogger.info(`Starting update installation for version ${version}`);
+    const state = this.checker.readState();
+
+    // Don't install if already in progress
+    if (state.updateStatus === 'downloading') {
+      installerLogger.warn('Update already in progress');
+      return { success: false, message: 'Update already in progress' };
+    }
+
+    // Check if npm is available
+    if (!this.checkNpmAvailable()) {
+      installerLogger.error('npm not found on system');
+      state.updateStatus = 'failed';
+      state.errorMessage = 'npm not found. Please install npm to enable auto-updates.';
+      this.checker.writeState(state);
+      return { success: false, message: state.errorMessage };
+    }
+
+    // Update state to downloading
+    installerLogger.debug('Setting status to downloading');
+    state.updateStatus = 'downloading';
+    state.errorMessage = null;
+    this.checker.writeState(state);
+
+    return new Promise((resolve) => {
+      // Prepare log files for npm output
+      const logDir = path.join(os.homedir(), '.avc', 'logs');
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+
+      const npmLogFile = path.join(logDir, 'npm-install.log');
+      const npmErrorLogFile = path.join(logDir, 'npm-install-error.log');
+
+      // Use shell redirection for reliable log capture with detached process
+      const npmCmd = `npm install -g "${this.packageName}@${version}" >> "${npmLogFile}" 2>> "${npmErrorLogFile}"`;
+
+      installerLogger.info(`Executing: npm install -g ${this.packageName}@${version}`);
+      installerLogger.debug(`npm output will be logged to ${npmLogFile}`);
+
+      const npmProcess = spawn(npmCmd, [], {
+        detached: true,
+        stdio: 'ignore',
+        shell: true
+      });
+
+      npmProcess.unref(); // Allow parent to exit independently
+
+      npmProcess.on('close', (code) => {
+        const state = this.checker.readState();
+        installerLogger.debug(`npm install exited with code ${code}`);
+
+        if (code === 0) {
+          // Success
+          installerLogger.info(`Update installed successfully: ${version}`);
+          state.updateStatus = 'ready';
+          state.updateReady = true;
+          state.downloadedVersion = version;
+          state.errorMessage = null;
+          this.checker.writeState(state);
+
+          resolve({ success: true, version });
+        } else if (code === 243 || code === 1) {
+          // Permission error (common code 243 on Unix, 1 on Windows)
+          const errorMsg = `Permission denied. Try: sudo npm install -g ${this.packageName}@${version}\nLogs: ${npmLogFile}`;
+          installerLogger.error(`Installation failed with permission error (code ${code})`, { error: errorMsg, logFile: npmLogFile });
+          state.updateStatus = 'failed';
+          state.updateReady = false;
+          state.errorMessage = errorMsg;
+          this.checker.writeState(state);
+
+          resolve({ success: false, message: state.errorMessage, needsSudo: true });
+        } else {
+          // Other error
+          const errorMsg = `Installation failed with code ${code}. Check logs: ${npmLogFile}`;
+          installerLogger.error(errorMsg, { logFile: npmLogFile, errorLogFile: npmErrorLogFile });
+          state.updateStatus = 'failed';
+          state.updateReady = false;
+          state.errorMessage = errorMsg;
+          this.checker.writeState(state);
+
+          resolve({ success: false, message: state.errorMessage });
+        }
+      });
+
+      npmProcess.on('error', (error) => {
+        const state = this.checker.readState();
+        installerLogger.error('npm process error', error);
+
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+          const errorMsg = `Permission denied. Try: sudo npm install -g ${this.packageName}@${version}\nLogs: ${npmLogFile}`;
+          installerLogger.error(`Permission error: ${error.code}`, { error: errorMsg, logFile: npmLogFile });
+          state.updateStatus = 'failed';
+          state.updateReady = false;
+          state.errorMessage = errorMsg;
+          this.checker.writeState(state);
+
+          resolve({ success: false, message: state.errorMessage, needsSudo: true });
+        } else {
+          const errorMsg = `${error.message}. Check logs: ${npmLogFile}`;
+          installerLogger.error(`Unexpected npm process error: ${error.message}`, { error, logFile: npmLogFile });
+          state.updateStatus = 'failed';
+          state.updateReady = false;
+          state.errorMessage = errorMsg;
+          this.checker.writeState(state);
+
+          resolve({ success: false, message: state.errorMessage });
+        }
+      });
+    });
+  }
+
+  // Trigger update installation
+  async triggerUpdate() {
+    const state = this.checker.readState();
+
+    if (!state.updateAvailable) {
+      return { success: false, message: 'No update available' };
+    }
+
+    if (state.updateReady) {
+      return { success: true, message: 'Update already installed', alreadyReady: true };
+    }
+
+    if (state.updateStatus === 'downloading') {
+      return { success: false, message: 'Update already in progress', inProgress: true };
+    }
+
+    return await this.installUpdate(state.latestVersion);
+  }
+
+  // Auto-trigger update if available and not dismissed
+  async autoTriggerUpdate() {
+    const state = this.checker.readState();
+    const settings = this.checker.readSettings();
+
+    // Don't auto-install if disabled or user dismissed
+    if (!settings.autoUpdate.enabled || state.userDismissed) {
+      return { success: false, message: 'Auto-update disabled or dismissed' };
+    }
+
+    // Don't install if already ready or downloading
+    if (state.updateReady || state.updateStatus === 'downloading') {
+      return { success: false, message: 'Update already processed' };
+    }
+
+    // Only auto-install if update available and in idle/pending state
+    if (state.updateAvailable && (state.updateStatus === 'idle' || state.updateStatus === 'pending')) {
+      return await this.triggerUpdate();
+    }
+
+    return { success: false, message: 'No action needed' };
+  }
+}

package/cli/update-notifier.js

@@ -0,0 +1,170 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { UpdateChecker } from './update-checker.js';
+
+/**
+ * Update notification components for Ink
+ */
+
+// Update notification banner (full notification)
+export const UpdateNotification = ({ onDismiss }) => {
+  const checker = new UpdateChecker();
+  const state = checker.readState();
+
+  // Don't show if no update available
+  if (!state.updateAvailable) return null;
+
+  // Don't show if user dismissed
+  if (state.userDismissed) return null;
+
+  // Update downloading
+  if (state.updateStatus === 'downloading') {
+    return React.createElement(Box, {
+      borderStyle: 'round',
+      borderColor: 'blue',
+      paddingX: 2,
+      paddingY: 1,
+      marginBottom: 1
+    },
+      React.createElement(Box, { flexDirection: 'column' },
+        React.createElement(Text, { bold: true, color: 'blue' },
+          `⬇️  Downloading update v${state.latestVersion}...`
+        ),
+        React.createElement(Text, { dimColor: true },
+          'This happens in the background. Continue working!'
+        )
+      )
+    );
+  }
+
+  // Update ready to use
+  if (state.updateReady) {
+    return React.createElement(Box, {
+      borderStyle: 'round',
+      borderColor: 'green',
+      paddingX: 2,
+      paddingY: 1,
+      marginBottom: 1
+    },
+      React.createElement(Box, { flexDirection: 'column' },
+        React.createElement(Text, { bold: true, color: 'green' },
+          `✅ Update v${state.downloadedVersion} ready!`
+        ),
+        React.createElement(Text, null,
+          'Restart to use the new version'
+        ),
+        React.createElement(Box, { marginTop: 1, flexDirection: 'row' },
+          React.createElement(Text, { dimColor: true },
+            'Type '
+          ),
+          React.createElement(Text, { color: 'cyan', bold: true },
+            '/restart'
+          ),
+          React.createElement(Text, { dimColor: true },
+            ' or press '
+          ),
+          React.createElement(Text, { color: 'cyan', bold: true },
+            'Ctrl+R'
+          )
+        ),
+        React.createElement(Box, { marginTop: 1, flexDirection: 'row' },
+          React.createElement(Text, { dimColor: true, italic: true },
+            'Press '
+          ),
+          React.createElement(Text, { color: 'yellow' },
+            'Esc'
+          ),
+          React.createElement(Text, { dimColor: true, italic: true },
+            ' to dismiss'
+          )
+        )
+      )
+    );
+  }
+
+  // Update failed
+  if (state.updateStatus === 'failed') {
+    const needsSudo = state.errorMessage && state.errorMessage.includes('sudo');
+
+    return React.createElement(Box, {
+      borderStyle: 'round',
+      borderColor: 'red',
+      paddingX: 2,
+      paddingY: 1,
+      marginBottom: 1
+    },
+      React.createElement(Box, { flexDirection: 'column' },
+        React.createElement(Text, { bold: true, color: 'red' },
+          '❌ Update failed'
+        ),
+        React.createElement(Text, null,
+          state.errorMessage || 'Unknown error'
+        ),
+        needsSudo && React.createElement(Box, { marginTop: 1 },
+          React.createElement(Text, { dimColor: true },
+            'Manual install: '
+          ),
+          React.createElement(Text, { color: 'cyan' },
+            state.errorMessage.split('Try: ')[1]
+          )
+        ),
+        React.createElement(Text, { dimColor: true, marginTop: 1 },
+          'Will retry on next check'
+        )
+      )
+    );
+  }
+
+  // Update pending (just discovered)
+  if (state.updateStatus === 'pending' || state.updateStatus === 'idle') {
+    return React.createElement(Box, {
+      borderStyle: 'round',
+      borderColor: 'yellow',
+      paddingX: 2,
+      paddingY: 1,
+      marginBottom: 1
+    },
+      React.createElement(Box, { flexDirection: 'column' },
+        React.createElement(Text, { bold: true, color: 'yellow' },
+          `📦 Update available: v${state.latestVersion}`
+        ),
+        React.createElement(Text, null,
+          'Installing in background...'
+        ),
+        React.createElement(Text, { dimColor: true, italic: true },
+          'You will be notified when ready'
+        )
+      )
+    );
+  }
+
+  return null;
+};
+
+// Update status badge (compact, for banner)
+export const UpdateStatusBadge = () => {
+  const checker = new UpdateChecker();
+  const state = checker.readState();
+
+  if (!state.updateAvailable || state.userDismissed) return null;
+
+  if (state.updateReady) {
+    return React.createElement(Text, { color: 'green', bold: true },
+      ' [Update Ready!]'
+    );
+  }
+
+  if (state.updateStatus === 'downloading') {
+    return React.createElement(Text, { color: 'blue', bold: true },
+      ' [Updating...]'
+    );
+  }
+
+  if (state.updateStatus === 'pending' || state.updateStatus === 'idle') {
+    return React.createElement(Text, { color: 'yellow', bold: true },
+      ' [Update Available]'
+    );
+  }
+
+  return null;
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@agile-vibe-coding/avc",
+  "version": "0.1.0",
+  "description": "Agile Vibe Coding (AVC) - Framework for managing AI agent-based software development projects",
+  "type": "module",
+  "main": "cli/index.js",
+  "bin": {
+    "avc": "./cli/index.js"
+  },
+  "files": [
+    "cli/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"No tests specified yet\" && exit 0",
+    "prepublishOnly": "echo \"Running pre-publish checks...\" && npm test"
+  },
+  "keywords": [
+    "avc",
+    "agile-vibe-coding",
+    "ai-agents",
+    "llm",
+    "claude",
+    "chatgpt",
+    "agile",
+    "framework",
+    "project-management",
+    "automation",
+    "cli",
+    "workflow"
+  ],
+  "author": "Nacho Coll",
+  "license": "MIT",
+  "homepage": "https://agilevibecoding.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NachoColl/agilevibecoding.git",
+    "directory": "src"
+  },
+  "bugs": {
+    "url": "https://github.com/NachoColl/agilevibecoding/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.20.0",
+    "dotenv": "^16.4.0",
+    "ink": "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^18.3.1"
+  }
+}