vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/config/refactoring-config.js

@@ -0,0 +1,307 @@
+/**
+ * Refactoring Configuration
+ * 
+ * Centralized configuration for file size refactoring operations.
+ * Defines exclusions, limits, and behavior for refactoring tools.
+ */
+
+const path = require('path');
+
+const RefactoringConfig = {
+  // File size limits
+  limits: {
+    maxFileSize: 800,
+    warningThreshold: 700,
+    criticalThreshold: 1000,
+    smallFileMax: 100,
+    mediumFileMax: 300,
+    largeFileMax: 800,
+    xlargeFileMin: 801
+  },
+
+  // File and directory exclusions
+  exclusions: {
+    // Third-party directories to exclude from analysis
+    thirdPartyDirs: [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      'coverage',
+      '.nyc_output',
+      '.vscode',
+      '.idea',
+      '.cursor',
+      '.windsurf',
+      'vendor',
+      'bower_components'
+    ],
+
+    // Third-party file patterns to exclude
+    thirdPartyFiles: [
+      '*.min.js',
+      '*.min.css',
+      '*.bundle.js',
+      '*.chunk.js',
+      '*.map',
+      '*.d.ts',
+      '*.lock',
+      '*.log'
+    ],
+
+    // Generated files to exclude
+    generatedFiles: [
+      '*.generated.js',
+      '*.generated.ts',
+      '*.auto.js',
+      '*.auto.ts',
+      '*.spec.generated.js',
+      '*.test.generated.js'
+    ],
+
+    // Test files (optional - can be included if needed)
+    testFiles: [
+      '*.test.js',
+      '*.spec.js',
+      '*.test.ts',
+      '*.spec.ts',
+      '__tests__/**/*',
+      'test/**/*',
+      'tests/**/*'
+    ],
+
+    // Config files that might be large but shouldn't be refactored
+    configFiles: [
+      'package-lock.json',
+      'yarn.lock',
+      '*.config.js',
+      '*.config.ts',
+      '.babelrc',
+      '.eslintrc*',
+      'tsconfig.json'
+    ],
+
+    // Documentation files
+    docFiles: [
+      '*.md',
+      '*.txt',
+      '*.rst',
+      'CHANGELOG*',
+      'LICENSE*',
+      'README*'
+    ]
+  },
+
+  // Refactoring behavior
+  refactoring: {
+    // Safety settings
+    backupBeforeRefactoring: true,
+    validateAfterRefactoring: true,
+    runTestsAfterRefactoring: true,
+    rollbackOnFailure: true,
+
+    // Module splitting preferences
+    preferLogicalBoundaries: true,
+    maintainCohesion: true,
+    minimizeCoupling: true,
+    preservePublicAPI: true,
+
+    // Import management
+    updateImportsAutomatically: true,
+    sortImportsAfterUpdate: true,
+    removeUnusedImports: true,
+
+    // File organization
+    groupRelatedFunctions: true,
+    separateConstants: true,
+    extractUtilities: true,
+    maintainNamingConventions: true
+  },
+
+  // Analysis settings
+  analysis: {
+    // AST parsing options
+    parseOptions: {
+      sourceType: 'module',
+      plugins: [
+        'jsx',
+        'typescript',
+        'decorators-legacy',
+        'classProperties',
+        'objectRestSpread',
+        'asyncGenerators',
+        'functionBind',
+        'exportDefaultFrom',
+        'exportNamespaceFrom',
+        'dynamicImport'
+      ]
+    },
+
+    // Boundary detection sensitivity
+    boundaryDetection: {
+      minFunctionLines: 10,
+      minClassLines: 15,
+      minModuleLines: 20,
+      maxComplexity: 10,
+      considerComments: true,
+      respectExistingSections: true
+    },
+
+    // Dependency analysis
+    dependencyAnalysis: {
+      includeTransitive: false,
+      detectCircular: true,
+      analyzeImportTypes: true,
+      trackInternalDependencies: true
+    }
+  },
+
+  // Reporting settings
+  reporting: {
+    // Output formats
+    formats: ['json', 'markdown', 'console'],
+    
+    // Report content
+    includeMetrics: true,
+    includeRecommendations: true,
+    includeDependencies: true,
+    includeComplexity: true,
+    
+    // Visualization
+    generateCharts: false,
+    includeTreeMap: false,
+    includeHeatMap: false
+  },
+
+  // Validation settings
+  validation: {
+    // Syntax validation
+    validateSyntax: true,
+    validateImports: true,
+    validateExports: true,
+
+    // Functional validation
+    runTests: true,
+    checkAPICompatibility: true,
+    validateBehavior: false, // Expensive, optional
+
+    // Quality validation
+    checkComplexity: true,
+    checkDuplication: true,
+    checkNaming: true
+  },
+
+  // Monitoring settings
+  monitoring: {
+    // Real-time monitoring
+    enableFileWatcher: true,
+    watchInterval: 1000,
+    debounceMs: 500,
+
+    // Alert thresholds
+    alertOnGrowth: true,
+    growthThreshold: 50, // lines
+    alertFrequency: 300000, // 5 minutes
+
+    // Compliance checking
+    checkOnCommit: true,
+    checkOnBuild: true,
+    scheduleCheck: false
+  },
+
+  // Package-specific overrides
+  packageOverrides: {
+    'packages/cli': {
+      limits: {
+        maxFileSize: 600, // CLI files can be slightly larger
+        warningThreshold: 550
+      }
+    },
+    'packages/electron-app': {
+      exclusions: {
+        testFiles: [] // Include test files in Electron app analysis
+      }
+    },
+    'packages/core': {
+      validation: {
+        checkComplexity: true,
+        checkDuplication: true,
+        validateBehavior: true // Core package needs stricter validation
+      }
+    }
+  },
+
+  // Helper methods
+  isExcluded(filePath) {
+    const normalizedPath = path.normalize(filePath);
+    
+    // Check directory exclusions
+    for (const dir of this.exclusions.thirdPartyDirs) {
+      if (normalizedPath.includes(path.sep + dir + path.sep) ||
+          normalizedPath.endsWith(path.sep + dir) ||
+          normalizedPath.startsWith(dir + path.sep)) {
+        return true;
+      }
+    }
+
+    // Check file pattern exclusions
+    const fileName = path.basename(normalizedPath);
+    for (const pattern of this.exclusions.thirdPartyFiles) {
+      if (this._matchesPattern(fileName, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+
+  isTestFile(filePath) {
+    const fileName = path.basename(filePath);
+    for (const pattern of this.exclusions.testFiles) {
+      if (this._matchesPattern(filePath, pattern) || 
+          this._matchesPattern(fileName, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  isConfigFile(filePath) {
+    const fileName = path.basename(filePath);
+    for (const pattern of this.exclusions.configFiles) {
+      if (this._matchesPattern(fileName, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  getLimits(packagePath) {
+    const packageConfig = this._getPackageConfig(packagePath);
+    return { ...this.limits, ...packageConfig.limits };
+  },
+
+  getExclusions(packagePath) {
+    const packageConfig = this._getPackageConfig(packagePath);
+    return { ...this.exclusions, ...packageConfig.exclusions };
+  },
+
+  _matchesPattern(str, pattern) {
+    const regex = new RegExp(
+      '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+    );
+    return regex.test(str);
+  },
+
+  _getPackageConfig(packagePath) {
+    // Find matching package override
+    for (const [pkgPath, config] of Object.entries(this.packageOverrides)) {
+      if (packagePath.includes(pkgPath)) {
+        return config;
+      }
+    }
+    return {};
+  }
+};
+
+module.exports = RefactoringConfig;

package/src/health-tracking/json-storage.js

@@ -14,6 +14,16 @@ const { StorageInterface } = require('./storage-interface');
 const { FileSystemError, ValidationError } = require('./errors');
 const { validateHealthData } = require('./validators');
 
+/**
+ * Simple logger for health tracking (minimal output in production)
+ */
+const logger = {
+  debug: (msg, ...args) => { /* Silent in production - only enable for debugging */ },
+  info: (msg, ...args) => console.log(`[HEALTH] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[HEALTH] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[HEALTH] ${msg}`, ...args)
+};
+
 /**
  * Default storage file location
  */
@@ -63,6 +73,8 @@ class JSONStorage extends StorageInterface {
    */
   async read() {
     try {
+      // logger.debug(`Reading health data from: ${this.storageFile}`); // Silent
+      
       // Ensure storage directory exists
       await fs.ensureDir(path.dirname(this.storageFile));
 
@@ -70,27 +82,33 @@ class JSONStorage extends StorageInterface {
       const fileExists = await this.exists();
 
       if (!fileExists) {
+        logger.info('Health data file not found, returning default structure');
         // Return default data structure if file doesn't exist
         return JSON.parse(JSON.stringify(DEFAULT_HEALTH_DATA));
       }
 
       // Read file content
       const content = await fs.readFile(this.storageFile, 'utf8');
+      // logger.debug(`Read ${content.length} bytes from health data file`); // Silent
 
       // Parse JSON
       let data;
       try {
         data = JSON.parse(content);
+        // logger.debug('Successfully parsed health data JSON'); // Silent
       } catch (parseError) {
         // Attempt to restore from backup on parse error
-        console.warn(`Failed to parse health data, attempting backup restore: ${parseError.message}`);
+        logger.warn(`Failed to parse health data, attempting backup restore: ${parseError.message}`);
         const backupExists = await fs.pathExists(this.backupFile);
 
         if (backupExists) {
+          logger.info('Restoring from backup file');
           await this.restore(this.backupFile);
           const backupContent = await fs.readFile(this.storageFile, 'utf8');
           data = JSON.parse(backupContent);
+          logger.info('Successfully restored from backup');
         } else {
+          logger.error('No backup file available for restoration');
           throw new FileSystemError(
             'Failed to parse health data and no backup available',
             this.storageFile,
@@ -103,7 +121,9 @@ class JSONStorage extends StorageInterface {
       // Validate data structure
       try {
         validateHealthData(data);
+        // logger.debug('Health data validation passed'); // Silent
       } catch (validationError) {
+        logger.error(`Health data validation failed: ${validationError.message}`);
         throw new FileSystemError(
           `Health data validation failed: ${validationError.message}`,
           this.storageFile,
@@ -115,11 +135,13 @@ class JSONStorage extends StorageInterface {
       // Run migrations if needed
       data = await this._runMigrations(data);
 
+      // logger.debug('Health data read completed successfully'); // Silent
       return data;
     } catch (error) {
       if (error instanceof FileSystemError) {
         throw error;
       }
+      logger.error(`Failed to read health data: ${error.message}`);
       throw new FileSystemError(
         `Failed to read health data: ${error.message}`,
         this.storageFile,
@@ -138,8 +160,11 @@ class JSONStorage extends StorageInterface {
    */
   async write(data) {
     try {
+      // logger.debug(`Writing health data to: ${this.storageFile}`); // Silent
+      
       // Validate data before writing
       validateHealthData(data);
+      // logger.debug('Health data validation passed'); // Silent
 
       // Update lastUpdated timestamp
       data.lastUpdated = new Date().toISOString();
@@ -150,19 +175,30 @@ class JSONStorage extends StorageInterface {
       // Create backup if file exists
       const fileExists = await this.exists();
       if (fileExists) {
+        // logger.debug('Creating backup before write'); // Silent
         await this.backup();
+        // logger.debug('Backup created successfully'); // Silent
       }
 
       // Atomic write: write to temp file first
       const tempFile = `${this.storageFile}.tmp`;
-      await fs.writeJson(tempFile, data, { spaces: 2 });
+      const jsonString = JSON.stringify(data, null, 2);
+      
+      // Ensure storage directory exists
+      await fs.ensureDir(path.dirname(this.storageFile));
+      
+      await fs.writeFile(tempFile, jsonString, 'utf8');
+      // logger.debug(`Wrote ${jsonString.length} bytes to temp file`); // Silent
 
       // Rename temp file to target (atomic operation)
       await fs.rename(tempFile, this.storageFile);
+      // logger.debug('Health data written successfully'); // Silent
     } catch (error) {
       if (error instanceof ValidationError) {
+        logger.error(`Validation error during write: ${error.message}`);
         throw error;
       }
+      logger.error(`Failed to write health data: ${error.message}`);
       throw new FileSystemError(
         `Failed to write health data: ${error.message}`,
         this.storageFile,

package/src/ide-integration/applescript-manager-core.js

@@ -0,0 +1,233 @@
+// @vibecodingmachine/core - AppleScript Manager Core
+// Core coordination and interface for IDE interactions
+
+const { execSync } = require('child_process');
+const { writeFileSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { tmpdir } = require('os');
+
+// Import platform-specific managers
+const MacOSIDEManager = require('./macos-ide-manager');
+const WindowsIDEManager = require('./windows-ide-manager');
+const IDEStatusChecker = require('./ide-status-checker');
+const ResponseReader = require('./response-reader');
+const ContinuationHandler = require('./continuation-handler');
+
+// Import Windows automation manager for Windows platform
+let WindowsAutomationManager;
+if (process.platform === 'win32') {
+  WindowsAutomationManager = require('./windows-automation-manager');
+}
+
+const AppleScriptUtils = require('./applescript-utils');
+
+/**
+ * Core AppleScript Manager for IDE interactions
+ * Coordinates platform-specific operations and provides unified interface
+ */
+class AppleScriptManagerCore {
+  constructor() {
+    this.logger = console;
+    this.platform = process.platform;
+    this.appleScriptUtils = new AppleScriptUtils();
+
+    // Initialize platform-specific managers
+    if (this.platform === 'win32' && WindowsAutomationManager) {
+      this.windowsManager = new WindowsAutomationManager();
+      this.ideManager = new WindowsIDEManager(this.windowsManager);
+    } else {
+      this.ideManager = new MacOSIDEManager(this.appleScriptUtils);
+    }
+
+    this.statusChecker = new IDEStatusChecker(this.platform, this.windowsManager);
+    this.responseReader = new ResponseReader(this.platform, this.windowsManager);
+    this.continuationHandler = new ContinuationHandler(this.platform, this.windowsManager);
+  }
+
+  /**
+   * Generic IDE opener - routes to specific IDE methods
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'antigravity', 'vscode', etc.')
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object
+   */
+  async openIDE(ide, repoPath = null) {
+    return await this.ideManager.openIDE(ide, repoPath);
+  }
+
+  /**
+   * Send text to an IDE using platform-specific methods
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'claude')
+   * @param {string} repoPath - The repository path (optional, used for Claude)
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendText(text, ide, repoPath = null) {
+    if (typeof text !== 'string') {
+      return {
+        success: false,
+        error: `Invalid text type: ${typeof text}. Expected string.`,
+        debug: { textType: typeof text, textValue: text }
+      };
+    }
+
+    return await this.ideManager.sendText(text, ide, repoPath);
+  }
+
+  /**
+   * Read chat response from IDE using platform-specific methods
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'vscode')
+   * @returns {Promise<string>} The chat response text
+   */
+  async readChatResponse(ide) {
+    return await this.responseReader.readChatResponse(ide);
+  }
+
+  /**
+   * Check if an IDE is running and accessible
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async getIDEStatus(ide) {
+    return await this.statusChecker.getIDEStatus(ide);
+  }
+
+  /**
+   * Close previous chat thread in an IDE to prevent conflicts
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf', 'claude')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async closePreviousChatThread(ide) {
+    return await this.ideManager.closePreviousChatThread(ide);
+  }
+
+  /**
+   * Send text to an IDE with automatic thread closure
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextWithThreadClosure(text, ide) {
+    return await this.ideManager.sendTextWithThreadClosure(text, ide);
+  }
+
+  /**
+   * Check Claude terminal output for session limit errors
+   * @returns {Promise<Object>} Result object with sessionLimitReached flag and details
+   */
+  async checkClaudeSessionLimit() {
+    return await this.ideManager.checkClaudeSessionLimit();
+  }
+
+  /**
+   * Detect continuation prompts using platform-specific methods
+   * @returns {Promise<boolean>} True if continuation prompt detected
+   */
+  async detectContinuationPrompt() {
+    return await this.continuationHandler.detectContinuationPrompt();
+  }
+
+  /**
+   * Click detected continuation button using platform-specific methods
+   * @returns {Promise<boolean>} True if button clicked successfully
+   */
+  async clickContinuationButton() {
+    return await this.continuationHandler.clickContinuationButton();
+  }
+
+  /**
+   * Check for continuation prompts using platform-specific methods
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuation(ide) {
+    return await this.continuationHandler.checkForContinuation(ide);
+  }
+
+  /**
+   * Click a continuation button if found
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of operation
+   */
+  async clickContinuationButton(ide) {
+    return await this.continuationHandler.clickContinuationButton(ide);
+  }
+
+  /**
+   * Deterministically send text to Terminal window 1 tab 1 and verify via history snippet
+   * @param {string} text
+   * @returns {Promise<Object>} Result with success and note
+   */
+  async sendDeterministicToTerminalWindow1(text) {
+    return await this.ideManager.sendDeterministicToTerminalWindow1(text);
+  }
+
+  /**
+   * Check Antigravity UI for Gemini quota limit popup text
+   * @returns {Promise<{isRateLimited: boolean, message?: string, resumeAt?: string, note?: string}>}
+   */
+  async checkAntigravityQuotaLimit() {
+    return await this.ideManager.checkAntigravityQuotaLimit();
+  }
+
+  /**
+   * Handle Antigravity quota limit by automatically switching models
+   * @returns {Promise<{success: boolean, model?: string, error?: string}>}
+   */
+  async handleAntigravityQuotaLimit() {
+    return await this.ideManager.handleAntigravityQuotaLimit();
+  }
+
+  /**
+   * Detect quota warnings using platform-specific methods
+   * @param {string} ide - The IDE name ('windsurf')
+   * @returns {Promise<Object>} Quota detection result
+   */
+  async detectQuotaWarning(ide) {
+    return await this.ideManager.detectQuotaWarning(ide);
+  }
+
+  /**
+   * Check Windsurf for rate limit errors
+   * @returns {Promise<Object>} Result object with isRateLimited flag and details
+   */
+  async checkWindsurfRateLimit() {
+    return await this.ideManager.checkWindsurfRateLimit();
+  }
+
+  /**
+   * Send text to VS Code using dedicated method
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextToVSCode(text) {
+    return await this.ideManager.sendTextToVSCode(text);
+  }
+
+  /**
+   * Send text to Windsurf extension within VS Code
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status
+   */
+  async sendTextToWindsurfExtension(text) {
+    return await this.ideManager.sendTextToWindsurfExtension(text);
+  }
+
+  /**
+   * Check if we're running within a VS Code extension context
+   * @returns {boolean} True if running in VS Code extension
+   */
+  isRunningInVSCodeExtension() {
+    try {
+      // Check for VS Code extension environment variables
+      return !!(process.env.VSCODE_PID ||
+        process.env.VSCODE_INJECTION ||
+        process.env.VSCODE_IPC_HOOK_CLI ||
+        (typeof require !== 'undefined' && require.main && require.main.filename.includes('vscode')));
+    } catch (error) {
+      this.logger.log('⚠️ Could not determine VS Code extension context:', error.message);
+      return false;
+    }
+  }
+}
+
+module.exports = AppleScriptManagerCore;