roast-my-codebase 1.2.0 → 1.3.0

package/dist/bundle-OG535XKC.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  BundleSizeScanner,
+  formatBytes
+} from "./chunk-4KMMPANT.js";
+export {
+  BundleSizeScanner,
+  formatBytes
+};

package/dist/chunk-4KMMPANT.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scanners/bundle.ts
+import fg from "fast-glob";
+import fs from "fs";
+import path from "path";
+
+// src/utils/constants.ts
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  // Python
+  ".go",
+  // Go
+  ".rs",
+  // Rust
+  ".java",
+  // Java
+  ".cs",
+  // C#
+  ".rb",
+  // Ruby
+  ".php",
+  // PHP
+  ".swift",
+  // Swift
+  ".kt",
+  // Kotlin
+  ".kts"
+  // Kotlin script
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.git/**",
+  "**/.turbo/**",
+  "**/.cache/**",
+  "**/out/**",
+  "**/.output/**"
+];
+function buildIgnorePatterns(extraPatterns = []) {
+  return [...IGNORE_PATTERNS, ...extraPatterns];
+}
+var SAFE_GLOB_OPTIONS = {
+  followSymbolicLinks: false,
+  deep: 20
+};
+var LARGE_FILE_THRESHOLDS = {
+  warning: 500,
+  large: 1e3,
+  extreme: 2e3
+};
+var HEALTH_DEDUCTIONS = {
+  unusedDependency: -2,
+  todo: -0.25,
+  largeFile: -3,
+  extremeFile: -5,
+  circularDependency: -5,
+  criticalIssue: -10,
+  excessiveDeps: -5,
+  deepNesting: -2,
+  utilExplosion: -1,
+  complexFunction: -2,
+  veryComplexFunction: -4,
+  duplicateCode: -3,
+  deadExport: -1,
+  typeSafetyIssue: -2,
+  criticalTypeSafety: -5,
+  gitChurn: -3,
+  largePRSize: -2,
+  secret: -10,
+  envInGit: -10,
+  evalUsage: -3,
+  missingTest: -0.5,
+  frameworkViolation: -2
+};
+
+// src/scanners/bundle.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+var OUTPUT_DIRS = ["dist", "build", ".next", "out", ".output"];
+var BundleSizeScanner = class {
+  constructor() {
+    this.name = "bundle-size";
+  }
+  async scan(rootDir) {
+    let outputDir = null;
+    for (const dir of OUTPUT_DIRS) {
+      const candidate = path.join(rootDir, dir);
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+        outputDir = candidate;
+        break;
+      }
+    }
+    if (!outputDir) {
+      return {
+        findings: [],
+        stats: { skipped: true, reason: "No build output found (run build first)" }
+      };
+    }
+    const files = await fg(["**/*.{js,mjs,cjs,css,wasm}"], {
+      cwd: outputDir,
+      ignore: ["**/node_modules/**", "**/*.map", "**/*.LICENSE.*"],
+      ...SAFE_GLOB_OPTIONS,
+      absolute: true
+    });
+    const currentSizes = {};
+    let totalBytes = 0;
+    for (const file of files) {
+      const rel = path.relative(outputDir, file).replace(/\\/g, "/");
+      const size = fs.statSync(file).size;
+      currentSizes[rel] = size;
+      totalBytes += size;
+    }
+    const cachePath = path.join(rootDir, ".roast-bundle-sizes.json");
+    let previousCache = null;
+    if (fs.existsSync(cachePath)) {
+      try {
+        previousCache = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+      } catch {
+      }
+    }
+    const findings = [];
+    if (!previousCache) {
+      if (totalBytes > 5 * 1024 * 1024) {
+        findings.push({
+          id: "bundle-size-total-critical",
+          severity: "critical",
+          category: "bundle-size",
+          message: `Total bundle size is ${formatBytes(totalBytes)} \u2014 that's a lot to send over the wire`,
+          detail: `${formatBytes(totalBytes)}`
+        });
+      } else if (totalBytes > 1024 * 1024) {
+        findings.push({
+          id: "bundle-size-total-warning",
+          severity: "warning",
+          category: "bundle-size",
+          message: `Total bundle size is ${formatBytes(totalBytes)}`,
+          detail: `${formatBytes(totalBytes)}`
+        });
+      }
+    } else {
+      const previousSizes = previousCache.sizes;
+      for (const [file, curr] of Object.entries(currentSizes)) {
+        const prev = previousSizes[file];
+        if (prev === void 0) {
+          if (curr > 100 * 1024) {
+            findings.push({
+              id: `bundle-size-new-${file}`,
+              severity: "info",
+              category: "bundle-size",
+              message: `New bundle file ${file} (${formatBytes(curr)})`,
+              file,
+              detail: formatBytes(curr)
+            });
+          }
+        } else {
+          const delta = (curr - prev) / prev * 100;
+          const growthBytes = curr - prev;
+          if (delta > 50 && growthBytes > 50 * 1024) {
+            findings.push({
+              id: `bundle-size-critical-${file}`,
+              severity: "critical",
+              category: "bundle-size",
+              message: `${file} grew ${delta.toFixed(0)}% (${formatBytes(prev)} \u2192 ${formatBytes(curr)})`,
+              file,
+              detail: `+${delta.toFixed(0)}%`
+            });
+          } else if (delta > 10 && growthBytes > 10 * 1024) {
+            findings.push({
+              id: `bundle-size-warning-${file}`,
+              severity: "warning",
+              category: "bundle-size",
+              message: `${file} grew ${delta.toFixed(0)}% (${formatBytes(prev)} \u2192 ${formatBytes(curr)})`,
+              file,
+              detail: `+${delta.toFixed(0)}%`
+            });
+          }
+        }
+      }
+      for (const file of Object.keys(previousSizes)) {
+        if (!(file in currentSizes)) {
+          findings.push({
+            id: `bundle-size-removed-${file}`,
+            severity: "info",
+            category: "bundle-size",
+            message: `${file} removed from bundle`,
+            file
+          });
+        }
+      }
+      const prevTotal = Object.values(previousSizes).reduce((a, b) => a + b, 0);
+      if (prevTotal > 0) {
+        const totalDelta = (totalBytes - prevTotal) / prevTotal * 100;
+        if (totalDelta > 20) {
+          findings.push({
+            id: "bundle-size-total-growth",
+            severity: "warning",
+            category: "bundle-size",
+            message: `Total bundle size grew ${totalDelta.toFixed(0)}% (${formatBytes(prevTotal)} \u2192 ${formatBytes(totalBytes)})`,
+            detail: `+${totalDelta.toFixed(0)}%`
+          });
+        }
+      }
+    }
+    const newCache = { timestamp: Date.now(), sizes: currentSizes };
+    try {
+      fs.writeFileSync(cachePath, JSON.stringify(newCache, null, 2), "utf-8");
+    } catch {
+    }
+    const relativeOutputDir = outputDir.replace(rootDir, ".");
+    return {
+      findings,
+      stats: {
+        totalBytes,
+        totalFormatted: formatBytes(totalBytes),
+        fileCount: files.length,
+        outputDir: relativeOutputDir,
+        hasBaseline: previousCache !== null
+      }
+    };
+  }
+};
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  SOURCE_EXTENSIONS,
+  IGNORE_PATTERNS,
+  buildIgnorePatterns,
+  SAFE_GLOB_OPTIONS,
+  LARGE_FILE_THRESHOLDS,
+  HEALTH_DEDUCTIONS,
+  formatBytes,
+  BundleSizeScanner
+};