vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/dependency-mapper.js

@@ -0,0 +1,456 @@
+/**
+ * Dependency Mapping Utility
+ * Maps and analyzes file dependencies for refactoring planning
+ * Part of specs/010-555-max-file-size implementation (Task T003)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Map dependencies for a given file
+ * @param {string} filePath - Path to file to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object} Dependency analysis results
+ */
+function mapFileDependencies(filePath, options = {}) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    const analysis = {
+      filePath,
+      dependencies: [],
+      dependents: [],
+      circularDependencies: [],
+      externalDependencies: [],
+      internalDependencies: [],
+      dependencyGraph: {},
+      complexity: 'LOW'
+    };
+
+    // Extract imports/requires
+    const imports = extractImports(lines);
+    
+    // Categorize dependencies
+    imports.forEach(imp => {
+      const depInfo = analyzeDependency(imp, filePath, options);
+      
+      if (depInfo.isExternal) {
+        analysis.externalDependencies.push(depInfo);
+      } else {
+        analysis.internalDependencies.push(depInfo);
+      }
+      
+      analysis.dependencies.push(depInfo);
+    });
+
+    // Build dependency graph
+    analysis.dependencyGraph = buildDependencyGraph(filePath, analysis.dependencies);
+
+    // Assess complexity
+    analysis.complexity = assessDependencyComplexity(analysis);
+
+    return analysis;
+  } catch (error) {
+    return {
+      filePath,
+      error: error.message,
+      dependencies: []
+    };
+  }
+}
+
+/**
+ * Extract import/require statements from file content
+ * @param {Array} lines - File lines
+ * @returns {Array} Array of import objects
+ */
+function extractImports(lines) {
+  const imports = [];
+
+  lines.forEach((line, index) => {
+    const trimmed = line.trim();
+    
+    // ES6 imports
+    const es6Match = trimmed.match(/^import\s+(?:(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/);
+    if (es6Match) {
+      imports.push({
+        type: 'es6',
+        module: es6Match[1],
+        line: index + 1,
+        statement: trimmed
+      });
+      return;
+    }
+
+    // CommonJS requires
+    const cjsMatch = trimmed.match(/(?:const|let|var)\s+(?:\{[^}]+\}|\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/);
+    if (cjsMatch) {
+      imports.push({
+        type: 'commonjs',
+        module: cjsMatch[1],
+        line: index + 1,
+        statement: trimmed
+      });
+      return;
+    }
+
+    // Direct require calls
+    const directMatch = trimmed.match(/require\(['"]([^'"]+)['"]\)/);
+    if (directMatch) {
+      imports.push({
+        type: 'direct',
+        module: directMatch[1],
+        line: index + 1,
+        statement: trimmed
+      });
+    }
+  });
+
+  return imports;
+}
+
+/**
+ * Analyze a dependency
+ * @param {Object} importObj - Import object
+ * @param {string} sourceFile - Source file path
+ * @param {Object} options - Analysis options
+ * @returns {Object} Dependency analysis
+ */
+function analyzeDependency(importObj, sourceFile, options = {}) {
+  const modulePath = importObj.module;
+  const resolvedPath = resolveModulePath(modulePath, sourceFile);
+  
+  return {
+    type: importObj.type,
+    module: modulePath,
+    resolvedPath,
+    line: importObj.line,
+    statement: importObj.statement,
+    isExternal: isExternalDependency(modulePath, resolvedPath, options),
+    isRelative: isRelativePath(modulePath),
+    isNodeModule: isNodeModule(modulePath),
+    isLocalModule: isLocalModule(modulePath, resolvedPath)
+  };
+}
+
+/**
+ * Resolve module path to absolute path
+ * @param {string} modulePath - Module path from import
+ * @param {string} sourceFile - Source file path
+ * @returns {string|null} Resolved absolute path
+ */
+function resolveModulePath(modulePath, sourceFile) {
+  try {
+    if (isNodeModule(modulePath)) {
+      return null; // Node modules don't resolve to local files
+    }
+
+    if (isRelativePath(modulePath)) {
+      const sourceDir = path.dirname(sourceFile);
+      const resolved = path.resolve(sourceDir, modulePath);
+      
+      // Try different extensions
+      const extensions = ['.js', '.json', '.jsx', '.ts', '.tsx'];
+      for (const ext of extensions) {
+        const fullPath = resolved.endsWith(ext) ? resolved : resolved + ext;
+        if (fs.existsSync(fullPath)) {
+          return fullPath;
+        }
+      }
+      
+      // Try index.js in directory
+      const indexPath = path.join(resolved, 'index.js');
+      if (fs.existsSync(indexPath)) {
+        return indexPath;
+      }
+      
+      return null;
+    }
+
+    // Absolute path
+    if (path.isAbsolute(modulePath)) {
+      return fs.existsSync(modulePath) ? modulePath : null;
+    }
+
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if dependency is external (third-party)
+ * @param {string} modulePath - Module path
+ * @param {string} resolvedPath - Resolved path
+ * @param {Object} options - Analysis options
+ * @returns {boolean}
+ */
+function isExternalDependency(modulePath, resolvedPath, options = {}) {
+  // Node modules are external
+  if (isNodeModule(modulePath)) {
+    return true;
+  }
+
+  // If we have a list of external modules, check against it
+  if (options.externalModules && Array.isArray(options.externalModules)) {
+    return options.externalModules.includes(modulePath);
+  }
+
+  // If resolved path is outside project root, it's external
+  if (resolvedPath && options.projectRoot) {
+    return !resolvedPath.startsWith(options.projectRoot);
+  }
+
+  // Default: non-relative paths without resolution are external
+  return !isRelativePath(modulePath) && !resolvedPath;
+}
+
+/**
+ * Check if path is relative
+ * @param {string} modulePath - Module path
+ * @returns {boolean}
+ */
+function isRelativePath(modulePath) {
+  return modulePath.startsWith('./') || modulePath.startsWith('../');
+}
+
+/**
+ * Check if module is a Node.js module
+ * @param {string} modulePath - Module path
+ * @returns {boolean}
+ */
+function isNodeModule(modulePath) {
+  // Common Node.js modules
+  const nodeModules = new Set([
+    'fs', 'path', 'os', 'util', 'events', 'stream', 'crypto', 'http', 'https',
+    'url', 'querystring', 'assert', 'buffer', 'child_process', 'cluster', 'dgram',
+    'dns', 'net', 'readline', 'repl', 'tls', 'tty', 'vm', 'zlib', 'console',
+    'timers', 'process', 'module', 'sys'
+  ]);
+
+  return nodeModules.has(modulePath) || !modulePath.startsWith('.') && !path.isAbsolute(modulePath);
+}
+
+/**
+ * Check if module is a local module
+ * @param {string} modulePath - Module path
+ * @param {string} resolvedPath - Resolved path
+ * @returns {boolean}
+ */
+function isLocalModule(modulePath, resolvedPath) {
+  return resolvedPath !== null && fs.existsSync(resolvedPath);
+}
+
+/**
+ * Build dependency graph
+ * @param {string} filePath - Source file path
+ * @param {Array} dependencies - Array of dependencies
+ * @returns {Object} Dependency graph
+ */
+function buildDependencyGraph(filePath, dependencies) {
+  const graph = {
+    nodes: [{ id: filePath, type: 'source' }],
+    edges: []
+  };
+
+  dependencies.forEach(dep => {
+    if (dep.resolvedPath) {
+      // Add dependency node if not already present
+      if (!graph.nodes.find(n => n.id === dep.resolvedPath)) {
+        graph.nodes.push({
+          id: dep.resolvedPath,
+          type: dep.isExternal ? 'external' : 'internal'
+        });
+      }
+
+      // Add edge
+      graph.edges.push({
+        from: filePath,
+        to: dep.resolvedPath,
+        type: dep.type,
+        line: dep.line
+      });
+    }
+  });
+
+  return graph;
+}
+
+/**
+ * Assess dependency complexity
+ * @param {Object} analysis - Dependency analysis
+ * @returns {string} Complexity level
+ */
+function assessDependencyComplexity(analysis) {
+  const totalDeps = analysis.dependencies.length;
+  const externalDeps = analysis.externalDependencies.length;
+  const internalDeps = analysis.internalDependencies.length;
+
+  if (totalDeps > 20 || internalDeps > 10) {
+    return 'HIGH';
+  } else if (totalDeps > 10 || internalDeps > 5) {
+    return 'MEDIUM';
+  } else {
+    return 'LOW';
+  }
+}
+
+/**
+ * Find circular dependencies in a set of files
+ * @param {Array} filePaths - Array of file paths to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Array} Array of circular dependency cycles
+ */
+function findCircularDependencies(filePaths, options = {}) {
+  const dependencyMap = new Map();
+  const cycles = [];
+
+  // Build dependency map for all files
+  filePaths.forEach(filePath => {
+    const analysis = mapFileDependencies(filePath, options);
+    dependencyMap.set(filePath, analysis.internalDependencies.map(dep => dep.resolvedPath).filter(Boolean));
+  });
+
+  // Detect cycles using DFS
+  const visited = new Set();
+  const recursionStack = new Set();
+  const pathStack = [];
+
+  function dfs(node, currentPath) {
+    if (recursionStack.has(node)) {
+      // Found a cycle
+      const cycleStart = currentPath.indexOf(node);
+      if (cycleStart !== -1) {
+        cycles.push(currentPath.slice(cycleStart).concat(node));
+      }
+      return;
+    }
+
+    if (visited.has(node)) {
+      return;
+    }
+
+    visited.add(node);
+    recursionStack.add(node);
+    currentPath.push(node);
+
+    const dependencies = dependencyMap.get(node) || [];
+    dependencies.forEach(dep => {
+      if (filePaths.includes(dep)) {
+        dfs(dep, [...currentPath]);
+      }
+    });
+
+    recursionStack.delete(node);
+    currentPath.pop();
+  }
+
+  filePaths.forEach(filePath => {
+    if (!visited.has(filePath)) {
+      dfs(filePath, []);
+    }
+  });
+
+  return cycles;
+}
+
+/**
+ * Generate dependency report
+ * @param {Array} filePaths - Array of file paths to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object} Comprehensive dependency report
+ */
+function generateDependencyReport(filePaths, options = {}) {
+  const report = {
+    summary: {
+      totalFiles: filePaths.length,
+      totalDependencies: 0,
+      externalDependencies: 0,
+      internalDependencies: 0,
+      circularDependencies: 0,
+      highComplexityFiles: 0
+    },
+    files: [],
+    circularDependencies: [],
+    recommendations: []
+  };
+
+  // Analyze each file
+  filePaths.forEach(filePath => {
+    const analysis = mapFileDependencies(filePath, options);
+    report.files.push(analysis);
+
+    // Update summary
+    report.summary.totalDependencies += analysis.dependencies.length;
+    report.summary.externalDependencies += analysis.externalDependencies.length;
+    report.summary.internalDependencies += analysis.internalDependencies.length;
+
+    if (analysis.complexity === 'HIGH') {
+      report.summary.highComplexityFiles++;
+    }
+  });
+
+  // Find circular dependencies
+  report.circularDependencies = findCircularDependencies(filePaths, options);
+  report.summary.circularDependencies = report.circularDependencies.length;
+
+  // Generate recommendations
+  report.recommendations = generateDependencyRecommendations(report);
+
+  return report;
+}
+
+/**
+ * Generate refactoring recommendations based on dependency analysis
+ * @param {Object} report - Dependency report
+ * @returns {Array} Array of recommendations
+ */
+function generateDependencyRecommendations(report) {
+  const recommendations = [];
+
+  // High complexity files
+  if (report.summary.highComplexityFiles > 0) {
+    recommendations.push({
+      type: 'complexity',
+      priority: 'HIGH',
+      description: `${report.summary.highComplexityFiles} files have high dependency complexity`,
+      action: 'Consider refactoring to reduce coupling'
+    });
+  }
+
+  // Circular dependencies
+  if (report.summary.circularDependencies > 0) {
+    recommendations.push({
+      type: 'circular',
+      priority: 'HIGH',
+      description: `${report.summary.circularDependencies} circular dependency cycles detected`,
+      action: 'Resolve circular dependencies before refactoring'
+    });
+  }
+
+  // Many external dependencies
+  if (report.summary.externalDependencies > report.summary.totalDependencies * 0.7) {
+    recommendations.push({
+      type: 'external',
+      priority: 'MEDIUM',
+      description: 'High ratio of external dependencies',
+      action: 'Review external dependencies for consolidation'
+    });
+  }
+
+  return recommendations;
+}
+
+module.exports = {
+  mapFileDependencies,
+  findCircularDependencies,
+  generateDependencyReport,
+  extractImports,
+  analyzeDependency,
+  resolveModulePath,
+  isExternalDependency,
+  isNodeModule,
+  isLocalModule
+};

package/src/utils/download-with-progress.js

@@ -2,7 +2,8 @@ const fs = require('fs');
 const { pipeline } = require('stream');
 const { promisify } = require('util');
 const streamPipeline = promisify(pipeline);
-const ora = require('ora');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
 
 function progressBar(percent, width) {
   const fill = Math.round((percent / 100) * width);
@@ -18,7 +19,8 @@ function formatEta(sec) {
 }
 
 async function downloadWithProgress(url, dest, opts = {}) {
-  const fetch = require('node-fetch');
+  const fetchModule = require('node-fetch');
+  const fetch = fetchModule.default || fetchModule;
   const spinner = opts.spinner || ora();
   const label = opts.label || 'Downloading...';
   const onProgress = typeof opts.onProgress === 'function' ? opts.onProgress : null;

package/src/utils/electron-update-checker.js

@@ -48,7 +48,10 @@ const { shouldCheckUpdates } = require('./env-helpers');
  */
 async function checkForElectronUpdates(currentVersion) {
   if (!shouldCheckUpdates()) {
-    console.log('ℹ️ [UPDATE CHECK] Skipped in development environment');
+    // Quiet development message - only show in debug mode
+    if (process.env.NODE_ENV === 'development' && process.env.DEBUG) {
+      console.log('ℹ️ [UPDATE CHECK] Skipped in development environment');
+    }
     return { hasUpdate: false, currentVersion };
   }