devcompass 1.0.0

package/README.md

@@ -0,0 +1,41 @@
+# DevCompass 🧭
+
+> Health check for your JavaScript project
+
+Find unused dependencies, outdated packages, and calculate your project's health score in seconds.
+
+## 🚀 Quick Start
+```bash
+npx devcompass analyze
+```
+
+## ✨ Features
+
+- 🔍 Find unused dependencies
+- 📦 Check for outdated packages
+- 📊 Calculate health score (0-10)
+- 💡 Get actionable recommendations
+- ⚡ Fast analysis (2-3 seconds)
+
+## 📦 Installation
+
+### Option 1: npx (Recommended)
+```bash
+npx devcompass analyze
+```
+
+### Option 2: Global Installation
+```bash
+npm install -g devcompass
+devcompass analyze
+```
+
+## 🛠️ Requirements
+
+- Node.js >= 16.0.0
+- npm >= 7.0.0
+- A project with `package.json`
+
+## 📝 License
+
+MIT

package/bin/devcompass.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { analyze } = require('../src/commands/analyze');
+const packageJson = require('../package.json');
+
+const program = new Command();
+
+program
+  .name('devcompass')
+  .description('Health check for your JavaScript project')
+  .version(packageJson.version, '-v, --version', 'Display version information')
+  .addHelpText('after', `
+${chalk.gray('Author:')} Ajay Thorat
+${chalk.gray('GitHub:')} ${chalk.cyan('https://github.com/AjayBThorat-20/devcompass')}
+  `);
+
+program
+  .command('analyze')
+  .description('Analyze your project dependencies')
+  .option('-p, --path <path>', 'Project path', process.cwd())
+  .action(analyze);
+
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "devcompass",
+  "version": "1.0.0",
+  "description": "Analyze your JavaScript projects for unused dependencies and outdated packages",
+  "main": "src/index.js",
+  "bin": {
+    "devcompass": "./bin/devcompass.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "dependencies",
+    "npm",
+    "outdated",
+    "unused",
+    "analyzer",
+    "health",
+    "cli",
+    "devtools",
+    "package-manager",
+    "dependency-analysis"
+  ],
+  "author": "Ajay Thorat <ajaythorat988@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "depcheck": "^1.4.7",
+    "npm-check-updates": "^16.14.12",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AjayBThorat-20/devcompass.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AjayBThorat-20/devcompass/issues"
+  },
+  "homepage": "https://github.com/AjayBThorat-20/devcompass#readme"
+}

package/src/analyzers/outdated.js

@@ -0,0 +1,52 @@
+const ncu = require('npm-check-updates');
+const path = require('path');
+
+async function findOutdatedDeps(projectPath, dependencies) {
+  try {
+    const upgraded = await ncu.run({
+      packageFile: path.join(projectPath, 'package.json'),
+      upgrade: false,
+      silent: true,
+      jsonUpgraded: true,
+      timeout: 30000,
+      dep: 'prod,dev'
+    });
+    
+    const outdatedDeps = Object.entries(upgraded || {}).map(
+      ([name, latest]) => {
+        const current = (dependencies[name] || '')
+          .replace(/^[\^~]/, '');
+        
+        return {
+          name,
+          current,
+          latest,
+          versionsBehind: getVersionDiff(current, latest)
+        };
+      }
+    );
+    
+    return outdatedDeps;
+  } catch (error) {
+    console.error('Error in findOutdatedDeps:', error.message);
+    throw error;
+  }
+}
+
+function getVersionDiff(current, latest) {
+  const currParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+  
+  while (currParts.length < 3) currParts.push(0);
+  while (latestParts.length < 3) latestParts.push(0);
+  
+  if (currParts[0] !== latestParts[0]) {
+    return 'major update';
+  } else if (currParts[1] !== latestParts[1]) {
+    return 'minor update';
+  } else {
+    return 'patch update';
+  }
+}
+
+module.exports = { findOutdatedDeps };

package/src/analyzers/scoring.js

@@ -0,0 +1,37 @@
+function calculateScore(totalDeps, unusedCount, outdatedCount) {
+  let score = 10;
+  
+  if (totalDeps === 0) {
+    return {
+      total: 10.0,
+      breakdown: {
+        unused: 0,
+        outdated: 0,
+        unusedPenalty: 0,
+        outdatedPenalty: 0
+      }
+    };
+  }
+  
+  const unusedRatio = unusedCount / totalDeps;
+  const unusedPenalty = unusedRatio * 4;
+  score -= unusedPenalty;
+  
+  const outdatedRatio = outdatedCount / totalDeps;
+  const outdatedPenalty = outdatedRatio * 3;
+  score -= outdatedPenalty;
+  
+  score = Math.max(0, Math.min(10, score));
+  
+  return {
+    total: parseFloat(score.toFixed(1)),
+    breakdown: {
+      unused: unusedCount,
+      outdated: outdatedCount,
+      unusedPenalty: parseFloat(unusedPenalty.toFixed(1)),
+      outdatedPenalty: parseFloat(outdatedPenalty.toFixed(1))
+    }
+  };
+}
+
+module.exports = { calculateScore };

package/src/analyzers/unused-deps.js

@@ -0,0 +1,51 @@
+const depcheck = require('depcheck');
+
+async function findUnusedDeps(projectPath, dependencies) {
+  const options = {
+    ignoreBinPackage: false,
+    skipMissing: true,
+    ignorePatterns: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      '.next/**',
+      'coverage/**',
+      'out/**',
+      '*.min.js'
+    ],
+    ignoreMatches: [
+      'react',
+      'react-dom',
+      'react-native',
+      'next',
+      '@angular/core',
+      '@angular/common',
+      '@angular/platform-browser',
+      '@nestjs/core',
+      '@nestjs/common',
+      '@nestjs/platform-express',
+      'typescript',
+      '@types/*',
+      'webpack',
+      'vite',
+      'rollup',
+      'esbuild',
+      'jest',
+      'vitest',
+      'mocha',
+      '@testing-library/*'
+    ]
+    // REMOVED parsers - let depcheck use defaults
+  };
+  
+  try {
+    const results = await depcheck(projectPath, options);
+    const unusedDeps = results.dependencies.map(name => ({ name }));
+    return unusedDeps;
+  } catch (error) {
+    console.error('Error in findUnusedDeps:', error.message);
+    throw error;
+  }
+}
+
+module.exports = { findUnusedDeps };

package/src/commands/analyze.js

@@ -0,0 +1,188 @@
+// src/commands/analyze.js
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const fs = require('fs');
+
+const { findUnusedDeps } = require('../analyzers/unused-deps');
+const { findOutdatedDeps } = require('../analyzers/outdated');
+const { calculateScore } = require('../analyzers/scoring');
+const { 
+  log, 
+  logSection, 
+  logDivider,
+  getScoreColor 
+} = require('../utils/logger');
+
+async function analyze(options) {
+  const projectPath = options.path || process.cwd();
+  
+  console.log('\n');
+  log(chalk.cyan.bold('🔍 DevCompass v1.0.0') + ' - Analyzing your project...\n');
+  
+  const spinner = ora({
+    text: 'Loading project...',
+    color: 'cyan'
+  }).start();
+  
+  try {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    
+    if (!fs.existsSync(packageJsonPath)) {
+      spinner.fail(chalk.red('No package.json found in current directory'));
+      console.log(chalk.yellow('\n💡 Make sure you run this command in a project directory.\n'));
+      process.exit(1);
+    }
+    
+    let packageJson;
+    try {
+      const fileContent = fs.readFileSync(packageJsonPath, 'utf8');
+      packageJson = JSON.parse(fileContent);
+    } catch (error) {
+      spinner.fail(chalk.red('Invalid package.json format'));
+      console.log(chalk.yellow(`\n💡 Error: ${error.message}\n`));
+      process.exit(1);
+    }
+    
+    const dependencies = {
+      ...(packageJson.dependencies || {}),
+      ...(packageJson.devDependencies || {})
+    };
+    
+    const totalDeps = Object.keys(dependencies).length;
+    
+    if (totalDeps === 0) {
+      spinner.succeed(chalk.green('No dependencies found'));
+      console.log(chalk.gray('\n✨ Nothing to analyze - your project has no dependencies.\n'));
+      process.exit(0);
+    }
+    
+    spinner.text = 'Detecting unused dependencies...';
+    
+    let unusedDeps = [];
+    try {
+      unusedDeps = await findUnusedDeps(projectPath, dependencies);
+    } catch (error) {
+      console.log(chalk.yellow('\n⚠️  Could not detect unused dependencies'));
+      console.log(chalk.gray(`   Error: ${error.message}\n`));
+    }
+    
+    spinner.text = 'Checking for outdated packages...';
+    
+    let outdatedDeps = [];
+    try {
+      outdatedDeps = await findOutdatedDeps(projectPath, dependencies);
+    } catch (error) {
+      console.log(chalk.yellow('\n⚠️  Could not check for outdated packages'));
+      console.log(chalk.gray(`   Error: ${error.message}\n`));
+    }
+    
+    const score = calculateScore(
+      totalDeps,
+      unusedDeps.length,
+      outdatedDeps.length
+    );
+    
+    spinner.succeed(chalk.green(`Scanned ${totalDeps} dependencies in project`));
+    
+    displayResults(unusedDeps, outdatedDeps, score, totalDeps);
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Analysis failed'));
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    if (process.env.DEBUG) {
+      console.log(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+function displayResults(unusedDeps, outdatedDeps, score, totalDeps) {
+  logDivider();
+  
+  if (unusedDeps.length > 0) {
+    logSection('🔴 UNUSED DEPENDENCIES', unusedDeps.length);
+    
+    const displayCount = Math.min(5, unusedDeps.length);
+    unusedDeps.slice(0, displayCount).forEach(dep => {
+      log(`  ${chalk.red('●')} ${dep.name}`);
+    });
+    
+    if (unusedDeps.length > 5) {
+      log(chalk.gray(`\n  ... and ${unusedDeps.length - 5} more\n`));
+    }
+    
+    log(chalk.gray('\n  Why marked unused:'));
+    log(chalk.gray('  • No import/require found in source files'));
+    log(chalk.gray('  • Excludes node_modules, build folders'));
+    log(chalk.gray('  • May include false positives - verify before removing\n'));
+  } else {
+    logSection('✅ UNUSED DEPENDENCIES');
+    log(chalk.green('  No unused dependencies detected!\n'));
+  }
+  
+  logDivider();
+  
+  if (outdatedDeps.length > 0) {
+    logSection('🟡 OUTDATED PACKAGES', outdatedDeps.length);
+    
+    const displayCount = Math.min(5, outdatedDeps.length);
+    outdatedDeps.slice(0, displayCount).forEach(dep => {
+      const nameCol = dep.name.padEnd(20);
+      const currentVer = chalk.yellow(dep.current);
+      const arrow = chalk.gray('→');
+      const latestVer = chalk.green(dep.latest);
+      const updateType = chalk.gray(`(${dep.versionsBehind})`);
+      
+      log(`  ${nameCol} ${currentVer} ${arrow} ${latestVer}  ${updateType}`);
+    });
+    
+    if (outdatedDeps.length > 5) {
+      log(chalk.gray(`\n  ... and ${outdatedDeps.length - 5} more\n`));
+    }
+  } else {
+    logSection('✅ OUTDATED PACKAGES');
+    log(chalk.green('  All packages are up to date!\n'));
+  }
+  
+  logDivider();
+  
+  logSection('📊 PROJECT HEALTH');
+  
+  const scoreColor = getScoreColor(score.total);
+  log(`  Overall Score:              ${scoreColor(score.total + '/10')}`);
+  log(`  Total Dependencies:         ${chalk.cyan(totalDeps)}`);
+  log(`  Unused:                     ${chalk.red(unusedDeps.length)}`);
+  log(`  Outdated:                   ${chalk.yellow(outdatedDeps.length)}\n`);
+  
+  logDivider();
+  
+  if (unusedDeps.length > 0) {
+    logSection('💡 QUICK WIN');
+    log('  Clean up unused dependencies:\n');
+    
+    const packagesToRemove = unusedDeps
+      .slice(0, 5)
+      .map(d => d.name)
+      .join(' ');
+    
+    log(chalk.cyan(`  npm uninstall ${packagesToRemove}\n`));
+    
+    log('  Expected impact:');
+    log(`  ${chalk.green('✓')} Remove ${unusedDeps.length} unused package${unusedDeps.length > 1 ? 's' : ''}`);
+    log(`  ${chalk.green('✓')} Reduce node_modules size`);
+    
+    const improvedScore = calculateScore(
+      totalDeps - unusedDeps.length,
+      0,
+      outdatedDeps.length
+    );
+    
+    const improvedScoreColor = getScoreColor(improvedScore.total);
+    log(`  ${chalk.green('✓')} Improve health score → ${improvedScoreColor(improvedScore.total + '/10')}\n`);
+    
+    logDivider();
+  }
+}
+
+module.exports = { analyze };

package/src/utils/logger.js

@@ -0,0 +1,36 @@
+const chalk = require('chalk');
+
+function log(message) {
+  console.log(message);
+}
+
+function logSection(title, count) {
+  const countStr = count !== undefined 
+    ? chalk.gray(` (${count})`) 
+    : '';
+  log(chalk.bold(`\n${title}${countStr}\n`));
+}
+
+function logDivider() {
+  const line = '━'.repeat(70);
+  log(chalk.gray(line) + '\n');
+}
+
+function getScoreColor(score) {
+  if (score >= 8) {
+    return chalk.green.bold;
+  } else if (score >= 6) {
+    return chalk.yellow.bold;
+  } else {
+    return chalk.red.bold;
+  }
+}
+
+module.exports = { 
+  log, 
+  logSection, 
+  logDivider,
+  getScoreColor
+};
+
+