backend-diet 1.0.0

package/dist/cli.js

@@ -0,0 +1,2021 @@
+#!/usr/bin/env node
+"use strict";
+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 __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/cli.ts
+var import_commander = require("commander");
+var import_ora = __toESM(require("ora"));
+var import_path6 = __toESM(require("path"));
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/scanner/walker.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_path = __toESM(require("path"));
+var SOURCE_EXTENSIONS = ["js", "ts", "jsx", "tsx", "mjs", "cjs"];
+var DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/coverage/**",
+  "**/*.min.js",
+  "**/*.bundle.js"
+];
+async function walkFiles(targetDir, extraIgnore = []) {
+  const pattern = `**/*.{${SOURCE_EXTENSIONS.join(",")}}`;
+  const ignore = [...DEFAULT_IGNORE, ...extraIgnore];
+  const files = await (0, import_fast_glob.default)(pattern, {
+    cwd: import_path.default.resolve(targetDir),
+    absolute: true,
+    ignore,
+    followSymbolicLinks: false,
+    onlyFiles: true
+  });
+  return files.sort();
+}
+
+// src/scanner/parser.ts
+var babelParser = __toESM(require("@babel/parser"));
+var import_traverse = __toESM(require("@babel/traverse"));
+var t = __toESM(require("@babel/types"));
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var BABEL_PLUGINS = [
+  "typescript",
+  "jsx",
+  ["decorators", { decoratorsBeforeExport: true }],
+  "classProperties",
+  "classPrivateProperties",
+  "classPrivateMethods",
+  "exportDefaultFrom",
+  "exportNamespaceFrom",
+  "dynamicImport",
+  "nullishCoalescingOperator",
+  "optionalChaining",
+  "optionalCatchBinding",
+  "logicalAssignment",
+  "numericSeparator",
+  "bigInt",
+  "importMeta"
+];
+function safeParseCode(code) {
+  try {
+    return babelParser.parse(code, {
+      sourceType: "module",
+      allowImportExportEverywhere: true,
+      allowReturnOutsideFunction: true,
+      allowSuperOutsideMethod: true,
+      plugins: BABEL_PLUGINS,
+      errorRecovery: true
+    });
+  } catch {
+    try {
+      return babelParser.parse(code, {
+        sourceType: "script",
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+        plugins: ["jsx", "classProperties"],
+        errorRecovery: true
+      });
+    } catch {
+      return null;
+    }
+  }
+}
+function normalizePackageName(source) {
+  if (source.startsWith("@")) {
+    const parts = source.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+  return source.split("/")[0];
+}
+function getSubPath(source) {
+  const parts = source.split("/");
+  if (source.startsWith("@") && parts.length > 2) {
+    return parts.slice(2).join("/");
+  }
+  if (!source.startsWith("@") && parts.length > 1) {
+    return parts.slice(1).join("/");
+  }
+  return null;
+}
+function parseFile(filePath) {
+  const records = [];
+  let code;
+  try {
+    code = import_fs.default.readFileSync(filePath, "utf-8");
+  } catch {
+    return records;
+  }
+  const ast = safeParseCode(code);
+  if (!ast) return records;
+  const relPath = import_path2.default.relative(process.cwd(), filePath);
+  (0, import_traverse.default)(ast, {
+    // Pattern 1: import { cloneDeep, merge } from 'lodash'
+    // Pattern 2: import cloneDeep from 'lodash/cloneDeep'
+    ImportDeclaration(nodePath) {
+      const source = nodePath.node.source.value;
+      if (!isThirdParty(source)) return;
+      const packageName = normalizePackageName(source);
+      const subPath = getSubPath(source);
+      const line = nodePath.node.loc?.start.line ?? 0;
+      const col = nodePath.node.loc?.start.column ?? 0;
+      const raw = code.split("\n")[line - 1]?.trim() ?? "";
+      for (const specifier of nodePath.node.specifiers) {
+        let functionName;
+        if (t.isImportSpecifier(specifier)) {
+          functionName = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+        } else if (t.isImportDefaultSpecifier(specifier)) {
+          functionName = subPath ?? specifier.local.name;
+        } else if (t.isImportNamespaceSpecifier(specifier)) {
+          functionName = "*";
+        } else {
+          continue;
+        }
+        records.push({ file: relPath, packageName, functionName, line, col, raw });
+      }
+    },
+    // Pattern 3: const { cloneDeep } = require('lodash')
+    VariableDeclarator(nodePath) {
+      const init = nodePath.node.init;
+      if (!t.isCallExpression(init)) return;
+      if (!t.isIdentifier(init.callee, { name: "require" })) return;
+      if (init.arguments.length === 0) return;
+      const arg = init.arguments[0];
+      if (!t.isStringLiteral(arg)) return;
+      if (!isThirdParty(arg.value)) return;
+      const source = arg.value;
+      const packageName = normalizePackageName(source);
+      const subPath = getSubPath(source);
+      const line = nodePath.node.loc?.start.line ?? 0;
+      const col = nodePath.node.loc?.start.column ?? 0;
+      const raw = code.split("\n")[line - 1]?.trim() ?? "";
+      if (t.isObjectPattern(nodePath.node.id)) {
+        for (const prop of nodePath.node.id.properties) {
+          if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+            records.push({
+              file: relPath,
+              packageName,
+              functionName: prop.key.name,
+              line,
+              col,
+              raw
+            });
+          }
+        }
+      } else if (t.isIdentifier(nodePath.node.id)) {
+        const functionName = subPath ?? "*";
+        records.push({ file: relPath, packageName, functionName, line, col, raw });
+      }
+    },
+    // Pattern 4: _.cloneDeep(obj) — namespace call detection
+    CallExpression(nodePath) {
+      const callee = nodePath.node.callee;
+      if (!t.isMemberExpression(callee)) return;
+      if (!t.isIdentifier(callee.object)) return;
+      if (!t.isIdentifier(callee.property)) return;
+      const nsName = callee.object.name;
+      const methodName = callee.property.name;
+      const line = nodePath.node.loc?.start.line ?? 0;
+      const col = nodePath.node.loc?.start.column ?? 0;
+      const raw = code.split("\n")[line - 1]?.trim() ?? "";
+      records.push({
+        file: relPath,
+        packageName: `__ns__${nsName}`,
+        functionName: methodName,
+        line,
+        col,
+        raw
+      });
+    }
+  });
+  return records;
+}
+function isThirdParty(source) {
+  if (source.startsWith(".")) return false;
+  if (source.startsWith("/")) return false;
+  if (source.startsWith("node:")) return false;
+  const builtins = /* @__PURE__ */ new Set([
+    "fs",
+    "path",
+    "os",
+    "crypto",
+    "http",
+    "https",
+    "url",
+    "util",
+    "stream",
+    "child_process",
+    "cluster",
+    "events",
+    "net",
+    "tls",
+    "dns",
+    "readline",
+    "repl",
+    "vm",
+    "zlib",
+    "buffer",
+    "assert",
+    "perf_hooks",
+    "worker_threads",
+    "module",
+    "process",
+    "v8",
+    "inspector"
+  ]);
+  return !builtins.has(source.split("/")[0]);
+}
+async function parseFiles(files) {
+  const allRecords = [];
+  for (const file of files) {
+    const records = parseFile(file);
+    allRecords.push(...records);
+  }
+  return allRecords;
+}
+
+// src/database/packs/lodash.ts
+var lodash = {
+  packageName: "lodash",
+  description: "A modern JavaScript utility library delivering modularity, performance & extras.",
+  gzippedSize: 24e3,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "cloneDeep",
+      importPaths: ["lodash/cloneDeep"],
+      alternatives: [
+        {
+          api: "structuredClone",
+          minNodeVersion: "17.0.0",
+          bytesSaved: 3200,
+          difficulty: "trivial",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/API/structuredClone",
+          snippet: {
+            before: `import { cloneDeep } from 'lodash';
+const copy = cloneDeep(obj);`,
+            after: `const copy = structuredClone(obj);`
+          }
+        }
+      ]
+    },
+    {
+      name: "merge",
+      importPaths: ["lodash/merge"],
+      alternatives: [
+        {
+          api: "Object.assign / spread",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 900,
+          difficulty: "easy",
+          snippet: {
+            before: `import { merge } from 'lodash';
+const result = merge({}, defaults, overrides);`,
+            after: `const result = { ...defaults, ...overrides };`
+          }
+        }
+      ]
+    },
+    {
+      name: "get",
+      importPaths: ["lodash/get"],
+      alternatives: [
+        {
+          api: "Optional Chaining (?.)",
+          minNodeVersion: "14.0.0",
+          bytesSaved: 700,
+          difficulty: "trivial",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining",
+          snippet: {
+            before: `import { get } from 'lodash';
+const val = get(obj, 'a.b.c', defaultVal);`,
+            after: `const val = obj?.a?.b?.c ?? defaultVal;`
+          }
+        }
+      ]
+    },
+    {
+      name: "flatten",
+      importPaths: ["lodash/flatten"],
+      alternatives: [
+        {
+          api: "Array.prototype.flat",
+          minNodeVersion: "11.0.0",
+          bytesSaved: 400,
+          difficulty: "trivial",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat",
+          snippet: {
+            before: `import { flatten } from 'lodash';
+const flat = flatten(arr);`,
+            after: `const flat = arr.flat();`
+          }
+        }
+      ]
+    },
+    {
+      name: "flattenDeep",
+      importPaths: ["lodash/flattenDeep"],
+      alternatives: [
+        {
+          api: "Array.prototype.flat(Infinity)",
+          minNodeVersion: "11.0.0",
+          bytesSaved: 500,
+          difficulty: "trivial",
+          snippet: {
+            before: `import { flattenDeep } from 'lodash';
+const flat = flattenDeep(arr);`,
+            after: `const flat = arr.flat(Infinity);`
+          }
+        }
+      ]
+    },
+    {
+      name: "uniq",
+      importPaths: ["lodash/uniq"],
+      alternatives: [
+        {
+          api: "Set",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 350,
+          difficulty: "trivial",
+          snippet: {
+            before: `import { uniq } from 'lodash';
+const unique = uniq(arr);`,
+            after: `const unique = [...new Set(arr)];`
+          }
+        }
+      ]
+    },
+    {
+      name: "uniqBy",
+      importPaths: ["lodash/uniqBy"],
+      alternatives: [
+        {
+          api: "Map + Array.from",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 450,
+          difficulty: "easy",
+          snippet: {
+            before: `import { uniqBy } from 'lodash';
+const unique = uniqBy(arr, (x) => x.id);`,
+            after: `const unique = Array.from(new Map(arr.map((x) => [x.id, x])).values());`
+          }
+        }
+      ]
+    },
+    {
+      name: "debounce",
+      importPaths: ["lodash/debounce"],
+      alternatives: [
+        {
+          api: "Custom closure",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 600,
+          difficulty: "easy",
+          snippet: {
+            before: `import { debounce } from 'lodash';
+const handler = debounce(fn, 300);`,
+            after: `function debounce(fn, ms) {
+  let timer;
+  return (...args) => { clearTimeout(timer); timer = setTimeout(() => fn(...args), ms); };
+}
+const handler = debounce(fn, 300);`
+          }
+        }
+      ]
+    },
+    {
+      name: "throttle",
+      importPaths: ["lodash/throttle"],
+      alternatives: [
+        {
+          api: "Custom closure",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 600,
+          difficulty: "easy",
+          snippet: {
+            before: `import { throttle } from 'lodash';
+const handler = throttle(fn, 300);`,
+            after: `function throttle(fn, ms) {
+  let last = 0;
+  return (...args) => { const now = Date.now(); if (now - last >= ms) { last = now; fn(...args); } };
+}
+const handler = throttle(fn, 300);`
+          }
+        }
+      ]
+    },
+    {
+      name: "isEmpty",
+      importPaths: ["lodash/isEmpty"],
+      alternatives: [
+        {
+          api: "Native checks",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "easy",
+          snippet: {
+            before: `import { isEmpty } from 'lodash';
+if (isEmpty(value)) { ... }`,
+            after: `// For arrays:
+if (!arr.length) { ... }
+// For objects:
+if (!Object.keys(obj).length) { ... }
+// For strings:
+if (!str) { ... }`
+          }
+        }
+      ]
+    },
+    {
+      name: "isEqual",
+      importPaths: ["lodash/isEqual"],
+      alternatives: [
+        {
+          api: "JSON.stringify (shallow use case)",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 800,
+          difficulty: "moderate",
+          snippet: {
+            before: `import { isEqual } from 'lodash';
+if (isEqual(a, b)) { ... }`,
+            after: `// For simple serializable objects (no functions/undefined):
+if (JSON.stringify(a) === JSON.stringify(b)) { ... }
+// For deep equality with full support, keep lodash.isEqual.`
+          }
+        }
+      ]
+    },
+    {
+      name: "omit",
+      importPaths: ["lodash/omit"],
+      alternatives: [
+        {
+          api: "Destructuring",
+          minNodeVersion: "6.0.0",
+          bytesSaved: 350,
+          difficulty: "easy",
+          snippet: {
+            before: `import { omit } from 'lodash';
+const clean = omit(obj, ['password', 'token']);`,
+            after: `const { password, token, ...clean } = obj;`
+          }
+        }
+      ]
+    },
+    {
+      name: "pick",
+      importPaths: ["lodash/pick"],
+      alternatives: [
+        {
+          api: "Object.fromEntries",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 350,
+          difficulty: "easy",
+          snippet: {
+            before: `import { pick } from 'lodash';
+const subset = pick(obj, ['name', 'age']);`,
+            after: `const keys = ['name', 'age'];
+const subset = Object.fromEntries(keys.map((k) => [k, obj[k]]));`
+          }
+        }
+      ]
+    },
+    {
+      name: "chunk",
+      importPaths: ["lodash/chunk"],
+      alternatives: [
+        {
+          api: "Array.from + slice",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 400,
+          difficulty: "easy",
+          snippet: {
+            before: `import { chunk } from 'lodash';
+const chunks = chunk(arr, 3);`,
+            after: `const chunk = (arr, size) =>
+  Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
+    arr.slice(i * size, i * size + size)
+  );
+const chunks = chunk(arr, 3);`
+          }
+        }
+      ]
+    },
+    {
+      name: "groupBy",
+      importPaths: ["lodash/groupBy"],
+      alternatives: [
+        {
+          api: "Array.prototype.reduce",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 500,
+          difficulty: "easy",
+          snippet: {
+            before: `import { groupBy } from 'lodash';
+const groups = groupBy(arr, (x) => x.category);`,
+            after: `const groups = arr.reduce((acc, x) => {
+  (acc[x.category] ??= []).push(x);
+  return acc;
+}, {});`
+          }
+        }
+      ]
+    },
+    {
+      name: "sortBy",
+      importPaths: ["lodash/sortBy"],
+      alternatives: [
+        {
+          api: "Array.prototype.sort",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 400,
+          difficulty: "easy",
+          snippet: {
+            before: `import { sortBy } from 'lodash';
+const sorted = sortBy(arr, (x) => x.name);`,
+            after: `const sorted = [...arr].sort((a, b) => a.name.localeCompare(b.name));`
+          }
+        }
+      ]
+    },
+    {
+      name: "mapValues",
+      importPaths: ["lodash/mapValues"],
+      alternatives: [
+        {
+          api: "Object.fromEntries + Object.entries",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 350,
+          difficulty: "easy",
+          snippet: {
+            before: `import { mapValues } from 'lodash';
+const result = mapValues(obj, (v) => v * 2);`,
+            after: `const result = Object.fromEntries(
+  Object.entries(obj).map(([k, v]) => [k, v * 2])
+);`
+          }
+        }
+      ]
+    },
+    {
+      name: "keyBy",
+      importPaths: ["lodash/keyBy"],
+      alternatives: [
+        {
+          api: "Array.prototype.reduce",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 400,
+          difficulty: "easy",
+          snippet: {
+            before: `import { keyBy } from 'lodash';
+const byId = keyBy(users, 'id');`,
+            after: `const byId = users.reduce((acc, u) => ({ ...acc, [u.id]: u }), {});`
+          }
+        }
+      ]
+    },
+    {
+      name: "startCase",
+      importPaths: ["lodash/startCase"],
+      alternatives: [
+        {
+          api: "Regex + replace",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "moderate",
+          snippet: {
+            before: `import { startCase } from 'lodash';
+const title = startCase('helloWorld');`,
+            after: `const startCase = (s) =>
+  s.replace(/([A-Z])/g, ' $1')
+   .replace(/[-_]/g, ' ')
+   .replace(/\\b\\w/g, (c) => c.toUpperCase())
+   .trim();
+const title = startCase('helloWorld');`
+          }
+        }
+      ]
+    },
+    {
+      name: "camelCase",
+      importPaths: ["lodash/camelCase"],
+      alternatives: [
+        {
+          api: "Regex + replace",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "moderate",
+          snippet: {
+            before: `import { camelCase } from 'lodash';
+const name = camelCase('hello-world');`,
+            after: `const camelCase = (s) =>
+  s.toLowerCase().replace(/[-_\\s]+(\\w)/g, (_, c) => c.toUpperCase());
+const name = camelCase('hello-world');`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/packs/moment.ts
+var moment = {
+  packageName: "moment",
+  description: "Parse, validate, manipulate, and display dates in JavaScript.",
+  gzippedSize: 72e3,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "default",
+      alternatives: [
+        {
+          api: "Intl.DateTimeFormat / Date",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 72e3,
+          difficulty: "moderate",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat",
+          snippet: {
+            before: `import moment from 'moment';
+const formatted = moment().format('YYYY-MM-DD');`,
+            after: `const formatted = new Date().toISOString().slice(0, 10);
+// Or with Intl:
+const formatted = new Intl.DateTimeFormat('en-CA').format(new Date());`
+          }
+        }
+      ]
+    },
+    {
+      name: "format",
+      alternatives: [
+        {
+          api: "Intl.DateTimeFormat",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 72e3,
+          difficulty: "moderate",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat",
+          snippet: {
+            before: `moment(date).format('MMM D, YYYY')`,
+            after: `new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric', year: 'numeric' }).format(date)`
+          }
+        }
+      ]
+    },
+    {
+      name: "diff",
+      alternatives: [
+        {
+          api: "Date arithmetic",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 5e3,
+          difficulty: "easy",
+          snippet: {
+            before: `moment(end).diff(moment(start), 'days')`,
+            after: `Math.round((new Date(end) - new Date(start)) / (1000 * 60 * 60 * 24))`
+          }
+        }
+      ]
+    },
+    {
+      name: "add",
+      alternatives: [
+        {
+          api: "Date manipulation",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 3e3,
+          difficulty: "easy",
+          snippet: {
+            before: `moment().add(7, 'days').toDate()`,
+            after: `const d = new Date();
+d.setDate(d.getDate() + 7);`
+          }
+        }
+      ]
+    },
+    {
+      name: "fromNow",
+      alternatives: [
+        {
+          api: "Intl.RelativeTimeFormat",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 5e3,
+          difficulty: "moderate",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat",
+          snippet: {
+            before: `moment(date).fromNow()`,
+            after: `const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+const diffMs = date - Date.now();
+const diffDays = Math.round(diffMs / 86_400_000);
+rtf.format(diffDays, 'day');`
+          }
+        }
+      ]
+    },
+    {
+      name: "isBefore",
+      alternatives: [
+        {
+          api: "Date comparison",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 1e3,
+          difficulty: "trivial",
+          snippet: {
+            before: `moment(a).isBefore(moment(b))`,
+            after: `new Date(a) < new Date(b)`
+          }
+        }
+      ]
+    },
+    {
+      name: "isAfter",
+      alternatives: [
+        {
+          api: "Date comparison",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 1e3,
+          difficulty: "trivial",
+          snippet: {
+            before: `moment(a).isAfter(moment(b))`,
+            after: `new Date(a) > new Date(b)`
+          }
+        }
+      ]
+    },
+    {
+      name: "unix",
+      alternatives: [
+        {
+          api: "Date.now() / 1000",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 500,
+          difficulty: "trivial",
+          snippet: {
+            before: `moment().unix()`,
+            after: `Math.floor(Date.now() / 1000)`
+          }
+        }
+      ]
+    },
+    {
+      name: "utc",
+      alternatives: [
+        {
+          api: "toUTCString / toISOString",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 1e3,
+          difficulty: "easy",
+          snippet: {
+            before: `moment.utc(date).format()`,
+            after: `new Date(date).toISOString()`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/packs/axios.ts
+var axios = {
+  packageName: "axios",
+  description: "Promise based HTTP client for the browser and Node.js.",
+  gzippedSize: 14e3,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "default",
+      alternatives: [
+        {
+          api: "fetch",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "easy",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API",
+          snippet: {
+            before: `import axios from 'axios';
+const { data } = await axios.get('/api/users');`,
+            after: `const data = await fetch('/api/users').then((r) => r.json());`
+          }
+        }
+      ]
+    },
+    {
+      name: "get",
+      alternatives: [
+        {
+          api: "fetch",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "easy",
+          snippet: {
+            before: `import axios from 'axios';
+const { data } = await axios.get(url, { params: { id: 1 } });`,
+            after: `const url = new URL('/api/users', baseUrl);
+url.searchParams.set('id', '1');
+const data = await fetch(url).then((r) => r.json());`
+          }
+        }
+      ]
+    },
+    {
+      name: "post",
+      alternatives: [
+        {
+          api: "fetch (POST)",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "easy",
+          snippet: {
+            before: `import axios from 'axios';
+await axios.post('/api/users', { name: 'Alice' });`,
+            after: `await fetch('/api/users', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ name: 'Alice' }),
+});`
+          }
+        }
+      ]
+    },
+    {
+      name: "put",
+      alternatives: [
+        {
+          api: "fetch (PUT)",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "easy",
+          snippet: {
+            before: `await axios.put('/api/users/1', payload);`,
+            after: `await fetch('/api/users/1', {
+  method: 'PUT',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify(payload),
+});`
+          }
+        }
+      ]
+    },
+    {
+      name: "delete",
+      alternatives: [
+        {
+          api: "fetch (DELETE)",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "easy",
+          snippet: {
+            before: `await axios.delete('/api/users/1');`,
+            after: `await fetch('/api/users/1', { method: 'DELETE' });`
+          }
+        }
+      ]
+    },
+    {
+      name: "create",
+      alternatives: [
+        {
+          api: "fetch wrapper",
+          minNodeVersion: "18.0.0",
+          bytesSaved: 14e3,
+          difficulty: "moderate",
+          snippet: {
+            before: `const api = axios.create({ baseURL: 'https://api.example.com', timeout: 5000 });`,
+            after: `const apiFetch = (path, init = {}) =>
+  fetch(\`https://api.example.com\${path}\`, {
+    signal: AbortSignal.timeout(5000),
+    ...init,
+  }).then((r) => { if (!r.ok) throw new Error(r.statusText); return r.json(); });`
+          }
+        }
+      ]
+    },
+    {
+      name: "all",
+      alternatives: [
+        {
+          api: "Promise.all",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 500,
+          difficulty: "trivial",
+          snippet: {
+            before: `await axios.all([axios.get('/a'), axios.get('/b')]);`,
+            after: `await Promise.all([fetch('/a').then(r => r.json()), fetch('/b').then(r => r.json())]);`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/packs/uuid.ts
+var uuid = {
+  packageName: "uuid",
+  description: "RFC4122 UUIDs generator.",
+  gzippedSize: 3700,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "v4",
+      importPaths: ["uuid/v4"],
+      alternatives: [
+        {
+          api: "crypto.randomUUID",
+          minNodeVersion: "14.17.0",
+          bytesSaved: 3700,
+          difficulty: "trivial",
+          docsUrl: "https://nodejs.org/api/crypto.html#cryptorandomuuidoptions",
+          snippet: {
+            before: `import { v4 as uuidv4 } from 'uuid';
+const id = uuidv4();`,
+            after: `const id = crypto.randomUUID();`
+          }
+        }
+      ]
+    },
+    {
+      name: "v1",
+      importPaths: ["uuid/v1"],
+      alternatives: [
+        {
+          api: "crypto.randomUUID (v4 alternative)",
+          minNodeVersion: "14.17.0",
+          bytesSaved: 3700,
+          difficulty: "easy",
+          snippet: {
+            before: `import { v1 as uuidv1 } from 'uuid';
+const id = uuidv1();`,
+            after: `// v1 (timestamp-based) has no direct native equivalent.
+// If timestamp ordering isn't required, use:
+const id = crypto.randomUUID();`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/packs/bluebird.ts
+var bluebird = {
+  packageName: "bluebird",
+  description: "A full featured promise library with unmatched performance.",
+  gzippedSize: 17e3,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "default",
+      alternatives: [
+        {
+          api: "Native Promise",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 17e3,
+          difficulty: "moderate",
+          docsUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise",
+          snippet: {
+            before: `const Promise = require('bluebird');
+const result = new Promise((resolve) => resolve(42));`,
+            after: `const result = Promise.resolve(42);`
+          }
+        }
+      ]
+    },
+    {
+      name: "all",
+      alternatives: [
+        {
+          api: "Promise.all",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 2e3,
+          difficulty: "trivial",
+          snippet: {
+            before: `Promise.all([p1, p2, p3])`,
+            after: `Promise.all([p1, p2, p3])  // Native \u2014 same API!`
+          }
+        }
+      ]
+    },
+    {
+      name: "map",
+      alternatives: [
+        {
+          api: "Promise.all + Array.map",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 1500,
+          difficulty: "easy",
+          snippet: {
+            before: `import Promise from 'bluebird';
+await Promise.map(ids, fetchUser, { concurrency: 3 });`,
+            after: `// Simple version (no concurrency limit):
+await Promise.all(ids.map(fetchUser));
+
+// With concurrency control (p-limit):
+import pLimit from 'p-limit';
+const limit = pLimit(3);
+await Promise.all(ids.map((id) => limit(() => fetchUser(id))));`
+          }
+        }
+      ]
+    },
+    {
+      name: "mapSeries",
+      alternatives: [
+        {
+          api: "for...of + await",
+          minNodeVersion: "10.0.0",
+          bytesSaved: 1200,
+          difficulty: "easy",
+          snippet: {
+            before: `await Promise.mapSeries(items, processItem);`,
+            after: `const results = [];
+for (const item of items) {
+  results.push(await processItem(item));
+}`
+          }
+        }
+      ]
+    },
+    {
+      name: "filter",
+      alternatives: [
+        {
+          api: "Promise.all + Array.filter",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 1e3,
+          difficulty: "easy",
+          snippet: {
+            before: `await Promise.filter(items, asyncPredicate);`,
+            after: `const flags = await Promise.all(items.map(asyncPredicate));
+const result = items.filter((_, i) => flags[i]);`
+          }
+        }
+      ]
+    },
+    {
+      name: "props",
+      alternatives: [
+        {
+          api: "Promise.all + Object.fromEntries",
+          minNodeVersion: "12.0.0",
+          bytesSaved: 1e3,
+          difficulty: "easy",
+          snippet: {
+            before: `await Promise.props({ user: fetchUser(), posts: fetchPosts() });`,
+            after: `const [user, posts] = await Promise.all([fetchUser(), fetchPosts()]);
+const result = { user, posts };`
+          }
+        }
+      ]
+    },
+    {
+      name: "each",
+      alternatives: [
+        {
+          api: "for...of + await",
+          minNodeVersion: "10.0.0",
+          bytesSaved: 800,
+          difficulty: "easy",
+          snippet: {
+            before: `await Promise.each(items, async (item) => { await process(item); });`,
+            after: `for (const item of items) { await process(item); }`
+          }
+        }
+      ]
+    },
+    {
+      name: "any",
+      alternatives: [
+        {
+          api: "Promise.any",
+          minNodeVersion: "15.0.0",
+          bytesSaved: 500,
+          difficulty: "trivial",
+          snippet: {
+            before: `await Promise.any([p1, p2, p3]);`,
+            after: `await Promise.any([p1, p2, p3]);  // Native \u2014 same API!`
+          }
+        }
+      ]
+    },
+    {
+      name: "reflect",
+      alternatives: [
+        {
+          api: "Promise.allSettled",
+          minNodeVersion: "12.9.0",
+          bytesSaved: 800,
+          difficulty: "easy",
+          snippet: {
+            before: `const results = await Promise.all(promises.map((p) => p.reflect()));
+results.filter((r) => r.isFulfilled());`,
+            after: `const results = await Promise.allSettled(promises);
+results.filter((r) => r.status === 'fulfilled');`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/packs/underscore.ts
+var underscore = {
+  packageName: "underscore",
+  description: "A JavaScript utility library providing lots of useful functional programming helpers.",
+  gzippedSize: 6800,
+  canFullyReplace: true,
+  functions: [
+    {
+      name: "each",
+      alternatives: [
+        {
+          api: "Array.prototype.forEach",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 400,
+          difficulty: "trivial",
+          snippet: {
+            before: `import _ from 'underscore';
+_.each(arr, (item) => console.log(item));`,
+            after: `arr.forEach((item) => console.log(item));`
+          }
+        }
+      ]
+    },
+    {
+      name: "map",
+      alternatives: [
+        {
+          api: "Array.prototype.map",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 400,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.map(arr, (x) => x * 2)`,
+            after: `arr.map((x) => x * 2)`
+          }
+        }
+      ]
+    },
+    {
+      name: "filter",
+      alternatives: [
+        {
+          api: "Array.prototype.filter",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.filter(arr, (x) => x > 0)`,
+            after: `arr.filter((x) => x > 0)`
+          }
+        }
+      ]
+    },
+    {
+      name: "reduce",
+      alternatives: [
+        {
+          api: "Array.prototype.reduce",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.reduce(arr, (acc, x) => acc + x, 0)`,
+            after: `arr.reduce((acc, x) => acc + x, 0)`
+          }
+        }
+      ]
+    },
+    {
+      name: "find",
+      alternatives: [
+        {
+          api: "Array.prototype.find",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 300,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.find(arr, (x) => x.id === id)`,
+            after: `arr.find((x) => x.id === id)`
+          }
+        }
+      ]
+    },
+    {
+      name: "contains",
+      alternatives: [
+        {
+          api: "Array.prototype.includes",
+          minNodeVersion: "6.0.0",
+          bytesSaved: 200,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.contains(arr, value)`,
+            after: `arr.includes(value)`
+          }
+        }
+      ]
+    },
+    {
+      name: "keys",
+      alternatives: [
+        {
+          api: "Object.keys",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 200,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.keys(obj)`,
+            after: `Object.keys(obj)`
+          }
+        }
+      ]
+    },
+    {
+      name: "values",
+      alternatives: [
+        {
+          api: "Object.values",
+          minNodeVersion: "7.0.0",
+          bytesSaved: 200,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.values(obj)`,
+            after: `Object.values(obj)`
+          }
+        }
+      ]
+    },
+    {
+      name: "extend",
+      alternatives: [
+        {
+          api: "Object.assign",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 200,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.extend(target, source)`,
+            after: `Object.assign(target, source)`
+          }
+        }
+      ]
+    },
+    {
+      name: "clone",
+      alternatives: [
+        {
+          api: "structuredClone / spread",
+          minNodeVersion: "17.0.0",
+          bytesSaved: 300,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.clone(obj)`,
+            after: `structuredClone(obj)  // deep clone
+// or { ...obj } for shallow`
+          }
+        }
+      ]
+    },
+    {
+      name: "flatten",
+      alternatives: [
+        {
+          api: "Array.prototype.flat",
+          minNodeVersion: "11.0.0",
+          bytesSaved: 300,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.flatten(arr)`,
+            after: `arr.flat()`
+          }
+        }
+      ]
+    },
+    {
+      name: "uniq",
+      alternatives: [
+        {
+          api: "Set",
+          minNodeVersion: "4.0.0",
+          bytesSaved: 250,
+          difficulty: "trivial",
+          snippet: {
+            before: `_.uniq(arr)`,
+            after: `[...new Set(arr)]`
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/database/index.ts
+var ALL_PACKAGES = [lodash, moment, axios, uuid, bluebird, underscore];
+var packageRegistry = /* @__PURE__ */ new Map();
+var functionRegistry = /* @__PURE__ */ new Map();
+var subPathRegistry = /* @__PURE__ */ new Map();
+for (const pkg of ALL_PACKAGES) {
+  packageRegistry.set(pkg.packageName, pkg);
+  const fnMap = /* @__PURE__ */ new Map();
+  for (const fn of pkg.functions) {
+    fnMap.set(fn.name, fn);
+    if (fn.importPaths) {
+      for (const subPath of fn.importPaths) {
+        subPathRegistry.set(subPath, { packageName: pkg.packageName, functionName: fn.name });
+      }
+    }
+  }
+  functionRegistry.set(pkg.packageName, fnMap);
+}
+function lookupPackage(packageName) {
+  return packageRegistry.get(packageName);
+}
+function lookupFunction(packageName, functionName) {
+  return functionRegistry.get(packageName)?.get(functionName);
+}
+function lookupSubPath(subPath) {
+  return subPathRegistry.get(subPath);
+}
+function getAllPackages() {
+  return ALL_PACKAGES;
+}
+function matchImports(imports) {
+  const matches = [];
+  const namespaceToPackage = /* @__PURE__ */ new Map();
+  for (const rec of imports) {
+    if (rec.functionName === "*" && !rec.packageName.startsWith("__ns__")) {
+      namespaceToPackage.set(rec.packageName, rec.packageName);
+    }
+  }
+  const fileNsMap = /* @__PURE__ */ new Map();
+  for (const rec of imports) {
+    if (rec.functionName === "*" && !rec.packageName.startsWith("__ns__")) {
+      const commonNs = rec.packageName === "lodash" || rec.packageName === "underscore" ? "_" : rec.packageName;
+      if (!fileNsMap.has(rec.file)) fileNsMap.set(rec.file, /* @__PURE__ */ new Map());
+      fileNsMap.get(rec.file).set(commonNs, rec.packageName);
+    }
+  }
+  for (const rec of imports) {
+    if (rec.functionName === "*") continue;
+    let packageName = rec.packageName;
+    let functionName = rec.functionName;
+    if (packageName.startsWith("__ns__")) {
+      const nsId = packageName.replace("__ns__", "");
+      const filePkg = fileNsMap.get(rec.file)?.get(nsId);
+      if (!filePkg) continue;
+      packageName = filePkg;
+    }
+    let pkgEntry = lookupPackage(packageName);
+    let fnEntry = pkgEntry ? lookupFunction(packageName, functionName) : void 0;
+    if (!fnEntry) {
+      const subPathKey = `${packageName}/${functionName}`;
+      const resolved = lookupSubPath(subPathKey);
+      if (resolved) {
+        pkgEntry = lookupPackage(resolved.packageName);
+        fnEntry = pkgEntry ? lookupFunction(resolved.packageName, resolved.functionName) : void 0;
+        if (pkgEntry) packageName = resolved.packageName;
+        if (fnEntry) functionName = resolved.functionName;
+      }
+    }
+    if (!fnEntry && pkgEntry) {
+      fnEntry = lookupFunction(packageName, "default");
+    }
+    if (!pkgEntry || !fnEntry) continue;
+    matches.push({
+      importRecord: { ...rec, packageName, functionName },
+      packageEntry: pkgEntry,
+      functionEntry: fnEntry
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return matches.filter((m) => {
+    const key = `${m.importRecord.file}::${m.importRecord.packageName}::${m.importRecord.functionName}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/scorer.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+function loadPackageJson(targetDir) {
+  const pkgPath = import_path3.default.join(targetDir, "package.json");
+  try {
+    const raw = import_fs2.default.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getTotalDepsSize(targetDir) {
+  const pkg = loadPackageJson(targetDir);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const allPkgs = getAllPackages();
+  const knownSizes = new Map(allPkgs.map((p) => [p.packageName, p.gzippedSize]));
+  let total = 0;
+  for (const depName of Object.keys(allDeps)) {
+    const size = knownSizes.get(depName);
+    if (size) total += size;
+  }
+  if (total === 0) {
+    total = allPkgs.reduce((sum, p) => sum + p.gzippedSize, 0);
+  }
+  return total;
+}
+function getScoreGrade(score) {
+  if (score >= 90) return "SVELTE";
+  if (score >= 70) return "HEALTHY";
+  if (score >= 40) return "NEEDS WORK";
+  return "CRITICAL";
+}
+function computeScore(totalBytesSaved, totalDepsSize) {
+  if (totalDepsSize === 0) return 100;
+  const wasteRatio = Math.min(totalBytesSaved / totalDepsSize, 1);
+  return Math.max(0, Math.round(100 - wasteRatio * 100));
+}
+function buildScanResult(targetDir, filesScanned, imports, matches, scanDurationMs) {
+  const totalBytesSaved = matches.reduce((sum, m) => {
+    const maxSaving = Math.max(...m.functionEntry.alternatives.map((a) => a.bytesSaved));
+    return sum + maxSaving;
+  }, 0);
+  const totalDepsSize = getTotalDepsSize(targetDir);
+  const refactorScore = computeScore(totalBytesSaved, totalDepsSize);
+  const grade = getScoreGrade(refactorScore);
+  return {
+    targetDir,
+    filesScanned,
+    imports,
+    matches,
+    totalBytesSaved,
+    totalDepsSize,
+    refactorScore,
+    grade,
+    scanDurationMs
+  };
+}
+function formatBytes(bytes) {
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+// src/reporter/terminal.ts
+var import_chalk = __toESM(require("chalk"));
+var import_boxen = __toESM(require("boxen"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var BRAND = (0, import_gradient_string.default)(["#FF6B6B", "#FFD93D", "#6BCB77", "#4D96FF"]);
+var gradeColor = {
+  CRITICAL: import_chalk.default.red.bold,
+  "NEEDS WORK": import_chalk.default.yellow.bold,
+  HEALTHY: import_chalk.default.green.bold,
+  SVELTE: import_chalk.default.cyan.bold
+};
+var gradeIcon = {
+  CRITICAL: "\u{1F480}",
+  "NEEDS WORK": "\u26A0\uFE0F ",
+  HEALTHY: "\u2705",
+  SVELTE: "\u{1F957}"
+};
+var difficultyColor = {
+  trivial: import_chalk.default.green,
+  easy: import_chalk.default.cyan,
+  moderate: import_chalk.default.yellow,
+  hard: import_chalk.default.red
+};
+var difficultyLabel = {
+  trivial: "TRIVIAL",
+  easy: "EASY",
+  moderate: "MODERATE",
+  hard: "HARD"
+};
+function scoreBar(score) {
+  const filled = Math.round(score / 5);
+  const empty = 20 - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  if (score >= 90) return import_chalk.default.cyan(bar);
+  if (score >= 70) return import_chalk.default.green(bar);
+  if (score >= 40) return import_chalk.default.yellow(bar);
+  return import_chalk.default.red(bar);
+}
+function sparkline(values) {
+  const BLOCKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  return values.map((v) => {
+    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
+    return BLOCKS[idx];
+  }).join("");
+}
+function formatDiff(before, after) {
+  const beforeLines = before.split("\n").map((l) => import_chalk.default.red(`- ${l}`));
+  const afterLines = after.split("\n").map((l) => import_chalk.default.green(`+ ${l}`));
+  return [...beforeLines, ...afterLines].join("\n");
+}
+function wrapSnippet(alternative) {
+  return [
+    import_chalk.default.dim("  \u250C\u2500\u2500 Before \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    ...alternative.snippet.before.split("\n").map((l) => import_chalk.default.red(`  \u2502  ${l}`)),
+    import_chalk.default.dim("  \u251C\u2500\u2500 After \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    ...alternative.snippet.after.split("\n").map((l) => import_chalk.default.green(`  \u2502  ${l}`)),
+    import_chalk.default.dim("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
+  ].join("\n");
+}
+function printHeader() {
+  const title = BRAND(
+    "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557       \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\n  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D       \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\n  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551   \n  \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551   \n  \u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D      \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   \n  \u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D       \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   "
+  );
+  console.log(
+    (0, import_boxen.default)(title, {
+      padding: 1,
+      borderStyle: "round",
+      borderColor: "magenta"
+    })
+  );
+  console.log(
+    import_chalk.default.dim("  Put your project on a diet. Find heavy packages, go native.\n")
+  );
+}
+function printScoreCard(result) {
+  const { refactorScore, grade, totalBytesSaved, filesScanned, matches, scanDurationMs } = result;
+  const uniquePackages = new Set(matches.map((m) => m.packageEntry.packageName));
+  const colorFn = gradeColor[grade];
+  const icon = gradeIcon[grade];
+  const content = [
+    "",
+    `  ${BRAND("REFACTOR SCORE")}`,
+    "",
+    `  ${scoreBar(refactorScore)}  ${colorFn(`${refactorScore}/100`)}`,
+    "",
+    `  Grade: ${colorFn(`${icon} ${grade}`)}`,
+    "",
+    `  ${import_chalk.default.dim("\u2500".repeat(44))}`,
+    "",
+    `  ${import_chalk.default.white("Potential savings:")}   ${import_chalk.default.yellow.bold(formatBytes(totalBytesSaved))}`,
+    `  ${import_chalk.default.white("Packages to replace:")} ${import_chalk.default.yellow.bold(String(uniquePackages.size))}`,
+    `  ${import_chalk.default.white("Usage sites found:")}   ${import_chalk.default.yellow.bold(String(matches.length))}`,
+    `  ${import_chalk.default.white("Files scanned:")}       ${import_chalk.default.dim(String(filesScanned))}`,
+    `  ${import_chalk.default.white("Scan duration:")}       ${import_chalk.default.dim(`${scanDurationMs}ms`)}`,
+    ""
+  ].join("\n");
+  console.log(
+    (0, import_boxen.default)(content, {
+      borderStyle: "double",
+      borderColor: grade === "CRITICAL" ? "red" : grade === "SVELTE" ? "cyan" : "yellow",
+      padding: 0
+    })
+  );
+}
+function printMatchesTable(matches) {
+  if (matches.length === 0) {
+    console.log(import_chalk.default.green("\n  \u2713 No heavy library usage found. Your project is already lean!\n"));
+    return;
+  }
+  console.log(import_chalk.default.bold.white("\n  DETECTED USAGE\n"));
+  const table = new import_cli_table3.default({
+    head: [
+      import_chalk.default.bold.cyan("Package"),
+      import_chalk.default.bold.cyan("Function"),
+      import_chalk.default.bold.cyan("File"),
+      import_chalk.default.bold.cyan("Line"),
+      import_chalk.default.bold.cyan("Savings"),
+      import_chalk.default.bold.cyan("Effort")
+    ],
+    style: { head: [], border: ["dim"] },
+    colWidths: [16, 16, 36, 6, 12, 12],
+    wordWrap: true
+  });
+  for (const match of matches) {
+    const best = match.functionEntry.alternatives[0];
+    if (!best) continue;
+    const diffColor = difficultyColor[best.difficulty];
+    const shortFile = match.importRecord.file.length > 34 ? "\u2026" + match.importRecord.file.slice(-33) : match.importRecord.file;
+    table.push([
+      import_chalk.default.magenta(match.packageEntry.packageName),
+      import_chalk.default.white(match.importRecord.functionName),
+      import_chalk.default.dim(shortFile),
+      import_chalk.default.dim(String(match.importRecord.line)),
+      import_chalk.default.yellow(formatBytes(best.bytesSaved)),
+      diffColor(difficultyLabel[best.difficulty])
+    ]);
+  }
+  console.log(table.toString());
+}
+function printSuggestions(matches) {
+  if (matches.length === 0) return;
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    const key = m.packageEntry.packageName;
+    if (!byPackage.has(key)) byPackage.set(key, []);
+    byPackage.get(key).push(m);
+  }
+  console.log(import_chalk.default.bold.white("\n  NATIVE ALTERNATIVES\n"));
+  for (const [packageName, pkgMatches] of byPackage) {
+    const totalSavings = pkgMatches.reduce((sum, m) => {
+      const best = m.functionEntry.alternatives[0];
+      return sum + (best?.bytesSaved ?? 0);
+    }, 0);
+    console.log(
+      (0, import_boxen.default)(
+        `  ${import_chalk.default.bold.magenta(packageName)}   ${import_chalk.default.dim(`\u2192 could save ${formatBytes(totalSavings)}`)}`,
+        { padding: 0, borderStyle: "single", borderColor: "magenta" }
+      )
+    );
+    console.log();
+    const seenFunctions = /* @__PURE__ */ new Set();
+    for (const match of pkgMatches) {
+      const fnName = match.functionEntry.name;
+      if (seenFunctions.has(fnName)) continue;
+      seenFunctions.add(fnName);
+      const alt = match.functionEntry.alternatives[0];
+      if (!alt) continue;
+      const diffColor = difficultyColor[alt.difficulty];
+      console.log(
+        `  ${import_chalk.default.bold.white(fnName)}  ${import_chalk.default.dim("\u2192")}  ${import_chalk.default.cyan(alt.api)}  ${import_chalk.default.dim("|")}  Node \u2265 ${import_chalk.default.dim(alt.minNodeVersion)}  ${import_chalk.default.dim("|")}  ${diffColor(difficultyLabel[alt.difficulty])}` + (alt.docsUrl ? `
+  ${import_chalk.default.dim.underline(alt.docsUrl)}` : "")
+      );
+      console.log();
+      console.log(wrapSnippet(alt));
+      console.log();
+    }
+  }
+}
+function printTimeMachine(history, currentScore) {
+  if (history.length === 0) {
+    console.log(import_chalk.default.dim("\n  No history yet \u2014 run again to build a trend.\n"));
+    return;
+  }
+  const scores = [...history.map((h) => h.score), currentScore];
+  const spark = sparkline(scores);
+  const trend = scores[scores.length - 1] - scores[0];
+  const trendStr = trend > 0 ? import_chalk.default.green(`\u25B2 +${trend} (leaner!)`) : trend < 0 ? import_chalk.default.red(`\u25BC ${trend} (getting fatter!)`) : import_chalk.default.dim("\u2501 no change");
+  console.log(import_chalk.default.bold.white("\n  TIME MACHINE\n"));
+  console.log(`  Score trend: ${import_chalk.default.cyan(spark)}  ${trendStr}`);
+  console.log();
+  const table = new import_cli_table3.default({
+    head: [import_chalk.default.bold.cyan("Date"), import_chalk.default.bold.cyan("Ref"), import_chalk.default.bold.cyan("Score"), import_chalk.default.bold.cyan("Grade")],
+    style: { head: [], border: ["dim"] }
+  });
+  for (const entry of history.slice(-8)) {
+    const color = gradeColor[entry.grade] ?? import_chalk.default.white;
+    table.push([
+      import_chalk.default.dim(new Date(entry.timestamp).toLocaleDateString()),
+      import_chalk.default.dim(entry.gitRef ?? "\u2014"),
+      color(String(entry.score)),
+      color(entry.grade)
+    ]);
+  }
+  console.log(table.toString());
+  console.log();
+}
+function printFooter(_result, fixMode) {
+  const lines = [];
+  if (fixMode) {
+    lines.push(import_chalk.default.green("  \u2726 Run with --fix --yes to auto-apply trivial patches."));
+  }
+  lines.push(
+    import_chalk.default.dim("  \u2726 Add to CI:  ") + import_chalk.default.white("npx backend-diet scan --format json")
+  );
+  lines.push(
+    import_chalk.default.dim("  \u2726 Get badge:  ") + import_chalk.default.white("npx backend-diet scan --badge")
+  );
+  lines.push(
+    import_chalk.default.dim("  \u2726 Track trend:") + import_chalk.default.white(" npx backend-diet scan --since HEAD~10")
+  );
+  lines.push("");
+  lines.push(
+    import_chalk.default.dim("  Built by ") + import_chalk.default.white("Marwan Said") + import_chalk.default.dim(" \xB7 github.com/1iPluto/backend-diet")
+  );
+  console.log(
+    (0, import_boxen.default)(lines.join("\n"), {
+      borderStyle: "round",
+      borderColor: "dim",
+      padding: 0,
+      margin: { top: 1, bottom: 0, left: 0, right: 0 }
+    })
+  );
+}
+function printError(msg) {
+  console.error(import_chalk.default.red(`
+  \u2717 ${msg}
+`));
+}
+function printInfo(msg) {
+  console.log(import_chalk.default.dim(`  \u2139  ${msg}`));
+}
+function printPatchPreview(file, before, after) {
+  console.log(import_chalk.default.bold.white(`
+  \u{1F4C4} ${file}
+`));
+  console.log(formatDiff(before, after));
+  console.log();
+}
+
+// src/reporter/json.ts
+function formatBytes2(bytes) {
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+function buildJsonReport(result) {
+  const uniquePackages = [...new Set(result.matches.map((m) => m.packageEntry.packageName))];
+  return {
+    version: "1.0.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    targetDir: result.targetDir,
+    summary: {
+      filesScanned: result.filesScanned,
+      matchesFound: result.matches.length,
+      uniquePackages,
+      totalBytesSaved: result.totalBytesSaved,
+      totalBytesSavedFormatted: formatBytes2(result.totalBytesSaved),
+      refactorScore: result.refactorScore,
+      grade: result.grade,
+      scanDurationMs: result.scanDurationMs
+    },
+    matches: result.matches.map((m) => ({
+      file: m.importRecord.file,
+      line: m.importRecord.line,
+      packageName: m.importRecord.packageName,
+      functionName: m.importRecord.functionName,
+      raw: m.importRecord.raw,
+      alternatives: m.functionEntry.alternatives.map((a) => ({
+        api: a.api,
+        minNodeVersion: a.minNodeVersion,
+        bytesSaved: a.bytesSaved,
+        difficulty: a.difficulty,
+        snippet: a.snippet,
+        ...a.docsUrl ? { docsUrl: a.docsUrl } : {}
+      }))
+    }))
+  };
+}
+function printJsonReport(result) {
+  const report = buildJsonReport(result);
+  console.log(JSON.stringify(report, null, 2));
+}
+
+// src/patcher.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+function computePatches(matches, targetDir) {
+  const results = [];
+  const trivial = matches.filter(
+    (m) => m.functionEntry.alternatives.some((a) => a.difficulty === "trivial")
+  );
+  const byFile = /* @__PURE__ */ new Map();
+  for (const m of trivial) {
+    const absFile = import_path4.default.resolve(targetDir, m.importRecord.file);
+    if (!byFile.has(absFile)) byFile.set(absFile, []);
+    byFile.get(absFile).push(m);
+  }
+  for (const [absFile, fileMatches] of byFile) {
+    let source;
+    try {
+      source = import_fs3.default.readFileSync(absFile, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = source.split("\n");
+    for (const match of fileMatches) {
+      const alt = match.functionEntry.alternatives.find((a) => a.difficulty === "trivial");
+      if (!alt) continue;
+      const lineIdx = match.importRecord.line - 1;
+      const originalLine = lines[lineIdx];
+      if (originalLine === void 0) continue;
+      results.push({
+        file: match.importRecord.file,
+        originalLine: match.importRecord.line,
+        before: originalLine,
+        after: alt.snippet.after,
+        applied: false
+      });
+    }
+  }
+  return results;
+}
+function applyPatches(patches, targetDir) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const p of patches) {
+    const absFile = import_path4.default.resolve(targetDir, p.file);
+    if (!byFile.has(absFile)) byFile.set(absFile, []);
+    byFile.get(absFile).push(p);
+  }
+  const applied = [];
+  for (const [absFile, filePatches] of byFile) {
+    let source;
+    try {
+      source = import_fs3.default.readFileSync(absFile, "utf-8");
+    } catch {
+      continue;
+    }
+    let modified = source;
+    for (const patch of filePatches) {
+      if (modified.includes(patch.before)) {
+        modified = modified.replace(patch.before, patch.after);
+        applied.push({ ...patch, applied: true });
+      }
+    }
+    try {
+      import_fs3.default.writeFileSync(absFile, modified, "utf-8");
+    } catch {
+    }
+  }
+  return applied;
+}
+
+// src/badger.ts
+var BADGE_COLORS = {
+  CRITICAL: "red",
+  "NEEDS WORK": "yellow",
+  HEALTHY: "green",
+  SVELTE: "brightgreen"
+};
+function generateBadge(score, grade) {
+  const color = BADGE_COLORS[grade];
+  const label = encodeURIComponent("backend-diet");
+  const message = encodeURIComponent(`${score}% lean`);
+  const badgeUrl = `https://img.shields.io/badge/${label}-${message}-${color}?style=flat-square&logo=npm`;
+  return `[![backend-diet score](${badgeUrl})](https://github.com/1iPluto/backend-diet)`;
+}
+function printBadge(score, grade) {
+  const badge = generateBadge(score, grade);
+  console.log("\n  Paste this into your README.md:\n");
+  console.log(`  ${badge}`);
+  console.log();
+}
+
+// src/time-machine.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var HISTORY_FILE = ".backend-diet-history.json";
+function loadHistory(cwd) {
+  const histPath = import_path5.default.join(cwd, HISTORY_FILE);
+  try {
+    const raw = import_fs4.default.readFileSync(histPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function saveHistory(cwd, history) {
+  const histPath = import_path5.default.join(cwd, HISTORY_FILE);
+  try {
+    import_fs4.default.writeFileSync(histPath, JSON.stringify(history, null, 2), "utf-8");
+  } catch {
+  }
+}
+function getCurrentGitRef(cwd) {
+  try {
+    return (0, import_child_process.execSync)("git rev-parse --short HEAD", { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+  } catch {
+    return void 0;
+  }
+}
+function recordScanResult(result, cwd) {
+  const history = loadHistory(cwd);
+  const gitRef = getCurrentGitRef(cwd);
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    gitRef,
+    score: result.refactorScore,
+    grade: result.grade,
+    totalBytesSaved: result.totalBytesSaved
+  };
+  history.push(entry);
+  if (history.length > 50) history.splice(0, history.length - 50);
+  saveHistory(cwd, history);
+}
+function getHistory(cwd) {
+  return loadHistory(cwd);
+}
+function analyzeTimeMachineTrend(history, currentScore) {
+  const allScores = [...history.map((h) => h.score), currentScore];
+  const delta = allScores.length > 1 ? allScores[allScores.length - 1] - allScores[0] : 0;
+  return {
+    isImproving: delta >= 0,
+    delta,
+    sparkValues: allScores
+  };
+}
+
+// src/cli.ts
+var VERSION = "1.0.0";
+async function runScan(directory, options) {
+  const targetDir = import_path6.default.resolve(directory ?? process.cwd());
+  const isJson = options.format === "json";
+  if (!isJson && !options.noHeader) {
+    printHeader();
+  }
+  const spinner = isJson ? null : (0, import_ora.default)({ text: "Scanning files\u2026", color: "cyan" }).start();
+  try {
+    const startMs = Date.now();
+    const files = await walkFiles(targetDir, options.ignore ?? []);
+    if (spinner) spinner.text = `Parsing ${files.length} files\u2026`;
+    const imports = await parseFiles(files);
+    if (spinner) spinner.text = "Matching against diet database\u2026";
+    const matches = matchImports(imports);
+    const scanDurationMs = Date.now() - startMs;
+    const result = buildScanResult(targetDir, files.length, imports, matches, scanDurationMs);
+    if (spinner) spinner.succeed(import_chalk2.default.green(`Scanned ${files.length} files in ${scanDurationMs}ms`));
+    recordScanResult(result, targetDir);
+    if (isJson) {
+      printJsonReport(result);
+      return;
+    }
+    printScoreCard(result);
+    printMatchesTable(matches);
+    if (matches.length > 0) {
+      printSuggestions(matches);
+    }
+    if (options.since) {
+      printInfo("Time Machine: comparing score trend\u2026");
+      const history = getHistory(targetDir);
+      analyzeTimeMachineTrend(history, result.refactorScore);
+      printTimeMachine(
+        history.map((h) => ({
+          timestamp: h.timestamp,
+          score: h.score,
+          gitRef: h.gitRef,
+          grade: h.grade
+        })),
+        result.refactorScore
+      );
+    }
+    if (options.badge) {
+      printBadge(result.refactorScore, result.grade);
+    }
+    if (options.fix) {
+      const patches = computePatches(matches, targetDir);
+      if (patches.length === 0) {
+        printInfo("No trivial patches available for automatic rewriting.");
+      } else {
+        console.log(
+          import_chalk2.default.bold.white(
+            `
+  AUTO-PATCH PREVIEW  (${patches.length} trivial replacement${patches.length === 1 ? "" : "s"})
+`
+          )
+        );
+        for (const patch of patches) {
+          printPatchPreview(patch.file, patch.before, patch.after);
+        }
+        if (options.yes) {
+          const applied = applyPatches(patches, targetDir);
+          console.log(
+            import_chalk2.default.green(`
+  \u2713 Applied ${applied.length} patch${applied.length === 1 ? "" : "es"} successfully.
+`)
+          );
+        } else {
+          console.log(import_chalk2.default.dim("  Add --yes to apply these patches in-place.\n"));
+        }
+      }
+    }
+    printFooter(result, !!options.fix && !options.yes);
+    if (result.grade === "CRITICAL") {
+      process.exit(1);
+    }
+  } catch (err) {
+    if (spinner) spinner.fail("Scan failed");
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+var program = new import_commander.Command();
+program.name("backend-diet").version(VERSION, "-v, --version").description("Put your project on a diet. Find heavy packages, get native alternatives.").helpOption("-h, --help", "Display help");
+program.command("scan [directory]", { isDefault: true }).description("Scan source files for heavy library usage and suggest native alternatives").option("--fix", "Preview trivial auto-patches (dry run by default)").option("--yes", "Apply --fix patches in-place (requires --fix)").option("--badge", "Print a Shields.io badge for your README").option("--since <ref>", "Show score trend since a git ref (e.g. HEAD~10)").option("--format <fmt>", "Output format: terminal | json", "terminal").option("--ignore <patterns...>", 'Glob patterns to ignore (e.g. "vendor/**")').option("--no-header", "Suppress the ASCII art header").action(async (directory, options) => {
+  await runScan(directory, {
+    ...options,
+    noHeader: !options.header
+  });
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map