roast-my-codebase 1.1.2 → 1.3.0

package/README.md

@@ -114,12 +114,24 @@ npx roast-my-codebase --markdown-file  # Save to .roast-report.md
 ### Fully Supported
 - **JavaScript** (.js, .jsx, .mjs, .cjs)
 - **TypeScript** (.ts, .tsx)
-- **Python** (.py) — Complexity, type hints, imports
+- **Python** (.py) — Complexity, type hints, imports, docstrings, security, class design
 - **Go** (.go) — Complexity, error handling, lint conventions
 - **Rust** (.rs) — Complexity, unsafe usage, clippy hints
 - **Java** (.java) — Complexity, code smells, naming conventions
 - **C#** (.cs) — Complexity, code smells, async patterns
 
+### Framework-Specific Checks
+
+| Framework | What's detected |
+|-----------|----------------|
+| **Next.js** | Missing metadata exports, server/client component misuse |
+| **React** | Missing error boundaries |
+| **Vue 3** | Options API in Vue 3, v-for without :key, deep watchers |
+| **Angular** | Missing OnPush strategy, direct DOM manipulation, untyped events |
+| **Svelte** | Reactive side effects, inaccessible buttons |
+| **Express** | Missing error middleware, no rate limiting, sync I/O in routes |
+| **FastAPI** | Missing response_model, sync endpoints, missing status codes |
+
 ### Language-Specific Checks
 
 | Language | Scanners |
@@ -272,7 +284,12 @@ roast-my-codebase --interactive
 - ✅ Remove unused dependencies (`npm uninstall`)
 - ✅ Add issue references to TODO comments
 - ✅ Remove dead exports
-- 🔜 More fixes coming soon!
+- ✅ Add `'use client'` directive to Next.js components
+- ✅ Add missing metadata export to Next.js pages
+- ✅ Add `.env` files to `.gitignore`
+- ✅ Upgrade `@ts-ignore` to `@ts-expect-error`
+- ✅ Create skeleton test files for untested source files
+- ✅ Add secret files to `.gitignore`
 
 **Example session:**
 ```
@@ -296,7 +313,25 @@ Unused dependency `lodash` is installed but never imported
   Exit interactive mode
 ```
 
-### Watch Mode
+### HTML Report
+```bash
+roast-my-codebase --html-file
+```
+- Saves `.roast-report.html` — a beautiful standalone HTML report
+- Dark theme, SVG health gauge, sortable findings table, severity chart
+- Fully self-contained (no CDN, works offline)
+- Perfect for sharing with the team
+
+# Incremental Scanning
+```bash
+roast-my-codebase --incremental      # Only changed files since last commit
+roast-my-codebase --since main       # Only files changed since branching from main
+```
+- Dramatically faster on large repos — only scans changed files
+- Global findings (circular deps, excessive dependencies) are always shown
+- Falls back to full scan if not in a git repository
+
+# Watch Mode
 ```bash
 roast-my-codebase --watch
 ```

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
+};