lambda-doctor 0.1.0

package/dist/cli.js

@@ -0,0 +1,737 @@
+#!/usr/bin/env node
+
+// src/bin/cli.ts
+import { Command } from "commander";
+import ora from "ora";
+import fs6 from "fs/promises";
+import path7 from "path";
+
+// src/index.ts
+import path6 from "path";
+
+// src/analyzers/bundle-size.ts
+import fg from "fast-glob";
+import fs from "fs/promises";
+import path from "path";
+function getPackageName(filePath) {
+  const parts = filePath.split("/");
+  if (parts[0].startsWith("@")) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+var bundleSizeAnalyzer = {
+  name: "bundle-size",
+  description: "Analyzes total node_modules size and identifies the largest dependencies",
+  async analyze(targetPath) {
+    const start = performance.now();
+    const diagnostics = [];
+    const nodeModulesPath = path.join(targetPath, "node_modules");
+    try {
+      await fs.access(nodeModulesPath);
+    } catch {
+      return {
+        analyzer: "bundle-size",
+        durationMs: performance.now() - start,
+        diagnostics: [],
+        metadata: { totalSizeBytes: 0, topDependencies: [] }
+      };
+    }
+    try {
+      const files = await fg("**/*", {
+        cwd: nodeModulesPath,
+        stats: true,
+        onlyFiles: true,
+        dot: true
+      });
+      const packageSizes = /* @__PURE__ */ new Map();
+      for (const entry of files) {
+        const pkgName = getPackageName(entry.path);
+        const size = entry.stats?.size ?? 0;
+        packageSizes.set(pkgName, (packageSizes.get(pkgName) ?? 0) + size);
+      }
+      const totalSizeBytes = [...packageSizes.values()].reduce((a, b) => a + b, 0);
+      const sorted = [...packageSizes.entries()].sort((a, b) => b[1] - a[1]);
+      const top10 = sorted.slice(0, 10);
+      const topDependencies = top10.map(([name, sizeBytes]) => ({
+        name,
+        version: "",
+        sizeBytes,
+        isHeavy: false
+      }));
+      const totalMB = totalSizeBytes / (1024 * 1024);
+      if (totalMB > 50) {
+        diagnostics.push({
+          analyzer: "bundle-size",
+          severity: "critical",
+          title: "Bundle size is critically large",
+          description: `Total node_modules size is ${totalMB.toFixed(1)}MB. AWS Lambda has a 250MB unzipped limit and large bundles severely impact cold start times.`,
+          recommendation: "Use a bundler (esbuild/webpack) to tree-shake and bundle only what you need. Remove unused dependencies.",
+          estimatedImpactMs: Math.min(totalMB * 10, 2e3)
+        });
+      } else if (totalMB > 10) {
+        diagnostics.push({
+          analyzer: "bundle-size",
+          severity: "warning",
+          title: "Bundle size is large",
+          description: `Total node_modules size is ${totalMB.toFixed(1)}MB. This adds unnecessary cold start latency.`,
+          recommendation: "Consider using a bundler to reduce the deployment package size.",
+          estimatedImpactMs: Math.min(totalMB * 5, 500)
+        });
+      }
+      for (const [name, sizeBytes] of sorted) {
+        const depMB = sizeBytes / (1024 * 1024);
+        if (depMB > 5) {
+          diagnostics.push({
+            analyzer: "bundle-size",
+            severity: "critical",
+            title: `Dependency "${name}" is very large (${depMB.toFixed(1)}MB)`,
+            description: `The package "${name}" takes up ${depMB.toFixed(1)}MB on disk.`,
+            recommendation: `Look for a lighter alternative to "${name}" or ensure it's being tree-shaken.`,
+            estimatedImpactMs: Math.min(depMB * 8, 500)
+          });
+        } else if (depMB > 1) {
+          diagnostics.push({
+            analyzer: "bundle-size",
+            severity: "warning",
+            title: `Dependency "${name}" is large (${depMB.toFixed(1)}MB)`,
+            description: `The package "${name}" takes up ${depMB.toFixed(1)}MB on disk.`,
+            recommendation: `Consider replacing "${name}" with a lighter alternative.`,
+            estimatedImpactMs: Math.min(depMB * 5, 200)
+          });
+        }
+      }
+      return {
+        analyzer: "bundle-size",
+        durationMs: performance.now() - start,
+        diagnostics,
+        metadata: { totalSizeBytes, topDependencies }
+      };
+    } catch (error) {
+      console.warn("bundle-size analyzer warning:", error);
+      return {
+        analyzer: "bundle-size",
+        durationMs: performance.now() - start,
+        diagnostics: [],
+        metadata: { totalSizeBytes: 0, topDependencies: [] }
+      };
+    }
+  }
+};
+
+// src/analyzers/heavy-dependencies.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// known-heavy-packages.ts
+var HEAVY_PACKAGES = [
+  {
+    name: "aws-sdk",
+    typicalSizeBytes: 65e6,
+    reason: "AWS SDK v2 is 65MB+ and loads all service clients. Lambda runtime includes it, but it's slow.",
+    alternative: "Use @aws-sdk/client-* (v3) with selective imports. Only import clients you need.",
+    estimatedSavingsMs: 400
+  },
+  {
+    name: "moment",
+    typicalSizeBytes: 48e5,
+    reason: "Moment.js is 4.8MB with locales. Not tree-shakeable.",
+    alternative: "Use dayjs (2KB) or date-fns with tree-shaking.",
+    estimatedSavingsMs: 50
+  },
+  {
+    name: "moment-timezone",
+    typicalSizeBytes: 82e5,
+    reason: "Moment-timezone adds 8MB+ of timezone data on top of Moment.",
+    alternative: "Use dayjs/plugin/timezone or Intl.DateTimeFormat (built-in).",
+    estimatedSavingsMs: 80
+  },
+  {
+    name: "lodash",
+    typicalSizeBytes: 14e5,
+    reason: "Full lodash is 1.4MB. Not tree-shakeable with CommonJS.",
+    alternative: "Use lodash-es (tree-shakeable) or individual packages like lodash.get.",
+    estimatedSavingsMs: 30
+  },
+  {
+    name: "axios",
+    typicalSizeBytes: 45e4,
+    reason: "Axios is 450KB. Overkill for Lambda where you can use native fetch (Node 18+).",
+    alternative: "Use native fetch (Node 18+) or undici.",
+    estimatedSavingsMs: 15
+  },
+  {
+    name: "express",
+    typicalSizeBytes: 55e4,
+    reason: "Express has 30+ dependencies. Heavy for a single Lambda function.",
+    alternative: "Use lambda-api (zero deps) or direct API Gateway event parsing.",
+    estimatedSavingsMs: 20
+  },
+  {
+    name: "bluebird",
+    typicalSizeBytes: 35e4,
+    reason: "Bluebird is unnecessary in Node 18+ which has native Promise with good performance.",
+    alternative: "Use native Promise (built-in).",
+    estimatedSavingsMs: 10
+  },
+  {
+    name: "uuid",
+    typicalSizeBytes: 15e4,
+    reason: "UUID package is 150KB. Node 18+ has crypto.randomUUID() built-in.",
+    alternative: "Use crypto.randomUUID() (built-in Node 18+).",
+    estimatedSavingsMs: 5
+  },
+  {
+    name: "winston",
+    typicalSizeBytes: 25e5,
+    reason: "Winston is 2.5MB with many transports. Too heavy for Lambda.",
+    alternative: "Use @aws-lambda-powertools/logger or pino.",
+    estimatedSavingsMs: 40
+  },
+  {
+    name: "joi",
+    typicalSizeBytes: 95e4,
+    reason: "Joi is ~1MB. Heavy for Lambda validation.",
+    alternative: "Use zod (lighter, TypeScript-native) or ajv.",
+    estimatedSavingsMs: 20
+  },
+  {
+    name: "mongoose",
+    typicalSizeBytes: 38e5,
+    reason: "Mongoose is 3.8MB. Extremely heavy for Lambda.",
+    alternative: "Use native MongoDB driver or Dynamoose for DynamoDB.",
+    estimatedSavingsMs: 100
+  },
+  {
+    name: "typescript",
+    typicalSizeBytes: 65e6,
+    reason: "TypeScript compiler in production bundle is 65MB. Should only be a devDependency.",
+    alternative: "Move to devDependencies. Deploy compiled JavaScript only.",
+    estimatedSavingsMs: 500
+  },
+  {
+    name: "ts-node",
+    typicalSizeBytes: 35e5,
+    reason: "ts-node adds 200-500ms cold start. Should not be in production.",
+    alternative: "Transpile to JavaScript before deployment.",
+    estimatedSavingsMs: 350
+  },
+  {
+    name: "@nestjs/core",
+    typicalSizeBytes: 52e5,
+    reason: "NestJS is a heavy framework (5MB+). Decorator metadata and DI container add cold start overhead.",
+    alternative: "Use lighter patterns for Lambda: plain handlers or lambda-api.",
+    estimatedSavingsMs: 150
+  },
+  {
+    name: "puppeteer",
+    typicalSizeBytes: 3e8,
+    reason: "Puppeteer bundles Chromium (300MB+). Exceeds Lambda package limits.",
+    alternative: "Use @sparticuz/chromium with puppeteer-core for Lambda.",
+    estimatedSavingsMs: 2e3
+  }
+];
+function findHeavyPackage(name) {
+  return HEAVY_PACKAGES.find((pkg) => pkg.name === name);
+}
+function isHeavyPackage(name) {
+  return HEAVY_PACKAGES.some((pkg) => pkg.name === name);
+}
+
+// src/analyzers/heavy-dependencies.ts
+var DEV_ONLY_PACKAGES = ["typescript", "ts-node", "ts-jest", "jest", "mocha", "eslint", "prettier", "tsup", "webpack", "rollup", "esbuild"];
+var heavyDependenciesAnalyzer = {
+  name: "heavy-dependencies",
+  description: "Detects known heavy dependencies and dev tools in production",
+  async analyze(targetPath) {
+    const start = performance.now();
+    const diagnostics = [];
+    try {
+      const pkgJsonPath = path2.join(targetPath, "package.json");
+      const pkgJson = JSON.parse(await fs2.readFile(pkgJsonPath, "utf-8"));
+      const deps = pkgJson.dependencies ?? {};
+      const devDeps = pkgJson.devDependencies ?? {};
+      let heavyCount = 0;
+      for (const depName of Object.keys(deps)) {
+        const heavy = findHeavyPackage(depName);
+        if (heavy) {
+          heavyCount++;
+          diagnostics.push({
+            analyzer: "heavy-dependencies",
+            severity: "warning",
+            title: `Heavy dependency: ${depName}`,
+            description: heavy.reason,
+            recommendation: heavy.alternative,
+            estimatedImpactMs: heavy.estimatedSavingsMs,
+            filePath: "package.json"
+          });
+        }
+      }
+      for (const depName of Object.keys(deps)) {
+        if (DEV_ONLY_PACKAGES.includes(depName)) {
+          diagnostics.push({
+            analyzer: "heavy-dependencies",
+            severity: "critical",
+            title: `Dev tool "${depName}" in production dependencies`,
+            description: `"${depName}" is a development tool that should not be in "dependencies". It adds unnecessary size and cold start time.`,
+            recommendation: `Move "${depName}" from "dependencies" to "devDependencies".`,
+            estimatedImpactMs: findHeavyPackage(depName)?.estimatedSavingsMs ?? 100,
+            filePath: "package.json"
+          });
+        }
+      }
+      return {
+        analyzer: "heavy-dependencies",
+        durationMs: performance.now() - start,
+        diagnostics,
+        metadata: { heavyCount, totalDependencies: Object.keys(deps).length }
+      };
+    } catch (error) {
+      console.warn("heavy-dependencies analyzer warning:", error);
+      return {
+        analyzer: "heavy-dependencies",
+        durationMs: performance.now() - start,
+        diagnostics: []
+      };
+    }
+  }
+};
+
+// src/analyzers/import-analysis.ts
+import fg2 from "fast-glob";
+import fs3 from "fs/promises";
+import path3 from "path";
+var ESM_IMPORT = /^import\s+.*\s+from\s+['"](.+)['"]/gm;
+var CJS_REQUIRE = /^(?:const|let|var)\s+.*=\s*require\(['"](.+)['"]\)/gm;
+var WILDCARD_IMPORT = /^import\s+\*\s+as\s+\w+\s+from\s+['"](.+)['"]/gm;
+function getPackageName2(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return null;
+  const parts = specifier.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  }
+  return parts[0];
+}
+function isTopLevel(line) {
+  const indent = line.length - line.trimStart().length;
+  return indent <= 1;
+}
+var importAnalysisAnalyzer = {
+  name: "import-analysis",
+  description: "Analyzes import patterns for tree-shaking issues and heavy top-level imports",
+  async analyze(targetPath) {
+    const start = performance.now();
+    const diagnostics = [];
+    try {
+      const files = await fg2(["**/*.ts", "**/*.js", "**/*.mjs"], {
+        cwd: targetPath,
+        ignore: ["node_modules/**", "dist/**", "**/*.d.ts"],
+        absolute: false
+      });
+      for (const file of files) {
+        const filePath = path3.join(targetPath, file);
+        const content = await fs3.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          let match;
+          WILDCARD_IMPORT.lastIndex = 0;
+          while ((match = WILDCARD_IMPORT.exec(line)) !== null) {
+            const pkg = getPackageName2(match[1]);
+            if (pkg) {
+              diagnostics.push({
+                analyzer: "import-analysis",
+                severity: "warning",
+                title: `Wildcard import of "${pkg}" prevents tree-shaking`,
+                description: `"import * as ..." from "${match[1]}" imports the entire module, preventing bundlers from removing unused code.`,
+                recommendation: `Use named imports: import { specificFunction } from "${match[1]}"`,
+                estimatedImpactMs: 20,
+                filePath: file,
+                line: i + 1
+              });
+            }
+          }
+          if (isTopLevel(line)) {
+            for (const regex of [ESM_IMPORT, CJS_REQUIRE]) {
+              regex.lastIndex = 0;
+              while ((match = regex.exec(line)) !== null) {
+                const pkg = getPackageName2(match[1]);
+                if (pkg && isHeavyPackage(pkg)) {
+                  const heavy = findHeavyPackage(pkg);
+                  diagnostics.push({
+                    analyzer: "import-analysis",
+                    severity: "warning",
+                    title: `Top-level import of heavy package "${pkg}"`,
+                    description: `"${pkg}" is imported at the top level in ${file}. This forces it to load during cold start even if not needed for every invocation.`,
+                    recommendation: `Consider lazy-loading: move the import inside the function that uses it. ${heavy.alternative}`,
+                    estimatedImpactMs: heavy.estimatedSavingsMs / 2,
+                    filePath: file,
+                    line: i + 1
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      return {
+        analyzer: "import-analysis",
+        durationMs: performance.now() - start,
+        diagnostics,
+        metadata: { filesScanned: files.length }
+      };
+    } catch (error) {
+      console.warn("import-analysis analyzer warning:", error);
+      return {
+        analyzer: "import-analysis",
+        durationMs: performance.now() - start,
+        diagnostics: []
+      };
+    }
+  }
+};
+
+// src/analyzers/aws-sdk.ts
+import fs4 from "fs/promises";
+import fg3 from "fast-glob";
+import path4 from "path";
+var awsSdkAnalyzer = {
+  name: "aws-sdk",
+  description: "Checks AWS SDK version usage and migration status",
+  async analyze(targetPath) {
+    const start = performance.now();
+    const diagnostics = [];
+    try {
+      const pkgJsonPath = path4.join(targetPath, "package.json");
+      const pkgJson = JSON.parse(await fs4.readFile(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkgJson.dependencies ?? {}, ...pkgJson.devDependencies ?? {} };
+      const hasV2 = "aws-sdk" in allDeps;
+      const v3Clients = Object.keys(allDeps).filter((d) => d.startsWith("@aws-sdk/client-"));
+      const hasV3 = v3Clients.length > 0;
+      if (hasV2 && !hasV3) {
+        diagnostics.push({
+          analyzer: "aws-sdk",
+          severity: "critical",
+          title: "Using AWS SDK v2 (aws-sdk)",
+          description: "AWS SDK v2 is 65MB+ and loads all service clients. It adds 400ms+ to cold starts.",
+          recommendation: "Migrate to AWS SDK v3 (@aws-sdk/client-*). Only import the clients you need.",
+          estimatedImpactMs: 400,
+          filePath: "package.json"
+        });
+      }
+      if (hasV2 && hasV3) {
+        diagnostics.push({
+          analyzer: "aws-sdk",
+          severity: "warning",
+          title: "Incomplete AWS SDK v2 to v3 migration",
+          description: "Both aws-sdk (v2) and @aws-sdk/client-* (v3) are present. This means v2 is still bundled alongside v3.",
+          recommendation: 'Complete the migration to SDK v3 and remove the "aws-sdk" dependency.',
+          estimatedImpactMs: 400,
+          filePath: "package.json"
+        });
+      }
+      if (v3Clients.length > 5) {
+        diagnostics.push({
+          analyzer: "aws-sdk",
+          severity: "info",
+          title: `${v3Clients.length} AWS SDK v3 clients detected`,
+          description: `This Lambda uses ${v3Clients.length} AWS SDK clients: ${v3Clients.join(", ")}. Each client adds to bundle size.`,
+          recommendation: "Verify all clients are necessary. Consider splitting into multiple Lambdas if responsibilities are too broad.",
+          estimatedImpactMs: v3Clients.length * 5
+        });
+      }
+      const sourceFiles = await fg3(["**/*.ts", "**/*.js", "**/*.mjs"], {
+        cwd: targetPath,
+        ignore: ["node_modules/**", "dist/**", "**/*.d.ts"],
+        absolute: false
+      });
+      for (const file of sourceFiles) {
+        const content = await fs4.readFile(path4.join(targetPath, file), "utf-8");
+        if (content.includes("@aws-sdk/client-sso")) {
+          diagnostics.push({
+            analyzer: "aws-sdk",
+            severity: "warning",
+            title: "Unnecessary SSO client in Lambda",
+            description: "@aws-sdk/client-sso is imported but Lambda functions use IAM roles, not SSO authentication.",
+            recommendation: "Remove the @aws-sdk/client-sso import. Lambda uses IAM execution roles for authentication.",
+            estimatedImpactMs: 15,
+            filePath: file
+          });
+          break;
+        }
+      }
+      return {
+        analyzer: "aws-sdk",
+        durationMs: performance.now() - start,
+        diagnostics,
+        metadata: { hasV2, hasV3, v3ClientCount: v3Clients.length }
+      };
+    } catch (error) {
+      console.warn("aws-sdk analyzer warning:", error);
+      return {
+        analyzer: "aws-sdk",
+        durationMs: performance.now() - start,
+        diagnostics: []
+      };
+    }
+  }
+};
+
+// src/analyzers/bundler-detection.ts
+import fs5 from "fs/promises";
+import fg4 from "fast-glob";
+import path5 from "path";
+var BUNDLER_PACKAGES = ["esbuild", "webpack", "rollup", "tsup", "parcel"];
+var BUNDLER_CONFIGS = [
+  "webpack.config.*",
+  "rollup.config.*",
+  "tsup.config.*",
+  "esbuild.config.*",
+  ".parcelrc"
+];
+var BUNDLER_KEYWORDS = ["esbuild", "webpack", "rollup", "tsup", "parcel", "bundle"];
+var bundlerDetectionAnalyzer = {
+  name: "bundler-detection",
+  description: "Detects whether a bundler is configured and checks ESM/bundler setup",
+  async analyze(targetPath) {
+    const start = performance.now();
+    const diagnostics = [];
+    try {
+      const pkgJsonPath = path5.join(targetPath, "package.json");
+      const pkgJson = JSON.parse(await fs5.readFile(pkgJsonPath, "utf-8"));
+      const devDeps = pkgJson.devDependencies ?? {};
+      const deps = pkgJson.dependencies ?? {};
+      const allDeps = { ...deps, ...devDeps };
+      const scripts = pkgJson.scripts ?? {};
+      const detectedBundlers = [];
+      for (const bundler of BUNDLER_PACKAGES) {
+        if (bundler in allDeps) {
+          detectedBundlers.push(bundler);
+        }
+      }
+      const configFiles = await fg4(BUNDLER_CONFIGS, {
+        cwd: targetPath,
+        dot: true
+      });
+      const bundlerScripts = [];
+      for (const [name, script] of Object.entries(scripts)) {
+        if (typeof script === "string" && BUNDLER_KEYWORDS.some((kw) => script.includes(kw))) {
+          bundlerScripts.push(name);
+        }
+      }
+      let serverlessPlugin = null;
+      try {
+        const slsPath = path5.join(targetPath, "serverless.yml");
+        const slsContent = await fs5.readFile(slsPath, "utf-8");
+        if (slsContent.includes("serverless-esbuild")) serverlessPlugin = "serverless-esbuild";
+        else if (slsContent.includes("serverless-webpack")) serverlessPlugin = "serverless-webpack";
+      } catch {
+      }
+      const isESM = pkgJson.type === "module";
+      const hasBundler = detectedBundlers.length > 0 || configFiles.length > 0 || serverlessPlugin !== null;
+      if (!hasBundler) {
+        diagnostics.push({
+          analyzer: "bundler-detection",
+          severity: "critical",
+          title: "No bundler detected",
+          description: "No bundler (esbuild, webpack, rollup, etc.) was found in this project. Without a bundler, the entire node_modules directory is deployed, causing large bundle sizes and slow cold starts.",
+          recommendation: "Add esbuild (fastest) or webpack to bundle your Lambda function. This is typically the single biggest cold start improvement you can make.",
+          estimatedImpactMs: 500
+        });
+      } else {
+        diagnostics.push({
+          analyzer: "bundler-detection",
+          severity: "info",
+          title: `Bundler detected: ${detectedBundlers.join(", ") || serverlessPlugin || "config found"}`,
+          description: `Found bundler setup: packages=[${detectedBundlers.join(", ")}], configs=[${configFiles.join(", ")}]${serverlessPlugin ? `, serverless plugin=${serverlessPlugin}` : ""}.`,
+          recommendation: "Ensure your bundler is configured for tree-shaking and minification.",
+          estimatedImpactMs: 0
+        });
+      }
+      if (!isESM) {
+        diagnostics.push({
+          analyzer: "bundler-detection",
+          severity: "info",
+          title: "Project is not using ESM",
+          description: '"type": "module" is not set in package.json. ESM enables better tree-shaking with bundlers.',
+          recommendation: 'Consider setting "type": "module" in package.json for better tree-shaking support.',
+          estimatedImpactMs: 20
+        });
+      }
+      return {
+        analyzer: "bundler-detection",
+        durationMs: performance.now() - start,
+        diagnostics,
+        metadata: {
+          detectedBundlers,
+          configFiles,
+          bundlerScripts,
+          serverlessPlugin,
+          isESM,
+          hasBundler
+        }
+      };
+    } catch (error) {
+      console.warn("bundler-detection analyzer warning:", error);
+      return {
+        analyzer: "bundler-detection",
+        durationMs: performance.now() - start,
+        diagnostics: []
+      };
+    }
+  }
+};
+
+// src/reporters/console.ts
+import chalk from "chalk";
+var SEVERITY_ICON = {
+  critical: "\u{1F534}",
+  warning: "\u26A0\uFE0F",
+  info: "\u{1F4A1}"
+};
+var SEVERITY_COLOR = {
+  critical: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.blue
+};
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${bytes}B`;
+}
+function printReport(report) {
+  console.log();
+  console.log(chalk.bold.cyan("\u{1FA7A} Lambda Doctor \u2014 Diagnosis Report"));
+  console.log(chalk.gray(`   Target: ${report.targetPath}`));
+  console.log(chalk.gray(`   Date:   ${report.timestamp}`));
+  console.log();
+  const bundleSizeResult = report.results.find((r) => r.analyzer === "bundle-size");
+  if (bundleSizeResult?.metadata) {
+    const { totalSizeBytes, topDependencies } = bundleSizeResult.metadata;
+    if (totalSizeBytes > 0) {
+      console.log(chalk.bold("\u{1F4E6} Bundle Size Breakdown"));
+      console.log(chalk.gray(`   Total: ${formatBytes(totalSizeBytes)}`));
+      console.log();
+      if (topDependencies && topDependencies.length > 0) {
+        console.log(chalk.gray("   Top Dependencies:"));
+        for (const dep of topDependencies) {
+          const bar = "\u2588".repeat(Math.max(1, Math.round(dep.sizeBytes / totalSizeBytes * 30)));
+          console.log(`   ${chalk.white(dep.name.padEnd(35))} ${formatBytes(dep.sizeBytes).padStart(10)}  ${chalk.green(bar)}`);
+        }
+        console.log();
+      }
+    }
+  }
+  const allDiagnostics = report.results.flatMap((r) => r.diagnostics);
+  const severityOrder = { critical: 0, warning: 1, info: 2 };
+  const sorted = [...allDiagnostics].sort(
+    (a, b) => severityOrder[a.severity] - severityOrder[b.severity]
+  );
+  if (sorted.length === 0) {
+    console.log(chalk.green.bold("\u2705 No issues found! Your Lambda looks healthy."));
+    console.log();
+    return;
+  }
+  console.log(chalk.bold("\u{1F50D} Diagnostics"));
+  console.log();
+  for (const diag of sorted) {
+    const icon = SEVERITY_ICON[diag.severity];
+    const colorFn = SEVERITY_COLOR[diag.severity];
+    const location = diag.filePath ? chalk.gray(` (${diag.filePath}${diag.line ? `:${diag.line}` : ""})`) : "";
+    console.log(`${icon} ${colorFn(diag.severity.toUpperCase())} ${chalk.bold(diag.title)}${location}`);
+    console.log(chalk.gray(`   ${diag.description}`));
+    console.log(chalk.green(`   \u2192 ${diag.recommendation}`));
+    if (diag.estimatedImpactMs > 0) {
+      console.log(chalk.cyan(`   \u23F1  Est. improvement: ~${diag.estimatedImpactMs}ms`));
+    }
+    console.log();
+  }
+  const { summary } = report;
+  console.log(chalk.bold("\u2500".repeat(60)));
+  console.log(
+    chalk.bold("Summary: ") + chalk.red(`${summary.critical} critical`) + chalk.gray(" | ") + chalk.yellow(`${summary.warnings} warnings`) + chalk.gray(" | ") + chalk.blue(`${summary.info} info`)
+  );
+  if (summary.estimatedTotalImpactMs > 0) {
+    console.log(
+      chalk.bold.green(`
+\u{1F680} Total estimated cold start improvement: ~${summary.estimatedTotalImpactMs}ms`)
+    );
+  }
+  console.log();
+}
+
+// src/index.ts
+var ALL_ANALYZERS = [
+  bundleSizeAnalyzer,
+  heavyDependenciesAnalyzer,
+  importAnalysisAnalyzer,
+  awsSdkAnalyzer,
+  bundlerDetectionAnalyzer
+];
+async function analyze(config) {
+  const targetPath = path6.resolve(config.targetPath);
+  const start = performance.now();
+  const analyzersToRun = config.analyzers ? ALL_ANALYZERS.filter((a) => config.analyzers.includes(a.name)) : ALL_ANALYZERS;
+  const results = await Promise.all(
+    analyzersToRun.map((a) => a.analyze(targetPath))
+  );
+  const allDiagnostics = results.flatMap((r) => r.diagnostics);
+  const summary = {
+    totalIssues: allDiagnostics.length,
+    critical: allDiagnostics.filter((d) => d.severity === "critical").length,
+    warnings: allDiagnostics.filter((d) => d.severity === "warning").length,
+    info: allDiagnostics.filter((d) => d.severity === "info").length,
+    estimatedTotalImpactMs: allDiagnostics.reduce((sum, d) => sum + d.estimatedImpactMs, 0),
+    heavyDependencies: results.find((r) => r.analyzer === "heavy-dependencies")?.metadata?.heavyCount ?? 0,
+    bundleSizeBytes: results.find((r) => r.analyzer === "bundle-size")?.metadata?.totalSizeBytes ?? void 0
+  };
+  return {
+    targetPath,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalDurationMs: performance.now() - start,
+    results,
+    summary
+  };
+}
+
+// src/bin/cli.ts
+var program = new Command();
+program.name("lambda-doctor").description("Diagnose and fix AWS Lambda cold start performance issues").version("0.1.0");
+program.command("analyze").description("Analyze a Lambda project directory").argument("<path>", "Path to the Lambda project directory").option("--format <format>", "Output format: console or json", "console").option("--verbose", "Show verbose output", false).action(async (targetPath, options) => {
+  const resolvedPath = path7.resolve(targetPath);
+  try {
+    await fs6.access(resolvedPath);
+  } catch {
+    console.error(`Error: Path does not exist: ${resolvedPath}`);
+    process.exit(1);
+  }
+  try {
+    await fs6.access(path7.join(resolvedPath, "package.json"));
+  } catch {
+    console.error(`Error: No package.json found in ${resolvedPath}`);
+    process.exit(1);
+  }
+  const spinner = ora("Analyzing Lambda project...").start();
+  try {
+    const report = await analyze({
+      targetPath: resolvedPath,
+      format: options.format,
+      verbose: options.verbose
+    });
+    spinner.stop();
+    if (options.format === "json") {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      printReport(report);
+    }
+    if (report.summary.critical > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Analysis failed");
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map