devcompass 1.0.5 → 2.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devcompass",
-  "version": "1.0.5",
-  "description": "Analyze your JavaScript projects for unused dependencies and outdated packages",
+  "version": "2.2.0",
+  "description": "Dependency health checker with ecosystem intelligence for JavaScript/TypeScript projects",
   "main": "src/index.js",
   "bin": {
     "devcompass": "./bin/devcompass.js"
@@ -9,6 +9,7 @@
   "files": [
     "bin/",
     "src/",
+    "data/",
     "README.md",
     "LICENSE"
   ],
@@ -25,7 +26,14 @@
     "cli",
     "devtools",
     "package-manager",
-    "dependency-analysis"
+    "dependency-analysis",
+    "security",
+    "ecosystem",
+    "alerts",
+    "ci-cd",
+    "automation",
+    "caching",
+    "json-output"
   ],
   "author": "Ajay Thorat <ajaythorat988@gmail.com>",
   "license": "MIT",
@@ -34,7 +42,8 @@
     "commander": "^11.1.0",
     "depcheck": "^1.4.7",
     "npm-check-updates": "^16.14.12",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "semver": "^7.6.0"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -47,4 +56,4 @@
     "url": "https://github.com/AjayBThorat-20/devcompass/issues"
   },
   "homepage": "https://github.com/AjayBThorat-20/devcompass#readme"
-}
+}

package/src/alerts/formatter.js

@@ -0,0 +1,69 @@
+// src/alerts/formatter.js
+const chalk = require('chalk');
+
+/**
+ * Format alerts for terminal output
+ */
+function formatAlerts(alerts) {
+  if (alerts.length === 0) {
+    return null;
+  }
+  
+  // Group alerts by package
+  const grouped = {};
+  
+  alerts.forEach(alert => {
+    if (!grouped[alert.package]) {
+      grouped[alert.package] = [];
+    }
+    grouped[alert.package].push(alert);
+  });
+  
+  return grouped;
+}
+
+/**
+ * Get severity emoji and color
+ */
+function getSeverityDisplay(severity) {
+  const displays = {
+    critical: { emoji: '🔴', color: chalk.red.bold, label: 'CRITICAL' },
+    high: { emoji: '🟠', color: chalk.red, label: 'HIGH' },
+    medium: { emoji: '🟡', color: chalk.yellow, label: 'MEDIUM' },
+    low: { emoji: '⚪', color: chalk.gray, label: 'LOW' }
+  };
+  
+  return displays[severity] || displays.medium;
+}
+
+/**
+ * Calculate alert impact on health score
+ */
+function calculateAlertPenalty(alerts) {
+  let penalty = 0;
+  
+  alerts.forEach(alert => {
+    switch (alert.severity) {
+      case 'critical':
+        penalty += 2.0;
+        break;
+      case 'high':
+        penalty += 1.5;
+        break;
+      case 'medium':
+        penalty += 0.5;
+        break;
+      case 'low':
+        penalty += 0.2;
+        break;
+    }
+  });
+  
+  return Math.min(penalty, 5.0); // Cap at 5 points max
+}
+
+module.exports = { 
+  formatAlerts, 
+  getSeverityDisplay, 
+  calculateAlertPenalty 
+};

package/src/alerts/index.js

@@ -0,0 +1,32 @@
+// src/alerts/index.js
+const { matchIssues } = require('./matcher');
+const { formatAlerts } = require('./formatter');
+const { resolveInstalledVersions } = require('./resolver');
+const path = require('path');
+const fs = require('fs');
+
+async function checkEcosystemAlerts(projectPath, dependencies) {
+  try {
+    // Load issues database
+    const issuesDbPath = path.join(__dirname, '../../data/issues-db.json');
+    
+    if (!fs.existsSync(issuesDbPath)) {
+      return []; // No alerts if database doesn't exist
+    }
+    
+    const issuesDb = JSON.parse(fs.readFileSync(issuesDbPath, 'utf8'));
+    
+    // Resolve installed versions from node_modules
+    const installedVersions = await resolveInstalledVersions(projectPath, dependencies);
+    
+    // Match issues against installed versions
+    const alerts = matchIssues(installedVersions, issuesDb);
+    
+    return alerts;
+  } catch (error) {
+    console.error('Error in checkEcosystemAlerts:', error.message);
+    return []; // Return empty array on error, don't break analysis
+  }
+}
+
+module.exports = { checkEcosystemAlerts };

package/src/alerts/matcher.js

@@ -0,0 +1,51 @@
+// src/alerts/matcher.js
+const semver = require('semver');
+
+/**
+ * Match installed packages against known issues database
+ */
+function matchIssues(installedVersions, issuesDb) {
+  const alerts = [];
+  
+  for (const [packageName, versionInfo] of Object.entries(installedVersions)) {
+    // Check if this package has known issues
+    if (!issuesDb[packageName]) {
+      continue;
+    }
+    
+    const packageIssues = issuesDb[packageName];
+    const installedVersion = versionInfo.version;
+    
+    // Check each issue for this package
+    for (const issue of packageIssues) {
+      try {
+        // Use semver to check if installed version is affected
+        if (semver.satisfies(installedVersion, issue.affected)) {
+          alerts.push({
+            package: packageName,
+            version: installedVersion,
+            severity: issue.severity,
+            title: issue.title,
+            affected: issue.affected,
+            fix: issue.fix || null,
+            source: issue.source || null,
+            reported: issue.reported || null
+          });
+        }
+      } catch (error) {
+        // Skip if semver parsing fails
+        continue;
+      }
+    }
+  }
+  
+  // Sort by severity: critical > high > medium > low
+  const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  alerts.sort((a, b) => {
+    return severityOrder[a.severity] - severityOrder[b.severity];
+  });
+  
+  return alerts;
+}
+
+module.exports = { matchIssues };

package/src/alerts/resolver.js

@@ -0,0 +1,46 @@
+// src/alerts/resolver.js
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Resolve actual installed versions from node_modules
+ * This is CRITICAL - we need installed version, not package.json version
+ */
+async function resolveInstalledVersions(projectPath, dependencies) {
+  const installedVersions = {};
+  
+  for (const [packageName, declaredVersion] of Object.entries(dependencies)) {
+    try {
+      const packageJsonPath = path.join(
+        projectPath,
+        'node_modules',
+        packageName,
+        'package.json'
+      );
+      
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        installedVersions[packageName] = {
+          name: packageName,
+          version: packageJson.version, // Clean version like "1.6.0"
+          declaredVersion: declaredVersion // What's in package.json like "^1.6.0"
+        };
+      } else {
+        // Fallback: use declared version (strip prefixes)
+        const cleanVersion = declaredVersion.replace(/^[\^~>=<]/, '');
+        installedVersions[packageName] = {
+          name: packageName,
+          version: cleanVersion,
+          declaredVersion: declaredVersion
+        };
+      }
+    } catch (error) {
+      // Skip packages that can't be resolved
+      continue;
+    }
+  }
+  
+  return installedVersions;
+}
+
+module.exports = { resolveInstalledVersions };

package/src/analyzers/outdated.js

@@ -1,3 +1,5 @@
+// src/analyzers/outdated.js
+
 const ncu = require('npm-check-updates');
 const path = require('path');
 

package/src/analyzers/scoring.js

@@ -1,4 +1,5 @@
-function calculateScore(totalDeps, unusedCount, outdatedCount) {
+// src/analyzers/scoring.js
+function calculateScore(totalDeps, unusedCount, outdatedCount, alertsCount = 0, alertPenalty = 0) {
   let score = 10;
   
   if (totalDeps === 0) {
@@ -7,20 +8,28 @@ function calculateScore(totalDeps, unusedCount, outdatedCount) {
       breakdown: {
         unused: 0,
         outdated: 0,
+        alerts: 0,
         unusedPenalty: 0,
-        outdatedPenalty: 0
+        outdatedPenalty: 0,
+        alertsPenalty: 0
       }
     };
   }
   
+  // Unused dependencies penalty
   const unusedRatio = unusedCount / totalDeps;
   const unusedPenalty = unusedRatio * 4;
   score -= unusedPenalty;
   
+  // Outdated packages penalty
   const outdatedRatio = outdatedCount / totalDeps;
   const outdatedPenalty = outdatedRatio * 3;
   score -= outdatedPenalty;
   
+  // Ecosystem alerts penalty (from formatter.calculateAlertPenalty)
+  score -= alertPenalty;
+  
+  // Ensure score is between 0 and 10
   score = Math.max(0, Math.min(10, score));
   
   return {
@@ -28,8 +37,10 @@ function calculateScore(totalDeps, unusedCount, outdatedCount) {
     breakdown: {
       unused: unusedCount,
       outdated: outdatedCount,
+      alerts: alertsCount,
       unusedPenalty: parseFloat(unusedPenalty.toFixed(1)),
-      outdatedPenalty: parseFloat(outdatedPenalty.toFixed(1))
+      outdatedPenalty: parseFloat(outdatedPenalty.toFixed(1)),
+      alertsPenalty: parseFloat(alertPenalty.toFixed(1))
     }
   };
 }

package/src/analyzers/unused-deps.js

@@ -1,3 +1,4 @@
+// src/analyzers/unused-deps.js
 const depcheck = require('depcheck');
 
 async function findUnusedDeps(projectPath, dependencies) {

package/src/cache/manager.js

@@ -0,0 +1,90 @@
+// src/cache/manager.js
+const fs = require('fs');
+const path = require('path');
+
+const CACHE_FILE = '.devcompass-cache.json';
+const CACHE_DURATION = 3600000; // 1 hour in milliseconds
+
+/**
+ * Load cache from disk
+ */
+function loadCache(projectPath) {
+  try {
+    const cachePath = path.join(projectPath, CACHE_FILE);
+    
+    if (!fs.existsSync(cachePath)) {
+      return {};
+    }
+    
+    const cacheData = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    return cacheData;
+  } catch (error) {
+    return {};
+  }
+}
+
+/**
+ * Save cache to disk
+ */
+function saveCache(projectPath, cacheData) {
+  try {
+    const cachePath = path.join(projectPath, CACHE_FILE);
+    fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), 'utf8');
+  } catch (error) {
+    // Silent fail - caching is not critical
+  }
+}
+
+/**
+ * Get cached data if still valid
+ */
+function getCached(projectPath, key) {
+  const cache = loadCache(projectPath);
+  
+  if (!cache[key]) {
+    return null;
+  }
+  
+  const cached = cache[key];
+  const age = Date.now() - cached.timestamp;
+  
+  if (age > CACHE_DURATION) {
+    return null; // Expired
+  }
+  
+  return cached.data;
+}
+
+/**
+ * Set cache entry
+ */
+function setCache(projectPath, key, data) {
+  const cache = loadCache(projectPath);
+  
+  cache[key] = {
+    timestamp: Date.now(),
+    data: data
+  };
+  
+  saveCache(projectPath, cache);
+}
+
+/**
+ * Clear all cache
+ */
+function clearCache(projectPath) {
+  try {
+    const cachePath = path.join(projectPath, CACHE_FILE);
+    if (fs.existsSync(cachePath)) {
+      fs.unlinkSync(cachePath);
+    }
+  } catch (error) {
+    // Silent fail
+  }
+}
+
+module.exports = {
+  getCached,
+  setCache,
+  clearCache
+};