@bfra.me/workspace-analyzer 0.1.0

package/src/analyzers/exports-field-analyzer.ts

@@ -0,0 +1,324 @@
+/**
+ * ExportsFieldAnalyzer - Validates package.json exports against actual source structure.
+ *
+ * Detects issues such as:
+ * - Exports pointing to non-existent files
+ * - Missing exports for existing source files
+ * - Invalid export conditions
+ * - Inconsistent export patterns
+ */
+
+import type {ParsedPackageJson} from '../parser/config-parser'
+import type {WorkspacePackage} from '../scanner/workspace-scanner'
+import type {Issue, IssueLocation} from '../types/index'
+import type {Result} from '../types/result'
+import type {AnalysisContext, Analyzer, AnalyzerError, AnalyzerMetadata} from './analyzer'
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import {ok} from '@bfra.me/es/result'
+
+import {createIssue, filterIssues} from './analyzer'
+
+/**
+ * Configuration options specific to ExportsFieldAnalyzer.
+ */
+export interface ExportsFieldAnalyzerOptions {
+  /** Whether to check if export paths resolve to existing files */
+  readonly validatePaths?: boolean
+  /** Whether to check export condition order */
+  readonly checkConditionOrder?: boolean
+  /** Whether to suggest missing exports for source files */
+  readonly suggestMissingExports?: boolean
+  /** Common output directories to check for built files */
+  readonly outputDirs?: readonly string[]
+  /** Package names exempt from checks */
+  readonly exemptPackages?: readonly string[]
+}
+
+const DEFAULT_OPTIONS: ExportsFieldAnalyzerOptions = {
+  validatePaths: true,
+  checkConditionOrder: true,
+  suggestMissingExports: false,
+  outputDirs: ['lib', 'dist', 'build', 'out'],
+  exemptPackages: [],
+}
+
+const METADATA: AnalyzerMetadata = {
+  id: 'exports-field',
+  name: 'Exports Field Analyzer',
+  description: 'Validates package.json exports against actual source file structure',
+  categories: ['configuration'],
+  defaultSeverity: 'warning',
+}
+
+/**
+ * Standard export conditions in recommended order.
+ */
+const CONDITION_ORDER = ['types', 'import', 'require', 'default'] as const
+
+/**
+ * Creates an ExportsFieldAnalyzer instance.
+ */
+export function createExportsFieldAnalyzer(options: ExportsFieldAnalyzerOptions = {}): Analyzer {
+  const resolvedOptions = {...DEFAULT_OPTIONS, ...options}
+
+  return {
+    metadata: METADATA,
+    analyze: async (context: AnalysisContext): Promise<Result<readonly Issue[], AnalyzerError>> => {
+      const issues: Issue[] = []
+
+      for (const pkg of context.packages) {
+        if (isExemptPackage(pkg.name, resolvedOptions.exemptPackages)) {
+          continue
+        }
+
+        const pkgJson = pkg.packageJson as ParsedPackageJson
+
+        if (pkgJson.exports === undefined) {
+          continue
+        }
+
+        const packageIssues = await analyzePackageExports(pkg, pkgJson, resolvedOptions)
+        issues.push(...packageIssues)
+      }
+
+      return ok(filterIssues(issues, context.config))
+    },
+  }
+}
+
+function isExemptPackage(name: string, exemptPackages: readonly string[] | undefined): boolean {
+  return exemptPackages?.includes(name) ?? false
+}
+
+function createLocation(filePath: string): IssueLocation {
+  return {filePath}
+}
+
+async function analyzePackageExports(
+  pkg: WorkspacePackage,
+  pkgJson: ParsedPackageJson,
+  options: ExportsFieldAnalyzerOptions,
+): Promise<Issue[]> {
+  const issues: Issue[] = []
+  const exports = pkgJson.exports
+
+  if (exports === undefined) {
+    return issues
+  }
+
+  // Analyze each export entry
+  const exportEntries = normalizeExports(exports)
+
+  for (const [exportPath, conditions] of exportEntries) {
+    // Check condition order
+    if (options.checkConditionOrder && typeof conditions === 'object' && conditions !== null) {
+      const orderIssues = checkConditionOrder(
+        pkg,
+        exportPath,
+        conditions as Record<string, unknown>,
+      )
+      issues.push(...orderIssues)
+    }
+
+    // Validate export paths
+    if (options.validatePaths) {
+      const pathIssues = await validateExportPaths(pkg, exportPath, conditions, options)
+      issues.push(...pathIssues)
+    }
+  }
+
+  // Check for package.json export (required for many tools)
+  issues.push(...checkPackageJsonExport(pkg, exports))
+
+  return issues
+}
+
+/**
+ * Normalizes exports to a consistent Map format.
+ */
+function normalizeExports(exports: Record<string, unknown>): Map<string, unknown> {
+  const normalized = new Map<string, unknown>()
+
+  for (const [key, value] of Object.entries(exports)) {
+    normalized.set(key, value)
+  }
+
+  return normalized
+}
+
+/**
+ * Checks if export conditions are in the recommended order.
+ */
+function checkConditionOrder(
+  pkg: WorkspacePackage,
+  exportPath: string,
+  conditions: Record<string, unknown>,
+): Issue[] {
+  const issues: Issue[] = []
+  const conditionKeys = Object.keys(conditions)
+
+  // Find the positions of standard conditions
+  const positions = new Map<string, number>()
+  for (const [index, key] of conditionKeys.entries()) {
+    if ((CONDITION_ORDER as readonly string[]).includes(key)) {
+      positions.set(key, index)
+    }
+  }
+
+  // Check if types comes before import/require
+  const typesPos = positions.get('types')
+  const importPos = positions.get('import')
+  const requirePos = positions.get('require')
+
+  if (typesPos !== undefined) {
+    if (importPos !== undefined && typesPos > importPos) {
+      issues.push(
+        createIssue({
+          id: 'exports-types-after-import',
+          title: 'Export types condition should come before import',
+          description: `Package "${pkg.name}" export "${exportPath}" has "types" after "import" condition`,
+          severity: 'warning',
+          category: 'configuration',
+          location: createLocation(pkg.packageJsonPath),
+          suggestion: 'Move "types" condition before "import" for proper TypeScript resolution',
+          metadata: {exportPath, conditions: conditionKeys},
+        }),
+      )
+    }
+
+    if (requirePos !== undefined && typesPos > requirePos) {
+      issues.push(
+        createIssue({
+          id: 'exports-types-after-require',
+          title: 'Export types condition should come before require',
+          description: `Package "${pkg.name}" export "${exportPath}" has "types" after "require" condition`,
+          severity: 'warning',
+          category: 'configuration',
+          location: createLocation(pkg.packageJsonPath),
+          suggestion: 'Move "types" condition before "require" for proper TypeScript resolution',
+          metadata: {exportPath, conditions: conditionKeys},
+        }),
+      )
+    }
+  }
+
+  return issues
+}
+
+/**
+ * Validates that export paths resolve to existing files.
+ */
+async function validateExportPaths(
+  pkg: WorkspacePackage,
+  exportPath: string,
+  conditions: unknown,
+  options: ExportsFieldAnalyzerOptions,
+): Promise<Issue[]> {
+  const issues: Issue[] = []
+
+  const paths = extractPaths(conditions)
+
+  for (const filePath of paths) {
+    // Skip non-file paths
+    if (!filePath.startsWith('./')) {
+      continue
+    }
+
+    const absolutePath = path.join(pkg.packagePath, filePath)
+    const exists = await fileExists(absolutePath)
+
+    if (!exists) {
+      // Check if this looks like a build output
+      const isBuildOutput = (options.outputDirs ?? []).some(dir => filePath.startsWith(`./${dir}/`))
+
+      if (isBuildOutput) {
+        // Build outputs might not exist yet - info level
+        issues.push(
+          createIssue({
+            id: 'exports-build-output-missing',
+            title: 'Export path points to non-existent build output',
+            description: `Package "${pkg.name}" export "${exportPath}" points to "${filePath}" which does not exist (may need build)`,
+            severity: 'info',
+            category: 'configuration',
+            location: createLocation(pkg.packageJsonPath),
+            suggestion: 'Run build to generate the file, or verify the path is correct',
+            metadata: {exportPath, filePath},
+          }),
+        )
+      } else {
+        // Source file missing - warning level
+        issues.push(
+          createIssue({
+            id: 'exports-path-missing',
+            title: 'Export path points to non-existent file',
+            description: `Package "${pkg.name}" export "${exportPath}" points to "${filePath}" which does not exist`,
+            severity: 'warning',
+            category: 'configuration',
+            location: createLocation(pkg.packageJsonPath),
+            suggestion: 'Verify the export path is correct or create the missing file',
+            metadata: {exportPath, filePath},
+          }),
+        )
+      }
+    }
+  }
+
+  return issues
+}
+
+/**
+ * Extracts all file paths from an export condition structure.
+ */
+function extractPaths(value: unknown): string[] {
+  const paths: string[] = []
+
+  if (typeof value === 'string') {
+    paths.push(value)
+  } else if (typeof value === 'object' && value !== null) {
+    for (const v of Object.values(value)) {
+      paths.push(...extractPaths(v))
+    }
+  }
+
+  return paths
+}
+
+/**
+ * Checks if package.json is exported (required by many tools).
+ */
+function checkPackageJsonExport(pkg: WorkspacePackage, exports: Record<string, unknown>): Issue[] {
+  const issues: Issue[] = []
+
+  const hasPackageJsonExport =
+    exports['./package.json'] !== undefined || exports['./package.json'] === './package.json'
+
+  if (!hasPackageJsonExport) {
+    issues.push(
+      createIssue({
+        id: 'exports-no-package-json',
+        title: 'Missing package.json export',
+        description: `Package "${pkg.name}" does not export "./package.json"`,
+        severity: 'info',
+        category: 'configuration',
+        location: createLocation(pkg.packageJsonPath),
+        suggestion: 'Add "./package.json": "./package.json" to exports for tool compatibility',
+      }),
+    )
+  }
+
+  return issues
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export {METADATA as exportsFieldAnalyzerMetadata}

package/src/analyzers/index.ts

@@ -0,0 +1,388 @@
+/**
+ * Analyzer registry and exports for workspace analysis.
+ *
+ * Provides a plugin architecture for registering and managing analyzers,
+ * with built-in analyzers for configuration validation and dependency analysis.
+ */
+
+import type {Analyzer, AnalyzerRegistration} from './analyzer'
+
+import {createArchitecturalAnalyzer} from './architectural-analyzer'
+import {createBuildConfigAnalyzer} from './build-config-analyzer'
+import {createCircularImportAnalyzer} from './circular-import-analyzer'
+import {createConfigConsistencyAnalyzer} from './config-consistency-analyzer'
+import {createDeadCodeAnalyzer} from './dead-code-analyzer'
+import {createDuplicateCodeAnalyzer} from './duplicate-code-analyzer'
+import {createDuplicateDependencyAnalyzer} from './duplicate-dependency-analyzer'
+import {createEslintConfigAnalyzer} from './eslint-config-analyzer'
+import {createExportsFieldAnalyzer} from './exports-field-analyzer'
+import {createLargeDependencyAnalyzer} from './large-dependency-analyzer'
+import {createPackageJsonAnalyzer} from './package-json-analyzer'
+import {createPeerDependencyAnalyzer} from './peer-dependency-analyzer'
+import {createTreeShakingBlockerAnalyzer} from './tree-shaking-analyzer'
+import {createTsconfigAnalyzer} from './tsconfig-analyzer'
+import {createUnusedDependencyAnalyzer} from './unused-dependency-analyzer'
+import {createVersionAlignmentAnalyzer} from './version-alignment-analyzer'
+
+export type {
+  AnalysisContext,
+  Analyzer,
+  AnalyzerError,
+  AnalyzerFactory,
+  AnalyzerMetadata,
+  AnalyzerOptions,
+  AnalyzerRegistration,
+} from './analyzer'
+export {createIssue, filterIssues, meetsMinSeverity, shouldAnalyzeCategory} from './analyzer'
+
+export type {ArchitecturalAnalyzerOptions} from './architectural-analyzer'
+export {architecturalAnalyzerMetadata, createArchitecturalAnalyzer} from './architectural-analyzer'
+
+export type {BuildConfigAnalyzerOptions} from './build-config-analyzer'
+export {buildConfigAnalyzerMetadata, createBuildConfigAnalyzer} from './build-config-analyzer'
+
+// Dependency analysis exports
+export type {CircularImportAnalyzerOptions} from './circular-import-analyzer'
+export {
+  circularImportAnalyzerMetadata,
+  computeCycleStats,
+  createCircularImportAnalyzer,
+  generateCycleVisualization,
+} from './circular-import-analyzer'
+
+export type {
+  CircularImportStats,
+  CycleEdge,
+  CycleNode,
+  CycleVisualization,
+} from './circular-import-analyzer'
+export type {ConfigConsistencyAnalyzerOptions} from './config-consistency-analyzer'
+
+export {
+  configConsistencyAnalyzerMetadata,
+  createConfigConsistencyAnalyzer,
+} from './config-consistency-analyzer'
+
+// Performance analysis exports (Phase 6)
+export type {DeadCodeAnalyzerOptions, DeadCodeStats, ExportedSymbol} from './dead-code-analyzer'
+export {
+  computeDeadCodeStats,
+  createDeadCodeAnalyzer,
+  deadCodeAnalyzerMetadata,
+} from './dead-code-analyzer'
+
+export type {
+  CodeFingerprint,
+  DuplicateCodeAnalyzerOptions,
+  DuplicatePattern,
+} from './duplicate-code-analyzer'
+export {createDuplicateCodeAnalyzer, duplicateCodeAnalyzerMetadata} from './duplicate-code-analyzer'
+
+export type {DuplicateDependencyAnalyzerOptions} from './duplicate-dependency-analyzer'
+
+export {
+  computeDuplicateStats,
+  createDuplicateDependencyAnalyzer,
+  duplicateDependencyAnalyzerMetadata,
+} from './duplicate-dependency-analyzer'
+export type {DuplicateDependencyStats} from './duplicate-dependency-analyzer'
+
+export type {EslintConfigAnalyzerOptions} from './eslint-config-analyzer'
+export {createEslintConfigAnalyzer, eslintConfigAnalyzerMetadata} from './eslint-config-analyzer'
+
+export type {ExportsFieldAnalyzerOptions} from './exports-field-analyzer'
+export {createExportsFieldAnalyzer, exportsFieldAnalyzerMetadata} from './exports-field-analyzer'
+
+export type {LargeDependencyAnalyzerOptions} from './large-dependency-analyzer'
+export {
+  createLargeDependencyAnalyzer,
+  getKnownLargePackages,
+  getPackageInfo,
+  largeDependencyAnalyzerMetadata,
+} from './large-dependency-analyzer'
+
+export type {PackageJsonAnalyzerOptions} from './package-json-analyzer'
+export {createPackageJsonAnalyzer, packageJsonAnalyzerMetadata} from './package-json-analyzer'
+export type {PeerDependencyAnalyzerOptions} from './peer-dependency-analyzer'
+
+export {
+  createPeerDependencyAnalyzer,
+  peerDependencyAnalyzerMetadata,
+} from './peer-dependency-analyzer'
+
+export type {
+  TreeShakingBlocker,
+  TreeShakingBlockerAnalyzerOptions,
+  TreeShakingBlockerType,
+} from './tree-shaking-analyzer'
+export {
+  createTreeShakingBlockerAnalyzer,
+  treeShakingBlockerAnalyzerMetadata,
+} from './tree-shaking-analyzer'
+
+export type {TsconfigAnalyzerOptions} from './tsconfig-analyzer'
+
+export {createTsconfigAnalyzer, tsconfigAnalyzerMetadata} from './tsconfig-analyzer'
+export type {UnusedDependencyAnalyzerOptions} from './unused-dependency-analyzer'
+
+export {
+  aggregatePackageImports,
+  createUnusedDependencyAnalyzer,
+  unusedDependencyAnalyzerMetadata,
+} from './unused-dependency-analyzer'
+export type {VersionAlignmentAnalyzerOptions} from './version-alignment-analyzer'
+export {
+  createVersionAlignmentAnalyzer,
+  versionAlignmentAnalyzerMetadata,
+} from './version-alignment-analyzer'
+
+/**
+ * Registry for managing analyzer registrations.
+ */
+export interface AnalyzerRegistry {
+  /** Register an analyzer */
+  readonly register: (id: string, registration: AnalyzerRegistration) => void
+  /** Unregister an analyzer */
+  readonly unregister: (id: string) => boolean
+  /** Get a registered analyzer */
+  readonly get: (id: string) => AnalyzerRegistration | undefined
+  /** Get all registered analyzers */
+  readonly getAll: () => Map<string, AnalyzerRegistration>
+  /** Get enabled analyzers sorted by priority */
+  readonly getEnabled: () => Analyzer[]
+  /** Check if an analyzer is registered */
+  readonly has: (id: string) => boolean
+}
+
+/**
+ * Creates a new analyzer registry.
+ *
+ * @example
+ * ```ts
+ * const registry = createAnalyzerRegistry()
+ *
+ * // Register a custom analyzer
+ * registry.register('my-analyzer', {
+ *   analyzer: createMyAnalyzer(),
+ *   enabled: true,
+ *   priority: 50,
+ * })
+ *
+ * // Get all enabled analyzers
+ * const analyzers = registry.getEnabled()
+ * ```
+ */
+export function createAnalyzerRegistry(): AnalyzerRegistry {
+  const registrations = new Map<string, AnalyzerRegistration>()
+
+  function resolveAnalyzer(registration: AnalyzerRegistration): Analyzer {
+    if (typeof registration.analyzer === 'function') {
+      return registration.analyzer()
+    }
+    return registration.analyzer
+  }
+
+  return {
+    register(id: string, registration: AnalyzerRegistration): void {
+      registrations.set(id, registration)
+    },
+
+    unregister(id: string): boolean {
+      return registrations.delete(id)
+    },
+
+    get(id: string): AnalyzerRegistration | undefined {
+      return registrations.get(id)
+    },
+
+    getAll(): Map<string, AnalyzerRegistration> {
+      return new Map(registrations)
+    },
+
+    getEnabled(): Analyzer[] {
+      const enabled = Array.from(registrations.entries())
+        .filter(([_id, reg]) => reg.enabled)
+        .sort((a, b) => a[1].priority - b[1].priority)
+        .map(([_id, reg]) => resolveAnalyzer(reg))
+
+      return enabled
+    },
+
+    has(id: string): boolean {
+      return registrations.has(id)
+    },
+  }
+}
+
+/**
+ * Built-in analyzer IDs.
+ */
+export const BUILTIN_ANALYZER_IDS = {
+  PACKAGE_JSON: 'package-json',
+  TSCONFIG: 'tsconfig',
+  ESLINT_CONFIG: 'eslint-config',
+  BUILD_CONFIG: 'build-config',
+  CONFIG_CONSISTENCY: 'config-consistency',
+  VERSION_ALIGNMENT: 'version-alignment',
+  EXPORTS_FIELD: 'exports-field',
+  // Dependency analyzers
+  UNUSED_DEPENDENCY: 'unused-dependency',
+  CIRCULAR_IMPORT: 'circular-import',
+  PEER_DEPENDENCY: 'peer-dependency',
+  DUPLICATE_DEPENDENCY: 'duplicate-dependency',
+  // Architectural analyzer
+  ARCHITECTURAL: 'architectural',
+  // Performance analyzers (Phase 6)
+  DEAD_CODE: 'dead-code',
+  DUPLICATE_CODE: 'duplicate-code',
+  LARGE_DEPENDENCY: 'large-dependency',
+  TREE_SHAKING_BLOCKER: 'tree-shaking-blocker',
+} as const
+
+/**
+ * Creates a registry with all built-in analyzers registered.
+ *
+ * @example
+ * ```ts
+ * const registry = createDefaultRegistry()
+ *
+ * // Disable a specific analyzer
+ * const registration = registry.get('eslint-config')
+ * if (registration) {
+ *   registry.register('eslint-config', {...registration, enabled: false})
+ * }
+ *
+ * // Run enabled analyzers
+ * const analyzers = registry.getEnabled()
+ * ```
+ */
+export function createDefaultRegistry(): AnalyzerRegistry {
+  const registry = createAnalyzerRegistry()
+
+  // Register built-in analyzers with default priorities
+  registry.register(BUILTIN_ANALYZER_IDS.PACKAGE_JSON, {
+    analyzer: createPackageJsonAnalyzer(),
+    enabled: true,
+    priority: 10,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.TSCONFIG, {
+    analyzer: createTsconfigAnalyzer(),
+    enabled: true,
+    priority: 20,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.ESLINT_CONFIG, {
+    analyzer: createEslintConfigAnalyzer(),
+    enabled: true,
+    priority: 30,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.BUILD_CONFIG, {
+    analyzer: createBuildConfigAnalyzer(),
+    enabled: true,
+    priority: 40,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.CONFIG_CONSISTENCY, {
+    analyzer: createConfigConsistencyAnalyzer(),
+    enabled: true,
+    priority: 50,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.VERSION_ALIGNMENT, {
+    analyzer: createVersionAlignmentAnalyzer(),
+    enabled: true,
+    priority: 60,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.EXPORTS_FIELD, {
+    analyzer: createExportsFieldAnalyzer(),
+    enabled: true,
+    priority: 70,
+  })
+
+  // Dependency analyzers
+  registry.register(BUILTIN_ANALYZER_IDS.UNUSED_DEPENDENCY, {
+    analyzer: createUnusedDependencyAnalyzer(),
+    enabled: true,
+    priority: 80,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.CIRCULAR_IMPORT, {
+    analyzer: createCircularImportAnalyzer(),
+    enabled: true,
+    priority: 90,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.PEER_DEPENDENCY, {
+    analyzer: createPeerDependencyAnalyzer(),
+    enabled: true,
+    priority: 100,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.DUPLICATE_DEPENDENCY, {
+    analyzer: createDuplicateDependencyAnalyzer(),
+    enabled: true,
+    priority: 110,
+  })
+
+  // Architectural analyzer
+  registry.register(BUILTIN_ANALYZER_IDS.ARCHITECTURAL, {
+    analyzer: createArchitecturalAnalyzer(),
+    enabled: true,
+    priority: 120,
+  })
+
+  // Performance analyzers (Phase 6)
+  registry.register(BUILTIN_ANALYZER_IDS.DEAD_CODE, {
+    analyzer: createDeadCodeAnalyzer(),
+    enabled: true,
+    priority: 130,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.DUPLICATE_CODE, {
+    analyzer: createDuplicateCodeAnalyzer(),
+    enabled: true,
+    priority: 140,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.LARGE_DEPENDENCY, {
+    analyzer: createLargeDependencyAnalyzer(),
+    enabled: true,
+    priority: 150,
+  })
+
+  registry.register(BUILTIN_ANALYZER_IDS.TREE_SHAKING_BLOCKER, {
+    analyzer: createTreeShakingBlockerAnalyzer(),
+    enabled: true,
+    priority: 160,
+  })
+
+  return registry
+}
+
+/**
+ * All built-in analyzer factories for direct use.
+ */
+export const builtinAnalyzers = {
+  packageJson: createPackageJsonAnalyzer,
+  tsconfig: createTsconfigAnalyzer,
+  eslintConfig: createEslintConfigAnalyzer,
+  buildConfig: createBuildConfigAnalyzer,
+  configConsistency: createConfigConsistencyAnalyzer,
+  versionAlignment: createVersionAlignmentAnalyzer,
+  exportsField: createExportsFieldAnalyzer,
+  // Dependency analyzers
+  unusedDependency: createUnusedDependencyAnalyzer,
+  circularImport: createCircularImportAnalyzer,
+  peerDependency: createPeerDependencyAnalyzer,
+  duplicateDependency: createDuplicateDependencyAnalyzer,
+  // Architectural analyzer
+  architectural: createArchitecturalAnalyzer,
+  // Performance analyzers (Phase 6)
+  deadCode: createDeadCodeAnalyzer,
+  duplicateCode: createDuplicateCodeAnalyzer,
+  largeDependency: createLargeDependencyAnalyzer,
+  treeShakingBlocker: createTreeShakingBlockerAnalyzer,
+} as const