vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/scripts/verify-full-compliance.js

@@ -0,0 +1,269 @@
+/**
+ * 100% File Size Compliance Verification
+ * 
+ * Verifies that all source files in the repository comply with the 555-line limit.
+ * This is Task T065 from the 555 Max File Size Refactoring specification.
+ */
+
+const path = require('path');
+const { validateDirectory } = require('../validation/line-limit-validator');
+
+class ComplianceVerifier {
+  constructor() {
+    this.rootDir = path.resolve(__dirname, '../../../..'); // Go up to repo root
+    this.packagesDir = path.join(this.rootDir, 'packages');
+    this.totalFiles = 0;
+    this.compliantFiles = 0;
+    this.violationFiles = [];
+    this.violationDetails = [];
+  }
+
+  /**
+   * Verify 100% file size compliance across all source files
+   */
+  async verifyFullCompliance() {
+    console.log('🔍 Starting 100% file size compliance verification...');
+    console.log(`📁 Scanning directory: ${this.rootDir}`);
+    
+    try {
+      // Validate all packages directories
+      const packages = this.getPackageDirectories();
+      
+      for (const packageDir of packages) {
+        await this.verifyPackage(packageDir);
+      }
+      
+      // Generate compliance report
+      const complianceReport = this.generateComplianceReport();
+      
+      // Log results
+      this.logResults(complianceReport);
+      
+      return complianceReport;
+      
+    } catch (error) {
+      console.error('❌ Compliance verification failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all package directories to scan
+   */
+  getPackageDirectories() {
+    const packages = [];
+    
+    // Core packages that should always be scanned
+    const corePackages = [
+      'packages/core',
+      'packages/cli', 
+      'packages/electron-app',
+      'packages/web',
+      'packages/mobile',
+      'packages/vscode-extension',
+      'packages/chrome-extension',
+      'packages/admin',
+      'packages/api-server'
+    ];
+    
+    for (const pkg of corePackages) {
+      const fullPath = path.join(this.rootDir, pkg);
+      if (this.directoryExists(fullPath)) {
+        packages.push(fullPath);
+      }
+    }
+    
+    return packages;
+  }
+
+  /**
+   * Verify a specific package directory
+   */
+  async verifyPackage(packageDir) {
+    console.log(`\n📦 Verifying package: ${path.basename(packageDir)}`);
+    
+    try {
+      const results = validateDirectory(packageDir, {
+        limit: 555,
+        warningThreshold: 500,
+        criticalThreshold: 800
+      });
+      
+      this.processValidationResults(results, packageDir);
+      
+    } catch (error) {
+      console.warn(`⚠️  Could not validate package ${packageDir}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Process validation results
+   */
+  processValidationResults(results, packageDir) {
+    for (const result of results) {
+      this.totalFiles++;
+      
+      if (result.isViolation()) {
+        this.violationFiles.push(result.filePath);
+        this.violationDetails.push({
+          filePath: result.filePath,
+          lineCount: result.lineCount,
+          limit: result.limit,
+          excess: result.lineCount - result.limit,
+          severity: result.getComplianceStatus(),
+          package: path.basename(packageDir)
+        });
+      } else {
+        this.compliantFiles++;
+      }
+    }
+  }
+
+  /**
+   * Generate comprehensive compliance report
+   */
+  generateComplianceReport() {
+    const compliancePercentage = this.totalFiles > 0 ? 
+      (this.compliantFiles / this.totalFiles) * 100 : 0;
+    
+    const isFullyCompliant = this.violationFiles.length === 0;
+    
+    return {
+      summary: {
+        totalFiles: this.totalFiles,
+        compliantFiles: this.compliantFiles,
+        violationFiles: this.violationFiles.length,
+        compliancePercentage: compliancePercentage.toFixed(2),
+        isFullyCompliant: isFullyCompliant,
+        verifiedAt: new Date().toISOString()
+      },
+      violations: this.violationDetails,
+      status: isFullyCompliant ? 'COMPLIANT' : 'NON_COMPLIANT',
+      message: isFullyCompliant ? 
+        '✅ All files comply with the 555-line limit!' :
+        `❌ ${this.violationFiles.length} files exceed the 555-line limit`
+    };
+  }
+
+  /**
+   * Log detailed results
+   */
+  logResults(report) {
+    console.log('\n' + '='.repeat(80));
+    console.log('📊 COMPLIANCE VERIFICATION RESULTS');
+    console.log('='.repeat(80));
+    
+    console.log(`\n📈 SUMMARY:`);
+    console.log(`   Total files scanned: ${report.summary.totalFiles}`);
+    console.log(`   Compliant files: ${report.summary.compliantFiles}`);
+    console.log(`   Violation files: ${report.summary.violationFiles}`);
+    console.log(`   Compliance rate: ${report.summary.compliancePercentage}%`);
+    console.log(`   Status: ${report.status}`);
+    
+    if (report.violations.length > 0) {
+      console.log(`\n❌ VIOLATIONS (${report.violations.length}):`);
+      
+      // Group violations by package
+      const violationsByPackage = {};
+      for (const violation of report.violations) {
+        if (!violationsByPackage[violation.package]) {
+          violationsByPackage[violation.package] = [];
+        }
+        violationsByPackage[violation.package].push(violation);
+      }
+      
+      for (const [pkg, pkgViolations] of Object.entries(violationsByPackage)) {
+        console.log(`\n📦 ${pkg} (${pkgViolations.length} violations):`);
+        
+        for (const violation of pkgViolations.sort((a, b) => b.lineCount - a.lineCount)) {
+          console.log(`   ❌ ${violation.lineCount} lines (+${violation.excess}) - ${violation.filePath}`);
+        }
+      }
+      
+      console.log(`\n🎯 RECOMMENDATIONS:`);
+      console.log(`   1. Prioritize files with highest line counts`);
+      console.log(`   2. Use existing refactoring tools in packages/core/src/refactoring/`);
+      console.log(`   3. Run 'npm run check-compliance' after each refactoring`);
+      console.log(`   4. Update tasks.md to mark completed refactoring tasks`);
+      
+    } else {
+      console.log(`\n🎉 EXCELLENT! All files are within the 555-line limit.`);
+      console.log(`   The codebase is fully compliant with constitutional requirements.`);
+    }
+    
+    console.log('\n' + '='.repeat(80));
+  }
+
+  /**
+   * Check if directory exists
+   */
+  directoryExists(dirPath) {
+    try {
+      const stats = require('fs').statSync(dirPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get violations by severity
+   */
+  getViolationsBySeverity() {
+    const bySeverity = {
+      critical: [],
+      warning: [],
+      info: []
+    };
+    
+    for (const violation of this.violationDetails) {
+      const severity = this.getSeverityFromLineCount(violation.lineCount);
+      bySeverity[severity].push(violation);
+    }
+    
+    return bySeverity;
+  }
+
+  /**
+   * Get severity from line count
+   */
+  getSeverityFromLineCount(lineCount) {
+    if (lineCount > 800) return 'critical';
+    if (lineCount > 555) return 'warning';
+    return 'info';
+  }
+}
+
+/**
+ * Main execution function
+ */
+async function runComplianceVerification() {
+  const verifier = new ComplianceVerifier();
+  
+  try {
+    const report = await verifier.verifyFullCompliance();
+    
+    // Exit with appropriate code
+    if (report.summary.isFullyCompliant) {
+      console.log('\n✅ Compliance verification PASSED');
+      process.exit(0);
+    } else {
+      console.log('\n❌ Compliance verification FAILED');
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    console.error('💥 Verification failed:', error);
+    process.exit(2);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  runComplianceVerification();
+}
+
+module.exports = {
+  ComplianceVerifier,
+  runComplianceVerification
+};

package/src/sync/sync-engine-core.js

@@ -6,6 +6,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const crypto = require('crypto');
+const os = require('os');
 const EventEmitter = require('events');
 
 class SyncEngineCore extends EventEmitter {

package/src/sync/sync-engine-remote-handlers.js

@@ -0,0 +1,135 @@
+/**
+ * Sync Engine Remote Control Handlers
+ * Extracted from sync-engine-backup.js for 555-line compliance
+ * Handles remote control commands for the sync engine
+ */
+
+/**
+ * Setup remote control event handlers
+ * @param {Object} syncEngine - The sync engine instance
+ */
+function setupRemoteControlHandlers(syncEngine) {
+  if (!syncEngine.remoteControlServer) return;
+
+  // Handle remote control commands
+  syncEngine.remoteControlServer.on('command', async (command) => {
+    console.log('🎮 Remote control command received:', command);
+
+    try {
+      switch (command.type) {
+        case 'start-auto':
+          await handleStartAutoCommand(syncEngine, command);
+          break;
+        case 'stop-auto':
+          await handleStopAutoCommand(syncEngine, command);
+          break;
+        case 'get-status':
+          await handleGetStatusCommand(syncEngine, command);
+          break;
+        default:
+          console.log('❌ Unknown remote control command:', command.type);
+          syncEngine.remoteControlServer.sendToClientById(command.clientId, 'command-error', {
+            command: command.type,
+            error: 'Unknown command type'
+          });
+      }
+    } catch (error) {
+      console.error('❌ Error handling remote control command:', error);
+      syncEngine.remoteControlServer.sendToClientById(command.clientId, 'command-error', {
+        command: command.type,
+        error: error.message
+      });
+    }
+  });
+
+  // Handle client authentication
+  syncEngine.remoteControlServer.on('client-authenticated', (data) => {
+    console.log('🔐 Remote control client authenticated:', data.userInfo.username);
+    syncEngine.emit('remote-client-authenticated', data);
+  });
+
+  // Handle client disconnection
+  syncEngine.remoteControlServer.on('client-disconnected', (data) => {
+    console.log('🔌 Remote control client disconnected:', data.clientId);
+    syncEngine.emit('remote-client-disconnected', data);
+  });
+
+  console.log('✅ Remote control handlers setup complete');
+}
+
+/**
+ * Handle start-auto command
+ * @param {Object} syncEngine - The sync engine instance
+ * @param {Object} command - The command object
+ */
+async function handleStartAutoCommand(syncEngine, command) {
+  console.log('🚀 Starting auto mode via remote control');
+
+  // Emit event for main application to handle
+  syncEngine.emit('remote-start-auto', {
+    clientId: command.clientId,
+    userInfo: command.userInfo,
+    data: command.data
+  });
+
+  // Send confirmation back to client
+  syncEngine.remoteControlServer.sendToClientById(command.clientId, 'command-success', {
+    command: 'start-auto',
+    message: 'Auto mode started successfully'
+  });
+}
+
+/**
+ * Handle stop-auto command
+ * @param {Object} syncEngine - The sync engine instance
+ * @param {Object} command - The command object
+ */
+async function handleStopAutoCommand(syncEngine, command) {
+  console.log('🛑 Stopping auto mode via remote control');
+
+  // Emit event for main application to handle
+  syncEngine.emit('remote-stop-auto', {
+    clientId: command.clientId,
+    userInfo: command.userInfo,
+    data: command.data
+  });
+
+  // Send confirmation back to client
+  syncEngine.remoteControlServer.sendToClientById(command.clientId, 'command-success', {
+    command: 'stop-auto',
+    message: 'Auto mode stopped successfully'
+  });
+}
+
+/**
+ * Handle get-status command
+ * @param {Object} syncEngine - The sync engine instance
+ * @param {Object} command - The command object
+ */
+async function handleGetStatusCommand(syncEngine, command) {
+  console.log('📊 Getting status via remote control');
+
+  // Get current status
+  const status = {
+    computerId: syncEngine.computerId,
+    isOnline: syncEngine.isOnline,
+    isSyncing: syncEngine.isSyncing,
+    lastSyncTime: syncEngine.lastSyncTime,
+    offlineQueueSize: syncEngine.offlineQueue?.length || 0,
+    changeHistorySize: syncEngine.changeHistory?.length || 0,
+    syncEngineStatus: 'running'
+  };
+
+  // Send status back to client
+  syncEngine.remoteControlServer.sendToClientById(command.clientId, 'status-response', {
+    command: 'get-status',
+    status
+  });
+}
+
+module.exports = {
+  setupRemoteControlHandlers,
+  handleStartAutoCommand,
+  handleStopAutoCommand,
+  handleGetStatusCommand
+};