vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/InstallationType.js

@@ -0,0 +1,254 @@
+/**
+ * Installation Type Enumeration
+ * 
+ * Defines types of installation methods for Windows agents.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Installation type enumeration
+ * These represent different approaches to installing AI agents on Windows
+ */
+const InstallationType = {
+  // Windows Package Manager (native)
+  WINGET: 'WINGET',
+  
+  // Node Package Manager (cross-platform)
+  NPM: 'NPM',
+  
+  // Yarn Package Manager (cross-platform)
+  YARN: 'YARN',
+  
+  // Direct installation methods (curl, wget, etc.)
+  DIRECT: 'DIRECT',
+  
+  // Homebrew (macOS and Linux)
+  HOMEBREW: 'HOMEBREW',
+  
+  // Go installation
+  GO: 'GO',
+  
+  // PowerShell script (vendor-specific)
+  POWERSHELL: 'POWERSHELL',
+  
+  // Chocolatey Package Manager (community)
+  CHOCOLATEY: 'CHOCOLATEY'
+};
+
+/**
+ * Check if installation type is native to Windows
+ * @param {string} type - Installation type to check
+ * @returns {boolean}
+ */
+function isNativeWindows(type) {
+  return [InstallationType.WINGET, InstallationType.POWERSHELL, InstallationType.CHOCOLATEY].includes(type);
+}
+
+/**
+ * Check if installation type requires external dependencies
+ * @param {string} type - Installation type to check
+ * @returns {boolean}
+ */
+function requiresExternalDependency(type) {
+  return [InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW, InstallationType.GO].includes(type);
+}
+
+/**
+ * Check if installation type supports automatic updates
+ * @param {string} type - Installation type to check
+ * @returns {boolean}
+ */
+function supportsAutoUpdate(type) {
+  return [InstallationType.WINGET, InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW].includes(type);
+}
+
+/**
+ * Check if installation type requires internet connection
+ * @param {string} type - Installation type to check
+ * @returns {boolean}
+ */
+function requiresInternet(type) {
+  return Object.values(InstallationType).includes(type); // All require internet
+}
+
+/**
+ * Get installation type priority (lower numbers = higher priority)
+ * @param {string} type - Installation type
+ * @returns {number} - Priority value
+ */
+function getTypePriority(type) {
+  const priorities = {
+    [InstallationType.WINGET]: 1, // Native Windows, official support
+    [InstallationType.POWERSHELL]: 2, // Vendor-specific official method
+    [InstallationType.NPM]: 3, // Cross-platform, widely used
+    [InstallationType.YARN]: 3, // Cross-platform, widely used
+    [InstallationType.HOMEBREW]: 3, // Cross-platform, widely used
+    [InstallationType.GO]: 4, // Cross-platform, Go-specific
+    [InstallationType.DIRECT]: 5, // Direct download, universal
+    [InstallationType.CHOCOLATEY]: 6 // Community-maintained
+  };
+  return priorities[type] || 10;
+}
+
+/**
+ * Get installation type description
+ * @param {string} type - Installation type
+ * @returns {string} - Human-readable description
+ */
+function getTypeDescription(type) {
+  const descriptions = {
+    [InstallationType.WINGET]: 'Windows Package Manager (native)',
+    [InstallationType.NPM]: 'Node Package Manager (cross-platform)',
+    [InstallationType.YARN]: 'Yarn Package Manager (cross-platform)',
+    [InstallationType.HOMEBREW]: 'Homebrew Package Manager (macOS/Linux)',
+    [InstallationType.GO]: 'Go installation (cross-platform)',
+    [InstallationType.POWERSHELL]: 'PowerShell script (vendor-specific)',
+    [InstallationType.CHOCOLATEY]: 'Chocolatey Package Manager (community)',
+    [InstallationType.DIRECT]: 'Direct installation script (curl/wget)'
+  };
+
+  return descriptions[type] || 'Unknown installation type';
+}
+
+/**
+ * Get all possible installation types
+ * @returns {string[]} - Array of all type values
+ */
+function getAllTypes() {
+  return Object.values(InstallationType);
+}
+
+/**
+ * Check if a value is a valid InstallationType
+ * @param {string} type - Type to validate
+ * @returns {boolean} - True if valid
+ */
+function isValidType(type) {
+  return getAllTypes().includes(type);
+}
+
+/**
+ * Get preferred installation types in order of preference
+ * @returns {string[]} - Array of types in priority order
+ */
+function getPreferredTypes() {
+  return getAllTypes().sort((a, b) => getTypePriority(a) - getTypePriority(b));
+}
+
+/**
+ * Check if installation type is available on current platform
+ * @param {string} type - Installation type to check
+ * @returns {boolean} - True if available
+ */
+function isAvailableOnPlatform(type) {
+  // All types are potentially available on Windows
+  if (process.platform === 'win32') {
+    return true;
+  }
+  
+  // On non-Windows platforms, only cross-platform types are available
+  const crossPlatformTypes = [
+    InstallationType.NPM, 
+    InstallationType.YARN, 
+    InstallationType.DIRECT, 
+    InstallationType.HOMEBREW, 
+    InstallationType.GO
+  ];
+  return crossPlatformTypes.includes(type);
+}
+
+/**
+ * Get system requirements for installation type
+ * @param {string} type - Installation type
+ * @returns {string[]} - Array of requirements
+ */
+function getSystemRequirements(type) {
+  const requirements = {
+    [InstallationType.WINGET]: ['windows'],
+    [InstallationType.NPM]: ['node.js'],
+    [InstallationType.YARN]: ['node.js'],
+    [InstallationType.HOMEBREW]: ['homebrew'],
+    [InstallationType.GO]: ['go'],
+    [InstallationType.POWERSHELL]: ['windows', 'powershell'],
+    [InstallationType.CHOCOLATEY]: ['windows'],
+    [InstallationType.DIRECT]: ['curl', 'bash']
+  };
+
+  return requirements[type] || [];
+}
+
+/**
+ * Get typical installation commands for each type
+ * @param {string} type - Installation type
+ * @returns {Object} - Command templates
+ */
+function getCommandTemplates(type) {
+  const templates = {
+    [InstallationType.WINGET]: {
+      install: 'winget install {packageId}',
+      uninstall: 'winget uninstall {packageId}',
+      upgrade: 'winget upgrade {packageId}',
+      info: 'winget show {packageId}'
+    },
+    [InstallationType.NPM]: {
+      install: 'npm install -g {packageId}',
+      uninstall: 'npm uninstall -g {packageId}',
+      upgrade: 'npm update -g {packageId}',
+      info: 'npm info {packageId}'
+    },
+    [InstallationType.YARN]: {
+      install: 'yarn global add {packageId}',
+      uninstall: 'yarn global remove {packageId}',
+      upgrade: 'yarn global upgrade {packageId}',
+      info: 'yarn info {packageId}'
+    },
+    [InstallationType.HOMEBREW]: {
+      install: 'brew install {packageId}',
+      uninstall: 'brew uninstall {packageId}',
+      upgrade: 'brew upgrade {packageId}',
+      info: 'brew info {packageId}'
+    },
+    [InstallationType.GO]: {
+      install: 'go install {packageId}',
+      uninstall: 'go clean -modcache {packageId}',
+      upgrade: 'go install {packageId}@latest',
+      info: 'go list -m {packageId}'
+    },
+    [InstallationType.POWERSHELL]: {
+      install: '{command}',
+      uninstall: 'Remove via vendor-specific method',
+      upgrade: 'Re-run installation script',
+      info: 'Check vendor documentation'
+    },
+    [InstallationType.CHOCOLATEY]: {
+      install: 'choco install {packageId}',
+      uninstall: 'choco uninstall {packageId}',
+      upgrade: 'choco upgrade {packageId}',
+      info: 'choco info {packageId}'
+    },
+    [InstallationType.DIRECT]: {
+      install: '{command}',
+      uninstall: 'Remove via vendor-specific method',
+      upgrade: 'Re-run installation script',
+      info: 'Check vendor documentation'
+    }
+  };
+
+  return templates[type] || {};
+}
+
+module.exports = {
+  InstallationType,
+  isNativeWindows,
+  requiresExternalDependency,
+  supportsAutoUpdate,
+  requiresInternet,
+  getTypePriority,
+  getTypeDescription,
+  getAllTypes,
+  isValidType,
+  getPreferredTypes,
+  isAvailableOnPlatform,
+  getSystemRequirements,
+  getCommandTemplates
+};

package/src/agents/OperationTypes.js

@@ -0,0 +1,310 @@
+/**
+ * Operation Types and Status Enumerations
+ * 
+ * Defines types and statuses for logged operations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Operation type enumeration
+ * These represent different types of agent operations
+ */
+const OperationType = {
+  // Agent installation
+  INSTALL: 'INSTALL',
+  
+  // Agent verification
+  VERIFY: 'VERIFY',
+  
+  // Status check
+  CHECK_STATUS: 'CHECK_STATUS',
+  
+  // Agent update
+  UPDATE: 'UPDATE',
+  
+  // Agent removal
+  UNINSTALL: 'UNINSTALL'
+};
+
+/**
+ * Operation status enumeration
+ * These represent the lifecycle states of operations
+ */
+const OperationStatus = {
+  // Operation initiated
+  STARTED: 'STARTED',
+  
+  // Operation finished successfully
+  COMPLETED: 'COMPLETED',
+  
+  // Operation failed
+  FAILED: 'FAILED',
+  
+  // Operation timed out
+  TIMEOUT: 'TIMEOUT',
+  
+  // Operation was cancelled
+  CANCELLED: 'CANCELLED'
+};
+
+/**
+ * Check if operation type is installation-related
+ * @param {string} type - Operation type to check
+ * @returns {boolean}
+ */
+function isInstallationOperation(type) {
+  return [OperationType.INSTALL, OperationType.UPDATE, OperationType.UNINSTALL].includes(type);
+}
+
+/**
+ * Check if operation type is verification-related
+ * @param {string} type - Operation type to check
+ * @returns {boolean}
+ */
+function isVerificationOperation(type) {
+  return [OperationType.VERIFY, OperationType.CHECK_STATUS].includes(type);
+}
+
+/**
+ * Check if operation type modifies agent state
+ * @param {string} type - Operation type to check
+ * @returns {boolean}
+ */
+function isStateModifying(type) {
+  return [OperationType.INSTALL, OperationType.UPDATE, OperationType.UNINSTALL].includes(type);
+}
+
+/**
+ * Check if operation status is terminal (no further changes possible)
+ * @param {string} status - Operation status to check
+ * @returns {boolean}
+ */
+function isTerminalStatus(status) {
+  return [OperationStatus.COMPLETED, OperationStatus.FAILED, OperationStatus.TIMEOUT, OperationStatus.CANCELLED].includes(status);
+}
+
+/**
+ * Check if operation status represents success
+ * @param {string} status - Operation status to check
+ * @returns {boolean}
+ */
+function isSuccessfulStatus(status) {
+  return status === OperationStatus.COMPLETED;
+}
+
+/**
+ * Check if operation status represents failure
+ * @param {string} status - Operation status to check
+ * @returns {boolean}
+ */
+function isFailedStatus(status) {
+  return [OperationStatus.FAILED, OperationStatus.TIMEOUT].includes(status);
+}
+
+/**
+ * Check if operation status is active/in-progress
+ * @param {string} status - Operation status to check
+ * @returns {boolean}
+ */
+function isActiveStatus(status) {
+  return status === OperationStatus.STARTED;
+}
+
+/**
+ * Get operation type description
+ * @param {string} type - Operation type
+ * @returns {string} - Human-readable description
+ */
+function getOperationTypeDescription(type) {
+  const descriptions = {
+    [OperationType.INSTALL]: 'Install agent',
+    [OperationType.VERIFY]: 'Verify agent',
+    [OperationType.CHECK_STATUS]: 'Check agent status',
+    [OperationType.UPDATE]: 'Update agent',
+    [OperationType.UNINSTALL]: 'Uninstall agent'
+  };
+
+  return descriptions[type] || 'Unknown operation';
+}
+
+/**
+ * Get operation status description
+ * @param {string} status - Operation status
+ * @returns {string} - Human-readable description
+ */
+function getOperationStatusDescription(status) {
+  const descriptions = {
+    [OperationStatus.STARTED]: 'Started',
+    [OperationStatus.COMPLETED]: 'Completed',
+    [OperationStatus.FAILED]: 'Failed',
+    [OperationStatus.TIMEOUT]: 'Timed out',
+    [OperationStatus.CANCELLED]: 'Cancelled'
+  };
+
+  return descriptions[status] || 'Unknown status';
+}
+
+/**
+ * Get all operation types
+ * @returns {string[]} - Array of all type values
+ */
+function getAllOperationTypes() {
+  return Object.values(OperationType);
+}
+
+/**
+ * Get all operation statuses
+ * @returns {string[]} - Array of all status values
+ */
+function getAllOperationStatuses() {
+  return Object.values(OperationStatus);
+}
+
+/**
+ * Check if value is a valid operation type
+ * @param {string} type - Type to validate
+ * @returns {boolean} - True if valid
+ */
+function isValidOperationType(type) {
+  return getAllOperationTypes().includes(type);
+}
+
+/**
+ * Check if value is a valid operation status
+ * @param {string} status - Status to validate
+ * @returns {boolean} - True if valid
+ */
+function isValidOperationStatus(status) {
+  return getAllOperationStatuses().includes(status);
+}
+
+/**
+ * Get valid status transitions for operation type
+ * @param {string} type - Operation type
+ * @returns {string[]} - Array of possible final statuses
+ */
+function getValidFinalStatuses(type) {
+  // All operations can end in these states
+  const commonFinal = [OperationStatus.COMPLETED, OperationStatus.FAILED, OperationStatus.TIMEOUT];
+  
+  // Add type-specific final statuses
+  switch (type) {
+    case OperationType.INSTALL:
+      return [...commonFinal];
+    case OperationType.VERIFY:
+      return [...commonFinal];
+    case OperationType.CHECK_STATUS:
+      return [...commonFinal];
+    case OperationType.UPDATE:
+      return [...commonFinal];
+    case OperationType.UNINSTALL:
+      return [...commonFinal, OperationStatus.CANCELLED];
+    default:
+      return commonFinal;
+  }
+}
+
+/**
+ * Get typical timeout values for each operation type
+ * @param {string} type - Operation type
+ * @returns {number} - Timeout in milliseconds
+ */
+function getDefaultTimeout(type) {
+  const timeouts = {
+    [OperationType.INSTALL]: 5 * 60 * 1000, // 5 minutes
+    [OperationType.VERIFY]: 2 * 60 * 1000, // 2 minutes
+    [OperationType.CHECK_STATUS]: 30 * 1000, // 30 seconds
+    [OperationType.UPDATE]: 5 * 60 * 1000, // 5 minutes
+    [OperationType.UNINSTALL]: 2 * 60 * 1000 // 2 minutes
+  };
+
+  return timeouts[type] || 5 * 60 * 1000; // Default 5 minutes
+}
+
+/**
+ * Get operation priority for logging (higher numbers = higher priority)
+ * @param {string} type - Operation type
+ * @returns {number} - Priority value
+ */
+function getOperationPriority(type) {
+  const priorities = {
+    [OperationType.INSTALL]: 100, // High priority - user-initiated
+    [OperationType.UNINSTALL]: 90,  // High priority - user-initiated
+    [OperationType.UPDATE]: 80,   // Medium priority - maintenance
+    [OperationType.VERIFY]: 70,   // Medium priority - verification
+    [OperationType.CHECK_STATUS]: 50 // Low priority - status check
+  };
+
+  return priorities[type] || 50;
+}
+
+/**
+ * Get status priority for display (higher numbers = higher priority)
+ * @param {string} status - Operation status
+ * @returns {number} - Priority value
+ */
+function getStatusPriority(status) {
+  const priorities = {
+    [OperationStatus.FAILED]: 100, // Highest priority for attention
+    [OperationStatus.TIMEOUT]: 90,  // High priority
+    [OperationStatus.STARTED]: 80,  // Medium priority - in progress
+    [OperationStatus.CANCELLED]: 70, // Medium-low priority
+    [OperationStatus.COMPLETED]: 10 // Low priority - completed successfully
+  };
+
+  return priorities[status] || 10;
+}
+
+/**
+ * Check if operation should be retried based on status
+ * @param {string} status - Operation status
+ * @returns {boolean} - True if retry is appropriate
+ */
+function shouldRetry(status) {
+  return [OperationStatus.FAILED, OperationStatus.TIMEOUT].includes(status);
+}
+
+/**
+ * Get retry delay for operation status
+ * @param {string} status - Operation status
+ * @param {number} attempt - Current attempt number
+ * @returns {number} - Delay in milliseconds
+ */
+function getRetryDelay(status, attempt = 1) {
+  const baseDelays = {
+    [OperationStatus.FAILED]: 1000, // 1 second base delay
+    [OperationStatus.TIMEOUT]: 5000  // 5 seconds base delay for timeouts
+  };
+
+  const baseDelay = baseDelays[status] || 1000;
+  
+  // Exponential backoff with jitter
+  const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+  const jitter = Math.random() * 1000; // Add up to 1 second jitter
+  
+  return Math.min(exponentialDelay + jitter, 60000); // Cap at 1 minute
+}
+
+module.exports = {
+  OperationType,
+  OperationStatus,
+  isInstallationOperation,
+  isVerificationOperation,
+  isStateModifying,
+  isTerminalStatus,
+  isSuccessfulStatus,
+  isFailedStatus,
+  isActiveStatus,
+  getOperationTypeDescription,
+  getOperationStatusDescription,
+  getAllOperationTypes,
+  getAllOperationStatuses,
+  isValidOperationType,
+  isValidOperationStatus,
+  getValidFinalStatuses,
+  getDefaultTimeout,
+  getOperationPriority,
+  getStatusPriority,
+  shouldRetry,
+  getRetryDelay
+};