@saismrutiranjan18/why-slow 1.0.0

package/bin/why-slow.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { scanProject } from "../src/scanner.js";
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+Usage: why-slow [options]
+
+Options:
+  --html     Generate an HTML report (performance-report.html)
+  --help     Show this help message
+`);
+  process.exit(0);
+}
+
+await scanProject({
+  html: args.includes("--html"),
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@saismrutiranjan18/why-slow",
+  "version": "1.0.0",
+  "description": "CLI tool to diagnose why your Node.js project is slow — scans for large files, oversized images, circular dependencies, and unused packages.",
+  "type": "module",
+  "bin": {
+    "why-slow": "./bin/why-slow.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "performance",
+    "cli",
+    "audit",
+    "circular-dependencies",
+    "unused-dependencies",
+    "bundle-size",
+    "why-slow"
+  ],
+  "author": "saismrutiranjan18",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/saismrutiranjan18/npm-workspace"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "depcheck": "^1.4.7",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.5",
+    "madge": "^8.0.0"
+  }
+}

package/src/scanner.js

@@ -0,0 +1,316 @@
+import fg from "fast-glob";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import madge from "madge";
+import depcheck from "depcheck";
+import fsExtra from "fs-extra";
+
+const ICONS = {
+  info: chalk.blue("i"),
+  pass: chalk.green("✓"),
+  warn: chalk.yellow("!"),
+  error: chalk.red("✖"),
+};
+
+// FIX #3: Factory function instead of module-level state,
+// so calling scanProject() twice never accumulates stale data.
+function createReport() {
+  return {
+    largeFiles: [],
+    largeImages: [],
+    circularDeps: [],
+    unusedDeps: [],
+    nodeModulesSize: 0,
+  };
+}
+
+export async function scanProject(options = {}) {
+  console.clear();
+
+  console.log(chalk.bold.cyan("\nWHY-SLOW v1.1"));
+  console.log(chalk.gray("────────────────────────────────────"));
+
+  // FIX #3: fresh report each run
+  const report = createReport();
+
+  await scanLargeFiles(report);
+  await scanImages(report);
+  await scanCircularDependencies(report);
+  await scanUnusedDependencies(report);
+  await scanNodeModules(report);
+
+  printSummary(report);
+
+  if (options.html) {
+    await generateHtmlReport(report);
+  }
+}
+
+async function scanLargeFiles(report) {
+  console.log(`\n${ICONS.info} ${chalk.bold("Largest Source Files")}`);
+
+  const files = await fg(["src/**/*.{js,jsx,ts,tsx}"], {
+    cwd: process.cwd(),
+    absolute: true,
+  });
+
+  const results = [];
+
+  for (const file of files) {
+    try {
+      const size = fs.statSync(file).size;
+      results.push({ file, size });
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  results.sort((a, b) => b.size - a.size);
+
+  const topFiles = results.slice(0, 10);
+
+  for (const { file, size } of topFiles) {
+    const kb = (size / 1024).toFixed(1);
+
+    if (size > 200 * 1024) {
+      report.largeFiles.push({ file, size: kb });
+      console.log(`${ICONS.warn} ${file} (${kb} KB)`);
+    }
+  }
+
+  if (report.largeFiles.length === 0) {
+    console.log(`${ICONS.pass} No oversized source files found`);
+  }
+}
+
+async function scanImages(report) {
+  console.log(`\n${ICONS.info} ${chalk.bold("Image Analysis")}`);
+
+  const images = await fg(["**/*.{png,jpg,jpeg,webp,svg}"], {
+    ignore: ["node_modules/**"],
+    cwd: process.cwd(),
+    absolute: true,
+  });
+
+  let found = false;
+
+  for (const image of images) {
+    try {
+      const size = fs.statSync(image).size;
+
+      if (size > 500 * 1024) {
+        found = true;
+        const mb = (size / 1024 / 1024).toFixed(2);
+        report.largeImages.push({ file: image, size: mb });
+        console.log(`${ICONS.warn} ${image} (${mb} MB)`);
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  if (!found) {
+    console.log(`${ICONS.pass} No oversized images found`);
+  }
+}
+
+async function scanCircularDependencies(report) {
+  console.log(`\n${ICONS.info} ${chalk.bold("Circular Dependencies")}`);
+
+  try {
+    // FIX #4: use absolute path so madge works regardless of cwd
+    const srcPath = path.join(process.cwd(), "src");
+
+    if (!fs.existsSync(srcPath)) {
+      console.log(`${ICONS.warn} No src/ directory found, skipping`);
+      return;
+    }
+
+    const result = await madge(srcPath);
+    const circular = result.circular();
+
+    report.circularDeps = circular;
+
+    if (!circular.length) {
+      console.log(`${ICONS.pass} No circular dependencies found`);
+      return;
+    }
+
+    circular.forEach((dep) => {
+      console.log(`${ICONS.error} ${dep.join(" → ")}`);
+    });
+  } catch (error) {
+    console.log(`${ICONS.warn} Unable to analyze circular dependencies`);
+  }
+}
+
+async function scanUnusedDependencies(report) {
+  console.log(`\n${ICONS.info} ${chalk.bold("Unused Dependencies")}`);
+
+  try {
+    const result = await depcheck(process.cwd(), {});
+
+    // FIX #2: depcheck returns { dependencies: [...], devDependencies: [...] }
+    // at the top level — but the shape is an object of unused dep names.
+    // result.dependencies is an array of unused production dep names.
+    const unused = Array.isArray(result.dependencies) ? result.dependencies : [];
+
+    report.unusedDeps = unused;
+
+    if (!unused.length) {
+      console.log(`${ICONS.pass} No unused dependencies found`);
+      return;
+    }
+
+    unused.forEach((dep) => {
+      console.log(`${ICONS.warn} ${dep}`);
+    });
+  } catch (error) {
+    console.log(`${ICONS.warn} Unable to analyze dependencies`);
+  }
+}
+
+async function scanNodeModules(report) {
+  console.log(`\n${ICONS.info} ${chalk.bold("Dependencies")}`);
+
+  const nodeModules = path.join(process.cwd(), "node_modules");
+
+  if (!fs.existsSync(nodeModules)) {
+    console.log(`${ICONS.warn} node_modules not found`);
+    return;
+  }
+
+  const size = getFolderSize(nodeModules);
+  report.nodeModulesSize = (size / 1024 / 1024).toFixed(2);
+
+  console.log(
+    `${ICONS.info} node_modules size: ${report.nodeModulesSize} MB`
+  );
+}
+
+// FIX #1: guard against symlinks and permission errors that crash statSync
+function getFolderSize(folder) {
+  let total = 0;
+
+  let files;
+  try {
+    files = fs.readdirSync(folder);
+  } catch {
+    return 0;
+  }
+
+  for (const file of files) {
+    const fullPath = path.join(folder, file);
+
+    try {
+      // lstatSync instead of statSync — does NOT follow symlinks,
+      // so broken symlinks in node_modules no longer throw.
+      const stat = fs.lstatSync(fullPath);
+
+      if (stat.isSymbolicLink()) {
+        // skip symlinks entirely; they don't contribute real disk usage
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        total += getFolderSize(fullPath);
+      } else {
+        total += stat.size;
+      }
+    } catch {
+      // skip any entry that can't be stat'd
+    }
+  }
+
+  return total;
+}
+
+function printSummary(report) {
+  let score = 100;
+
+  score -= report.largeFiles.length * 5;
+  score -= report.largeImages.length * 5;
+  score -= report.circularDeps.length * 10;
+  score -= report.unusedDeps.length * 2;
+
+  score = Math.max(score, 0);
+
+  console.log("\n" + chalk.gray("────────────────────────────────────"));
+  console.log(chalk.bold("\nPerformance Summary\n"));
+
+  console.log(`${ICONS.info} Large Files: ${report.largeFiles.length}`);
+  console.log(`${ICONS.info} Large Images: ${report.largeImages.length}`);
+  console.log(`${ICONS.info} Circular Dependencies: ${report.circularDeps.length}`);
+  console.log(`${ICONS.info} Unused Dependencies: ${report.unusedDeps.length}`);
+
+  console.log();
+
+  if (score >= 90) {
+    console.log(chalk.green(`${ICONS.pass} Performance Score: ${score}/100`));
+  } else if (score >= 70) {
+    console.log(chalk.yellow(`${ICONS.warn} Performance Score: ${score}/100`));
+  } else {
+    console.log(chalk.red(`${ICONS.error} Performance Score: ${score}/100`));
+  }
+
+  console.log(chalk.gray("\n────────────────────────────────────"));
+  console.log(chalk.bold("\nScan completed successfully.\n"));
+}
+
+async function generateHtmlReport(report) {
+  const html = `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<title>WHY-SLOW Report</title>
+<style>
+body { font-family: Arial, sans-serif; padding: 40px; max-width: 1200px; margin: auto; background: #f5f5f5; }
+.card { background: white; padding: 20px; margin-bottom: 20px; border-radius: 10px; box-shadow: 0 2px 8px rgba(0,0,0,.1); }
+h1 { margin-bottom: 30px; }
+ul { padding-left: 20px; }
+.empty { color: #888; font-style: italic; }
+</style>
+</head>
+<body>
+<h1>WHY-SLOW Performance Report</h1>
+
+<div class="card">
+<h2>Node Modules Size</h2>
+<p>${report.nodeModulesSize} MB</p>
+</div>
+
+<div class="card">
+<h2>Large Files</h2>
+${report.largeFiles.length
+  ? `<ul>${report.largeFiles.map(f => `<li>${f.file} — ${f.size} KB</li>`).join("")}</ul>`
+  : `<p class="empty">None found</p>`}
+</div>
+
+<div class="card">
+<h2>Large Images</h2>
+${report.largeImages.length
+  ? `<ul>${report.largeImages.map(i => `<li>${i.file} — ${i.size} MB</li>`).join("")}</ul>`
+  : `<p class="empty">None found</p>`}
+</div>
+
+<div class="card">
+<h2>Circular Dependencies</h2>
+${report.circularDeps.length
+  ? `<ul>${report.circularDeps.map(c => `<li>${c.join(" → ")}</li>`).join("")}</ul>`
+  : `<p class="empty">None found</p>`}
+</div>
+
+<div class="card">
+<h2>Unused Dependencies</h2>
+${report.unusedDeps.length
+  ? `<ul>${report.unusedDeps.map(d => `<li>${d}</li>`).join("")}</ul>`
+  : `<p class="empty">None found</p>`}
+</div>
+
+</body>
+</html>`;
+
+  await fsExtra.writeFile("performance-report.html", html);
+  console.log(chalk.green("\n✓ HTML report generated: performance-report.html\n"));
+}