@bfra.me/workspace-analyzer 0.1.0

package/lib/index.js

@@ -0,0 +1,1262 @@
+import {
+  BUILTIN_ANALYZER_IDS,
+  BUILTIN_RULE_IDS,
+  CATEGORY_CONFIG,
+  DEFAULT_ANALYZER_CONFIG,
+  DEFAULT_CONCURRENCY,
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_INCLUDE_PATTERNS,
+  DEFAULT_LAYER_CONFIG,
+  DEFAULT_PACKAGE_PATTERNS,
+  DEFAULT_REPORT_OPTIONS,
+  DEFAULT_WORKSPACE_OPTIONS,
+  METADATA,
+  METADATA2,
+  METADATA3,
+  METADATA4,
+  METADATA5,
+  METADATA6,
+  METADATA7,
+  SEVERITY_CONFIG,
+  aggregatePackageImports,
+  analyzePackages,
+  analyzeWorkspace,
+  architecturalAnalyzerMetadata,
+  barrelExportRuleMetadata,
+  buildDependencyGraph,
+  builtinAnalyzers,
+  calculateSummary,
+  circularImportAnalyzerMetadata,
+  computeCycleStats,
+  computeDeadCodeStats,
+  computeDuplicateStats,
+  computeGraphStatistics,
+  createAnalyzerRegistry,
+  createArchitecturalAnalyzer,
+  createBarrelExportRule,
+  createBuildConfigAnalyzer,
+  createCircularImportAnalyzer,
+  createConfigConsistencyAnalyzer,
+  createConsoleReporter,
+  createDeadCodeAnalyzer,
+  createDefaultRegistry,
+  createDuplicateCodeAnalyzer,
+  createDuplicateDependencyAnalyzer,
+  createEslintConfigAnalyzer,
+  createExportsFieldAnalyzer,
+  createIssue,
+  createJsonReporter,
+  createLargeDependencyAnalyzer,
+  createLayerViolationRule,
+  createMarkdownReporter,
+  createOrchestrator,
+  createPackageBoundaryRule,
+  createPackageJsonAnalyzer,
+  createPathAliasRule,
+  createPeerDependencyAnalyzer,
+  createProject,
+  createPublicApiRule,
+  createRuleEngine,
+  createSideEffectRule,
+  createTreeShakingBlockerAnalyzer,
+  createTsconfigAnalyzer,
+  createUnusedDependencyAnalyzer,
+  createVersionAlignmentAnalyzer,
+  createWorkspaceScanner,
+  deadCodeAnalyzerMetadata,
+  defineConfig,
+  duplicateCodeAnalyzerMetadata,
+  duplicateDependencyAnalyzerMetadata,
+  extractImports,
+  filterIssues,
+  filterIssuesForReport,
+  filterPackagesByPattern,
+  findConfigFile,
+  findCycles,
+  formatDuration,
+  formatLocation,
+  generateCycleVisualization,
+  getAllDependencies,
+  getAllSourceFiles,
+  getAnalyzerOptions,
+  getDefaultConfig,
+  getFileLayer,
+  getKnownLargePackages,
+  getPackageInfo,
+  getPackageNameFromSpecifier,
+  getPackageScope,
+  getRelativePath,
+  getSourceFile,
+  getTransitiveDependencies,
+  getTransitiveDependents,
+  getUniqueDependencies,
+  getUnscopedName,
+  groupIssues,
+  groupPackagesByScope,
+  isJavaScriptFile,
+  isLayerImportAllowed,
+  isRelativeImport,
+  isSourceFile,
+  isTypeScriptFile,
+  isWorkspacePackageImport,
+  largeDependencyAnalyzerMetadata,
+  layerViolationRuleMetadata,
+  loadConfig,
+  loadConfigFile,
+  matchAnyPattern,
+  matchPattern,
+  meetsMinSeverity,
+  mergeAnalyzerConfigs,
+  mergeConfig,
+  normalizePath,
+  packageBoundaryRuleMetadata,
+  parsePackageJson,
+  parsePackageJsonContent,
+  parseSourceContent,
+  parseSourceFile,
+  parseSourceFiles,
+  parseTsConfig,
+  parseTsConfigContent,
+  parseWorkspaceAnalyzerConfig,
+  pathAliasRuleMetadata,
+  peerDependencyAnalyzerMetadata,
+  publicApiRuleMetadata,
+  resolveRelativeImport,
+  resolveTsConfigExtends,
+  safeParseAnalyzeOptions,
+  shouldAnalyzeCategory,
+  sideEffectRuleMetadata,
+  treeShakingBlockerAnalyzerMetadata,
+  truncateText,
+  unusedDependencyAnalyzerMetadata
+} from "./chunk-WOJ4C7N7.js";
+import "./chunk-4LSFAAZW.js";
+import {
+  err,
+  flatMap,
+  fromPromise,
+  fromThrowable,
+  isErr,
+  isOk,
+  map,
+  mapErr,
+  ok,
+  unwrap,
+  unwrapOr
+} from "./chunk-JDF7DQ4V.js";
+
+// src/cache/cache-manager.ts
+import { Buffer } from "buffer";
+import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { join } from "path";
+import { promisify } from "util";
+import { gunzip, gzip } from "zlib";
+
+// src/cache/cache-schema.ts
+var CACHE_SCHEMA_VERSION = 1;
+var CONFIG_FILE_PATTERNS = [
+  "package.json",
+  "tsconfig.json",
+  "tsconfig.*.json",
+  "eslint.config.ts",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  ".eslintrc.*",
+  "tsup.config.ts",
+  "tsup.config.js",
+  "vitest.config.ts",
+  "vitest.config.js",
+  "workspace-analyzer.config.ts",
+  "workspace-analyzer.config.js"
+];
+var DEFAULT_CACHE_OPTIONS = {
+  cacheDir: ".workspace-analyzer-cache",
+  maxAge: 7 * 24 * 60 * 60 * 1e3,
+  // 7 days
+  compress: true,
+  hashAlgorithm: "sha256"
+};
+function createEmptyCache(workspacePath, configHash, analyzerVersion) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      version: CACHE_SCHEMA_VERSION,
+      workspacePath,
+      createdAt: now,
+      updatedAt: now,
+      configHash,
+      analyzerVersion
+    },
+    files: {},
+    packages: {},
+    workspaceIssues: [],
+    configFiles: []
+  };
+}
+function createFileAnalysisEntry(path, contentHash, modifiedAt, size, issues, analyzersRun) {
+  return {
+    fileState: {
+      path,
+      contentHash,
+      modifiedAt: modifiedAt.toISOString(),
+      size
+    },
+    issues,
+    analyzersRun,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createPackageAnalysisEntry(packageName, packagePath, packageJsonHash, issues, analyzersRun) {
+  return {
+    packageName,
+    packagePath,
+    packageJsonHash,
+    issues,
+    analyzersRun,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/cache/change-detector.ts
+import { createChangeDetector } from "@bfra.me/es/watcher";
+
+// src/cache/file-hasher.ts
+import { createFileHasher } from "@bfra.me/es/watcher";
+function createWorkspaceHasher(options = {}) {
+  const { algorithm = "sha256" } = options;
+  const baseHasher = createFileHasher(algorithm);
+  return {
+    ...baseHasher,
+    hashJson(obj) {
+      const normalized = JSON.stringify(obj, Object.keys(obj).sort(), 0);
+      return baseHasher.hashContent(normalized);
+    },
+    async hashFiles(paths) {
+      const hashes = await Promise.all(paths.map(async (path) => baseHasher.hash(path)));
+      const combined = hashes.join(":");
+      return baseHasher.hashContent(combined);
+    }
+  };
+}
+
+// src/cache/change-detector.ts
+function createAnalysisChangeDetector(options = {}) {
+  const baseDetector = createChangeDetector(options);
+  const hasher = createWorkspaceHasher({ algorithm: options.algorithm });
+  const recordedPaths = /* @__PURE__ */ new Set();
+  return {
+    async hasChanged(path) {
+      return baseDetector.hasChanged(path);
+    },
+    async record(path) {
+      recordedPaths.add(path);
+      return baseDetector.record(path);
+    },
+    clear(path) {
+      recordedPaths.delete(path);
+      baseDetector.clear(path);
+    },
+    clearAll() {
+      recordedPaths.clear();
+      baseDetector.clearAll();
+    },
+    getRecordedPaths() {
+      return Array.from(recordedPaths);
+    },
+    async validateCache(cachedFiles, currentFiles) {
+      const cachedPaths = new Set(cachedFiles.map((f) => f.path));
+      const currentPaths = new Set(currentFiles);
+      const changedFiles = [];
+      const newFiles = [];
+      const deletedFiles = [];
+      for (const path of currentPaths) {
+        if (!cachedPaths.has(path)) {
+          newFiles.push(path);
+        }
+      }
+      for (const cached of cachedFiles) {
+        if (!currentPaths.has(cached.path)) {
+          deletedFiles.push(cached.path);
+          continue;
+        }
+        try {
+          const currentHash = await hasher.hash(cached.path);
+          if (currentHash !== cached.contentHash) {
+            changedFiles.push(cached.path);
+          }
+        } catch {
+          deletedFiles.push(cached.path);
+        }
+      }
+      const hasChanges = changedFiles.length > 0 || newFiles.length > 0 || deletedFiles.length > 0;
+      let invalidationReason;
+      if (hasChanges) {
+        const reasons = [];
+        if (changedFiles.length > 0) reasons.push(`${changedFiles.length} files changed`);
+        if (newFiles.length > 0) reasons.push(`${newFiles.length} new files`);
+        if (deletedFiles.length > 0) reasons.push(`${deletedFiles.length} files deleted`);
+        invalidationReason = reasons.join(", ");
+      }
+      return {
+        isValid: !hasChanges,
+        changedFiles,
+        newFiles,
+        deletedFiles,
+        invalidatedPackages: [],
+        // Computed by cache manager based on file paths
+        changedConfigFiles: [],
+        invalidationReason
+      };
+    },
+    async hasConfigChanged(configFiles) {
+      for (const config of configFiles) {
+        try {
+          const currentHash = await hasher.hash(config.path);
+          if (currentHash !== config.contentHash) {
+            return true;
+          }
+        } catch {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+}
+
+// src/cache/cache-manager.ts
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
+var CACHE_FILE_NAME = "analysis-cache.json";
+var COMPRESSED_CACHE_FILE_NAME = "analysis-cache.json.gz";
+function createCacheManager(options) {
+  const {
+    workspacePath,
+    analyzerVersion,
+    cacheDir = DEFAULT_CACHE_OPTIONS.cacheDir,
+    maxAge = DEFAULT_CACHE_OPTIONS.maxAge,
+    compress = DEFAULT_CACHE_OPTIONS.compress,
+    hashAlgorithm = DEFAULT_CACHE_OPTIONS.hashAlgorithm
+  } = options;
+  const cachePath = join(workspacePath, cacheDir);
+  const cacheFile = join(cachePath, compress ? COMPRESSED_CACHE_FILE_NAME : CACHE_FILE_NAME);
+  const hasher = createWorkspaceHasher({ algorithm: hashAlgorithm });
+  const changeDetector = createAnalysisChangeDetector({ algorithm: hashAlgorithm });
+  async function ensureCacheDir() {
+    await mkdir(cachePath, { recursive: true });
+  }
+  async function readCacheFile() {
+    try {
+      const content = await readFile(cacheFile);
+      if (compress) {
+        const decompressed = await gunzipAsync(content);
+        return ok(decompressed.toString("utf-8"));
+      }
+      return ok(content.toString("utf-8"));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return err({ code: "CACHE_NOT_FOUND", message: "Cache file not found" });
+      }
+      return err({
+        code: "CACHE_READ_FAILED",
+        message: `Failed to read cache file: ${error.message}`,
+        cause: error
+      });
+    }
+  }
+  async function writeCacheFile(content) {
+    try {
+      await ensureCacheDir();
+      const buffer = Buffer.from(content, "utf-8");
+      const data = compress ? await gzipAsync(buffer) : buffer;
+      await writeFile(cacheFile, data);
+      return ok(void 0);
+    } catch (error) {
+      return err({
+        code: "CACHE_WRITE_FAILED",
+        message: `Failed to write cache file: ${error.message}`,
+        cause: error
+      });
+    }
+  }
+  async function getFileState(path) {
+    const stats = await stat(path);
+    const contentHash = await hasher.hash(path);
+    return {
+      path,
+      contentHash,
+      modifiedAt: stats.mtime.toISOString(),
+      size: stats.size
+    };
+  }
+  return {
+    async load() {
+      const readResult = await readCacheFile();
+      if (readResult.success === false) {
+        return readResult;
+      }
+      try {
+        const cache = JSON.parse(readResult.data);
+        const cacheVersion = cache.metadata.version;
+        if (cacheVersion !== CACHE_SCHEMA_VERSION) {
+          return err({
+            code: "CACHE_VERSION_MISMATCH",
+            message: `Cache version ${String(cacheVersion)} does not match current version ${String(CACHE_SCHEMA_VERSION)}`
+          });
+        }
+        const cacheAge = Date.now() - new Date(cache.metadata.createdAt).getTime();
+        if (cacheAge > maxAge) {
+          return err({
+            code: "CACHE_EXPIRED",
+            message: `Cache is ${Math.round(cacheAge / 1e3 / 60 / 60 / 24)} days old (max: ${Math.round(maxAge / 1e3 / 60 / 60 / 24)} days)`
+          });
+        }
+        return ok(cache);
+      } catch (error) {
+        return err({
+          code: "CACHE_CORRUPTED",
+          message: `Failed to parse cache file: ${error.message}`,
+          cause: error
+        });
+      }
+    },
+    async save(cache) {
+      const updatedCache = {
+        ...cache,
+        metadata: {
+          ...cache.metadata,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      const content = JSON.stringify(updatedCache, null, compress ? 0 : 2);
+      return writeCacheFile(content);
+    },
+    async validate(cache, currentFiles) {
+      const configChanged = await changeDetector.hasConfigChanged(cache.configFiles);
+      if (configChanged) {
+        return {
+          isValid: false,
+          changedFiles: [],
+          newFiles: [],
+          deletedFiles: [],
+          invalidatedPackages: [],
+          changedConfigFiles: cache.configFiles.map((f) => f.path),
+          invalidationReason: "Configuration files changed"
+        };
+      }
+      const cachedFileStates = Object.values(cache.files).map((f) => f.fileState);
+      const validation = await changeDetector.validateCache(cachedFileStates, currentFiles);
+      const affectedPackages = /* @__PURE__ */ new Set();
+      const allChangedPaths = [
+        ...validation.changedFiles,
+        ...validation.newFiles,
+        ...validation.deletedFiles
+      ];
+      for (const changedPath of allChangedPaths) {
+        for (const [pkgName, pkg] of Object.entries(cache.packages)) {
+          const pkgFullPath = join(workspacePath, pkg.packagePath);
+          if (changedPath.startsWith(pkgFullPath)) {
+            affectedPackages.add(pkgName);
+            break;
+          }
+        }
+      }
+      return {
+        ...validation,
+        invalidatedPackages: Array.from(affectedPackages)
+      };
+    },
+    async updateFile(cache, path, issues, analyzersRun) {
+      try {
+        const fileState = await getFileState(path);
+        const entry = createFileAnalysisEntry(
+          path,
+          fileState.contentHash,
+          new Date(fileState.modifiedAt),
+          fileState.size,
+          issues,
+          analyzersRun
+        );
+        return ok({
+          ...cache,
+          files: {
+            ...cache.files,
+            [path]: entry
+          },
+          metadata: {
+            ...cache.metadata,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+      } catch (error) {
+        return err({
+          code: "CACHE_WRITE_FAILED",
+          message: `Failed to update cache for file ${path}: ${error.message}`,
+          cause: error
+        });
+      }
+    },
+    async updatePackage(cache, packageName, packagePath, issues, analyzersRun) {
+      try {
+        const packageJsonPath = join(workspacePath, packagePath, "package.json");
+        const packageJsonHash = await hasher.hash(packageJsonPath);
+        const entry = createPackageAnalysisEntry(
+          packageName,
+          packagePath,
+          packageJsonHash,
+          issues,
+          analyzersRun
+        );
+        return ok({
+          ...cache,
+          packages: {
+            ...cache.packages,
+            [packageName]: entry
+          },
+          metadata: {
+            ...cache.metadata,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+      } catch (error) {
+        return err({
+          code: "CACHE_WRITE_FAILED",
+          message: `Failed to update cache for package ${packageName}: ${error.message}`,
+          cause: error
+        });
+      }
+    },
+    async clear() {
+      try {
+        await rm(cachePath, { recursive: true, force: true });
+        return ok(void 0);
+      } catch (error) {
+        return err({
+          code: "CACHE_WRITE_FAILED",
+          message: `Failed to clear cache: ${error.message}`,
+          cause: error
+        });
+      }
+    },
+    getStatistics(cache) {
+      const cachedFiles = Object.keys(cache.files).length;
+      const cachedPackages = Object.keys(cache.packages).length;
+      const ageMs = Date.now() - new Date(cache.metadata.createdAt).getTime();
+      const fileIssueCount = Object.values(cache.files).reduce((sum, f) => sum + f.issues.length, 0);
+      const packageIssueCount = Object.values(cache.packages).reduce(
+        (sum, p) => sum + p.issues.length,
+        0
+      );
+      const totalSizeBytes = (fileIssueCount + packageIssueCount) * 200 + cachedFiles * 100;
+      return {
+        cachedFiles,
+        cachedPackages,
+        totalSizeBytes,
+        ageMs,
+        hitCount: 0,
+        // Updated during analysis
+        missCount: 0,
+        // Updated during analysis
+        hitRate: 0
+        // Calculated: hitCount / (hitCount + missCount)
+      };
+    },
+    quickValidate(cache, configHash) {
+      if (cache.metadata.version !== CACHE_SCHEMA_VERSION) return false;
+      if (cache.metadata.workspacePath !== workspacePath) return false;
+      if (cache.metadata.analyzerVersion !== analyzerVersion) return false;
+      if (cache.metadata.configHash !== configHash) return false;
+      const cacheAge = Date.now() - new Date(cache.metadata.createdAt).getTime();
+      if (cacheAge > maxAge) return false;
+      return true;
+    }
+  };
+}
+function initializeCache(workspacePath, configHash, analyzerVersion) {
+  return createEmptyCache(workspacePath, configHash, analyzerVersion);
+}
+async function collectConfigFileStates(workspacePath, packagePaths) {
+  const hasher = createWorkspaceHasher();
+  const configFiles = [];
+  for (const pattern of CONFIG_FILE_PATTERNS) {
+    if (!pattern.includes("*")) {
+      const configPath = join(workspacePath, pattern);
+      try {
+        const stats = await stat(configPath);
+        const contentHash = await hasher.hash(configPath);
+        configFiles.push({
+          path: configPath,
+          contentHash,
+          modifiedAt: stats.mtime.toISOString(),
+          size: stats.size
+        });
+      } catch {
+      }
+    }
+  }
+  for (const pkgPath of packagePaths) {
+    const fullPkgPath = join(workspacePath, pkgPath);
+    for (const pattern of CONFIG_FILE_PATTERNS) {
+      if (!pattern.includes("*")) {
+        const configPath = join(fullPkgPath, pattern);
+        try {
+          const stats = await stat(configPath);
+          const contentHash = await hasher.hash(configPath);
+          configFiles.push({
+            path: configPath,
+            contentHash,
+            modifiedAt: stats.mtime.toISOString(),
+            size: stats.size
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  return configFiles;
+}
+
+// src/core/incremental-analyzer.ts
+import process from "process";
+import { pLimit } from "@bfra.me/es/async";
+import { consola } from "consola";
+var DEFAULT_INCREMENTAL_OPTIONS = {
+  useCache: true,
+  concurrency: 4,
+  maxCacheAge: 7 * 24 * 60 * 60 * 1e3,
+  // 7 days
+  minSeverity: "info",
+  cacheDir: ".workspace-analyzer-cache",
+  hashAlgorithm: "sha256"
+};
+function createIncrementalAnalyzer(options) {
+  const {
+    workspacePath,
+    analyzerVersion,
+    useCache = DEFAULT_INCREMENTAL_OPTIONS.useCache,
+    concurrency = DEFAULT_INCREMENTAL_OPTIONS.concurrency,
+    maxCacheAge = DEFAULT_INCREMENTAL_OPTIONS.maxCacheAge,
+    minSeverity = DEFAULT_INCREMENTAL_OPTIONS.minSeverity,
+    onProgress,
+    cacheDir = DEFAULT_INCREMENTAL_OPTIONS.cacheDir,
+    hashAlgorithm = DEFAULT_INCREMENTAL_OPTIONS.hashAlgorithm
+  } = options;
+  const hasher = createWorkspaceHasher({ algorithm: hashAlgorithm });
+  const cacheManager = createCacheManager({
+    workspacePath,
+    analyzerVersion,
+    cacheDir,
+    maxAge: maxCacheAge,
+    hashAlgorithm
+  });
+  const limit = pLimit(concurrency);
+  function reportProgress(phase, current, processed, total) {
+    onProgress?.({ phase, current, processed, total });
+  }
+  async function computeConfigHash(packagePaths) {
+    try {
+      const configFiles = await collectConfigFileStates(workspacePath, packagePaths);
+      const hashes = configFiles.map((f) => f.contentHash);
+      return hasher.hashContent(hashes.join(":"));
+    } catch {
+      return hasher.hashContent(Date.now().toString());
+    }
+  }
+  return {
+    async analyze(files, packages, analyzers) {
+      const startTime = Date.now();
+      let cache;
+      let validation;
+      let cacheUsed = false;
+      let hitCount = 0;
+      let missCount = 0;
+      const packagePaths = packages.map((p) => p.packagePath);
+      reportProgress("scanning", workspacePath, 0, files.length);
+      const configHash = await computeConfigHash(packagePaths);
+      if (useCache) {
+        const cacheResult = await cacheManager.load();
+        if (cacheResult.success && cacheManager.quickValidate(cacheResult.data, configHash)) {
+          cache = cacheResult.data;
+          validation = await cacheManager.validate(cache, files);
+          cacheUsed = true;
+        }
+      }
+      const filesToAnalyze = [];
+      const cachedFiles = [];
+      if (validation?.isValid && cache != null) {
+        for (const file of files) {
+          if (file in cache.files) {
+            cachedFiles.push(file);
+            hitCount++;
+          } else {
+            filesToAnalyze.push(file);
+            missCount++;
+          }
+        }
+      } else {
+        filesToAnalyze.push(...files);
+        missCount = files.length;
+        if (useCache) {
+          cache = initializeCache(workspacePath, configHash, analyzerVersion);
+          const configFiles = await collectConfigFileStates(workspacePath, packagePaths);
+          cache = { ...cache, configFiles };
+        }
+      }
+      reportProgress("parsing", "", 0, filesToAnalyze.length);
+      const allIssues = [];
+      if (cache != null) {
+        for (const file of cachedFiles) {
+          const cached = cache.files[file];
+          if (cached != null) {
+            allIssues.push(...cached.issues);
+          }
+        }
+        allIssues.push(...cache.workspaceIssues);
+      }
+      const analyzerContext = {
+        workspacePath,
+        packages,
+        config: {
+          minSeverity,
+          include: [],
+          exclude: []
+        },
+        reportProgress: (message) => {
+          reportProgress("analyzing", message, 0);
+        }
+      };
+      reportProgress("analyzing", "", 0, analyzers.length);
+      const analyzerResults = await Promise.all(
+        analyzers.map(
+          async (analyzer, index) => limit(async () => {
+            const analyzerId = analyzer.metadata.id;
+            reportProgress("analyzing", analyzerId, index + 1, analyzers.length);
+            try {
+              const result = await analyzer.analyze(analyzerContext);
+              return result;
+            } catch (error) {
+              const analyzerError = {
+                code: "ANALYZER_ERROR",
+                message: `Analyzer ${analyzerId} failed: ${error.message}`
+              };
+              return { success: false, error: analyzerError };
+            }
+          })
+        )
+      );
+      for (const result of analyzerResults) {
+        if (!result.success) {
+          consola.warn(`Analyzer error: ${result.error.message}`);
+          continue;
+        }
+        allIssues.push(...result.data);
+      }
+      const severityOrder = ["info", "warning", "error", "critical"];
+      const minSeverityIndex = severityOrder.indexOf(minSeverity);
+      const filteredIssues = allIssues.filter(
+        (issue) => severityOrder.indexOf(issue.severity) >= minSeverityIndex
+      );
+      if (useCache && cache != null) {
+        const issuesByFile = /* @__PURE__ */ new Map();
+        for (const issue of filteredIssues) {
+          const existing = issuesByFile.get(issue.location.filePath) ?? [];
+          existing.push(issue);
+          issuesByFile.set(issue.location.filePath, existing);
+        }
+        let updatedCache = cache;
+        for (const file of filesToAnalyze) {
+          const fileIssues = issuesByFile.get(file) ?? [];
+          const updateResult = await cacheManager.updateFile(
+            updatedCache,
+            file,
+            fileIssues,
+            analyzers.map((a) => a.metadata.id)
+          );
+          if (updateResult.success) {
+            updatedCache = updateResult.data;
+          }
+        }
+        reportProgress("reporting", "Saving cache", 0);
+        await cacheManager.save(updatedCache);
+      }
+      reportProgress("reporting", "", files.length, files.length);
+      const durationMs = Date.now() - startTime;
+      return ok({
+        issues: filteredIssues,
+        filesAnalyzed: filesToAnalyze.length,
+        filesFromCache: cachedFiles.length,
+        packagesAnalyzed: packagePaths.length,
+        durationMs,
+        cacheUsed,
+        cacheStats: cacheUsed ? {
+          hitRate: hitCount + missCount > 0 ? hitCount / (hitCount + missCount) : 0,
+          hitCount,
+          missCount
+        } : void 0
+      });
+    },
+    async invalidateFiles(paths) {
+      const cacheResult = await cacheManager.load();
+      if (!cacheResult.success) return;
+      const cache = cacheResult.data;
+      const updatedFiles = { ...cache.files };
+      for (const path of paths) {
+        delete updatedFiles[path];
+      }
+      await cacheManager.save({
+        ...cache,
+        files: updatedFiles
+      });
+    },
+    async clearCache() {
+      const result = await cacheManager.clear();
+      if (!result.success) {
+        return err({
+          code: "CACHE_ERROR",
+          message: result.error.message
+        });
+      }
+      return ok(void 0);
+    },
+    async getCacheStats() {
+      const cacheResult = await cacheManager.load();
+      if (!cacheResult.success) {
+        if (cacheResult.error.code === "CACHE_NOT_FOUND") {
+          return ok({ cachedFiles: 0, cachedPackages: 0, ageMs: 0 });
+        }
+        return err({
+          code: "CACHE_ERROR",
+          message: cacheResult.error.message
+        });
+      }
+      const stats = cacheManager.getStatistics(cacheResult.data);
+      return ok({
+        cachedFiles: stats.cachedFiles,
+        cachedPackages: stats.cachedPackages,
+        ageMs: stats.ageMs
+      });
+    }
+  };
+}
+function createConsoleProgressCallback() {
+  let lastPhase;
+  return (progress) => {
+    if (progress.phase !== lastPhase) {
+      lastPhase = progress.phase;
+      const phaseNames = {
+        scanning: "Scanning workspace",
+        parsing: "Parsing source files",
+        analyzing: "Running analyzers",
+        reporting: "Generating report"
+      };
+      console.error(`
+${phaseNames[progress.phase]}...`);
+    }
+    if (progress.total != null && progress.total > 0) {
+      const percent = Math.round(progress.processed / progress.total * 100);
+      process.stderr.write(`\r  ${progress.processed}/${progress.total} (${percent}%)`);
+    }
+  };
+}
+function createSilentProgressCallback() {
+  return () => {
+  };
+}
+
+// src/performance/bundle-estimator.ts
+import fs from "fs/promises";
+var DEFAULT_OPTIONS = {
+  includeNodeModules: false,
+  maxFiles: 1e4,
+  minificationRatio: 0.6,
+  gzipRatio: 0.3,
+  largeFileThreshold: 5e4,
+  largeDependencyThreshold: 1e5
+};
+var KNOWN_PACKAGE_SIZES = {
+  lodash: 71,
+  "lodash-es": 71,
+  moment: 67,
+  "moment-timezone": 95,
+  rxjs: 40,
+  "@angular/core": 90,
+  "@angular/common": 45,
+  react: 6,
+  "react-dom": 42,
+  vue: 34,
+  d3: 80,
+  "chart.js": 65,
+  three: 150,
+  "@mui/material": 120,
+  antd: 200,
+  "date-fns": 25,
+  dayjs: 3,
+  axios: 13,
+  zod: 12,
+  yup: 22,
+  "class-validator": 15,
+  typeorm: 180,
+  prisma: 40,
+  "@prisma/client": 40,
+  express: 30,
+  fastify: 25,
+  "ts-morph": 150,
+  typescript: 150
+};
+async function estimatePackageBundleSize(pkg, importResults, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const fileEstimates = [];
+  let totalSourceSize = 0;
+  let totalMinifiedSize = 0;
+  let totalGzippedSize = 0;
+  const filesToAnalyze = pkg.sourceFiles.slice(0, opts.maxFiles);
+  for (const filePath of filesToAnalyze) {
+    try {
+      const stats = await fs.stat(filePath);
+      const sourceSize = stats.size;
+      const fileImports = importResults.find((r) => r.filePath === filePath);
+      const importCount = fileImports?.imports.length ?? 0;
+      const estimate = createSizeEstimate(
+        filePath,
+        sourceSize,
+        importCount,
+        0,
+        false,
+        opts.minificationRatio,
+        opts.gzipRatio
+      );
+      fileEstimates.push(estimate);
+      totalSourceSize += sourceSize;
+      totalMinifiedSize += estimate.estimatedMinifiedSize;
+      totalGzippedSize += estimate.estimatedGzippedSize;
+    } catch {
+    }
+  }
+  const dependencyEstimates = collectDependencyEstimates(importResults, opts);
+  const topContributors = [...fileEstimates].sort((a, b) => b.sourceSize - a.sourceSize).slice(0, 10);
+  return {
+    packageName: pkg.name,
+    totalSourceSize,
+    totalMinifiedSize,
+    totalGzippedSize,
+    fileCount: fileEstimates.length,
+    files: fileEstimates,
+    dependencies: dependencyEstimates,
+    topContributors
+  };
+}
+async function estimateFileSize(filePath, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  try {
+    const stats = await fs.stat(filePath);
+    return createSizeEstimate(
+      filePath,
+      stats.size,
+      0,
+      0,
+      false,
+      opts.minificationRatio,
+      opts.gzipRatio
+    );
+  } catch {
+    return null;
+  }
+}
+function estimateDependencySize(packageName) {
+  const baseName = getBasePackageName(packageName);
+  const knownSize = KNOWN_PACKAGE_SIZES[baseName];
+  if (knownSize === void 0) {
+    return {
+      packageName,
+      estimatedSize: void 0,
+      sizeKnown: false,
+      importCount: 0,
+      locations: []
+    };
+  }
+  return {
+    packageName,
+    estimatedSize: knownSize * 1024,
+    sizeKnown: true,
+    importCount: 0,
+    locations: []
+  };
+}
+function findLargeFiles(stats, threshold) {
+  const actualThreshold = threshold ?? DEFAULT_OPTIONS.largeFileThreshold;
+  return stats.files.filter((file) => file.sourceSize > actualThreshold);
+}
+function findLargeDependencies(stats, threshold) {
+  const actualThreshold = threshold ?? DEFAULT_OPTIONS.largeDependencyThreshold;
+  return stats.dependencies.filter(
+    (dep) => dep.sizeKnown && dep.estimatedSize !== void 0 && dep.estimatedSize > actualThreshold
+  );
+}
+function estimateTreeShakingSavings(imports) {
+  let potentialSavings = 0;
+  const optimizableImports = [];
+  for (const imp of imports) {
+    if (imp.namespaceImport !== void 0) {
+      const baseName = getBasePackageName(imp.moduleSpecifier);
+      const knownSize = KNOWN_PACKAGE_SIZES[baseName];
+      if (knownSize !== void 0) {
+        const savings = Math.floor(knownSize * 1024 * 0.5);
+        potentialSavings += savings;
+        optimizableImports.push({
+          moduleSpecifier: imp.moduleSpecifier,
+          currentImportStyle: "namespace",
+          suggestedImportStyle: "named",
+          estimatedSavings: savings,
+          line: imp.line,
+          column: imp.column
+        });
+      }
+    }
+    if (imp.defaultImport !== void 0 && imp.importedNames === void 0) {
+      const baseName = getBasePackageName(imp.moduleSpecifier);
+      const knownSize = KNOWN_PACKAGE_SIZES[baseName];
+      if (knownSize !== void 0 && !imp.isRelative) {
+        const savings = Math.floor(knownSize * 1024 * 0.3);
+        potentialSavings += savings;
+        optimizableImports.push({
+          moduleSpecifier: imp.moduleSpecifier,
+          currentImportStyle: "default",
+          suggestedImportStyle: "named",
+          estimatedSavings: savings,
+          line: imp.line,
+          column: imp.column
+        });
+      }
+    }
+  }
+  return {
+    potentialSavings,
+    optimizableImports,
+    hasPotentialOptimizations: optimizableImports.length > 0
+  };
+}
+function createSizeEstimate(identifier, sourceSize, importCount, exportCount, isTransitive, minificationRatio, gzipRatio) {
+  const estimatedMinifiedSize = Math.floor(sourceSize * minificationRatio);
+  const estimatedGzippedSize = Math.floor(estimatedMinifiedSize * gzipRatio);
+  return {
+    identifier,
+    sourceSize,
+    estimatedMinifiedSize,
+    estimatedGzippedSize,
+    importCount,
+    exportCount,
+    isTransitive
+  };
+}
+function collectDependencyEstimates(importResults, _options) {
+  const depMap = /* @__PURE__ */ new Map();
+  for (const result of importResults) {
+    for (const dep of result.externalDependencies) {
+      const baseName = getBasePackageName(dep);
+      const existing = depMap.get(baseName);
+      if (existing === void 0) {
+        const knownSize = KNOWN_PACKAGE_SIZES[baseName];
+        const sizeKnown = knownSize !== void 0;
+        depMap.set(baseName, {
+          estimatedSize: sizeKnown ? knownSize * 1024 : void 0,
+          sizeKnown,
+          locations: [result.filePath]
+        });
+      } else {
+        existing.locations.push(result.filePath);
+      }
+    }
+  }
+  return Array.from(depMap.entries()).map(([packageName, data]) => ({
+    packageName,
+    estimatedSize: data.estimatedSize,
+    sizeKnown: data.sizeKnown,
+    importCount: data.locations.length,
+    locations: data.locations
+  }));
+}
+function getBasePackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / k ** i;
+  return `${size.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+export {
+  BUILTIN_ANALYZER_IDS,
+  BUILTIN_RULE_IDS,
+  CACHE_SCHEMA_VERSION,
+  CATEGORY_CONFIG,
+  CONFIG_FILE_PATTERNS,
+  DEFAULT_ANALYZER_CONFIG,
+  DEFAULT_CACHE_OPTIONS,
+  DEFAULT_CONCURRENCY,
+  DEFAULT_EXCLUDE_PATTERNS,
+  DEFAULT_INCLUDE_PATTERNS,
+  DEFAULT_INCREMENTAL_OPTIONS,
+  DEFAULT_LAYER_CONFIG,
+  DEFAULT_PACKAGE_PATTERNS,
+  DEFAULT_REPORT_OPTIONS,
+  DEFAULT_WORKSPACE_OPTIONS,
+  SEVERITY_CONFIG,
+  aggregatePackageImports,
+  analyzePackages,
+  analyzeWorkspace,
+  architecturalAnalyzerMetadata,
+  barrelExportRuleMetadata,
+  METADATA as buildConfigAnalyzerMetadata,
+  buildDependencyGraph,
+  builtinAnalyzers,
+  calculateSummary,
+  circularImportAnalyzerMetadata,
+  collectConfigFileStates,
+  computeCycleStats,
+  computeDeadCodeStats,
+  computeDuplicateStats,
+  computeGraphStatistics,
+  METADATA2 as configConsistencyAnalyzerMetadata,
+  createAnalysisChangeDetector,
+  createAnalyzerRegistry,
+  createArchitecturalAnalyzer,
+  createBarrelExportRule,
+  createBuildConfigAnalyzer,
+  createCacheManager,
+  createChangeDetector,
+  createCircularImportAnalyzer,
+  createConfigConsistencyAnalyzer,
+  createConsoleProgressCallback,
+  createConsoleReporter,
+  createDeadCodeAnalyzer,
+  createDefaultRegistry,
+  createDuplicateCodeAnalyzer,
+  createDuplicateDependencyAnalyzer,
+  createEmptyCache,
+  createEslintConfigAnalyzer,
+  createExportsFieldAnalyzer,
+  createFileAnalysisEntry,
+  createFileHasher,
+  createIncrementalAnalyzer,
+  createIssue,
+  createJsonReporter,
+  createLargeDependencyAnalyzer,
+  createLayerViolationRule,
+  createMarkdownReporter,
+  createOrchestrator,
+  createPackageAnalysisEntry,
+  createPackageBoundaryRule,
+  createPackageJsonAnalyzer,
+  createPathAliasRule,
+  createPeerDependencyAnalyzer,
+  createProject,
+  createPublicApiRule,
+  createRuleEngine,
+  createSideEffectRule,
+  createSilentProgressCallback,
+  createTreeShakingBlockerAnalyzer,
+  createTsconfigAnalyzer,
+  createUnusedDependencyAnalyzer,
+  createVersionAlignmentAnalyzer,
+  createWorkspaceHasher,
+  createWorkspaceScanner,
+  deadCodeAnalyzerMetadata,
+  defineConfig,
+  duplicateCodeAnalyzerMetadata,
+  duplicateDependencyAnalyzerMetadata,
+  err,
+  METADATA3 as eslintConfigAnalyzerMetadata,
+  estimateDependencySize,
+  estimateFileSize,
+  estimatePackageBundleSize,
+  estimateTreeShakingSavings,
+  METADATA4 as exportsFieldAnalyzerMetadata,
+  extractImports,
+  filterIssues,
+  filterIssuesForReport,
+  filterPackagesByPattern,
+  findConfigFile,
+  findCycles,
+  findLargeDependencies,
+  findLargeFiles,
+  flatMap,
+  formatBytes,
+  formatDuration,
+  formatLocation,
+  fromPromise,
+  fromThrowable,
+  generateCycleVisualization,
+  getAllDependencies,
+  getAllSourceFiles,
+  getAnalyzerOptions,
+  getDefaultConfig,
+  getFileLayer,
+  getKnownLargePackages,
+  getPackageInfo,
+  getPackageNameFromSpecifier,
+  getPackageScope,
+  getRelativePath,
+  getSourceFile,
+  getTransitiveDependencies,
+  getTransitiveDependents,
+  getUniqueDependencies,
+  getUnscopedName,
+  groupIssues,
+  groupPackagesByScope,
+  initializeCache,
+  isErr,
+  isJavaScriptFile,
+  isLayerImportAllowed,
+  isOk,
+  isRelativeImport,
+  isSourceFile,
+  isTypeScriptFile,
+  isWorkspacePackageImport,
+  largeDependencyAnalyzerMetadata,
+  layerViolationRuleMetadata,
+  loadConfig,
+  loadConfigFile,
+  map,
+  mapErr,
+  matchAnyPattern,
+  matchPattern,
+  meetsMinSeverity,
+  mergeAnalyzerConfigs,
+  mergeConfig,
+  normalizePath,
+  ok,
+  packageBoundaryRuleMetadata,
+  METADATA5 as packageJsonAnalyzerMetadata,
+  parsePackageJson,
+  parsePackageJsonContent,
+  parseSourceContent,
+  parseSourceFile,
+  parseSourceFiles,
+  parseTsConfig,
+  parseTsConfigContent,
+  parseWorkspaceAnalyzerConfig,
+  pathAliasRuleMetadata,
+  peerDependencyAnalyzerMetadata,
+  publicApiRuleMetadata,
+  resolveRelativeImport,
+  resolveTsConfigExtends,
+  safeParseAnalyzeOptions,
+  shouldAnalyzeCategory,
+  sideEffectRuleMetadata,
+  treeShakingBlockerAnalyzerMetadata,
+  truncateText,
+  METADATA6 as tsconfigAnalyzerMetadata,
+  unusedDependencyAnalyzerMetadata,
+  unwrap,
+  unwrapOr,
+  METADATA7 as versionAlignmentAnalyzerMetadata
+};
+//# sourceMappingURL=index.js.map