@ovh-ux/manager-static-analysis-kit 0.7.1 → 0.9.0

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.9.0](https://github.com/ovh/manager/compare/@ovh-ux/manager-static-analysis-kit@0.8.0...@ovh-ux/manager-static-analysis-kit@0.9.0) (2025-09-18)
+
+
+### Bug Fixes
+
+* md lint issues ([0d2fe8e](https://github.com/ovh/manager/commit/0d2fe8e49f3594f5abc9d8e6b306b0b71a065c6c)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+
+
+### Features
+
+* a11y and w3c unit tests expectations ([5a2d75d](https://github.com/ovh/manager/commit/5a2d75dba8a8877253871aa0a7c12dc2c79d1423)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+* code duplication analysis ([d431254](https://github.com/ovh/manager/commit/d4312543737541257185be6e54358dfb49285d51)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+* extend tests cases ([69ad98b](https://github.com/ovh/manager/commit/69ad98b3d02c615996f5c4ad9067a93a10b58ec4)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+* global unit tests coverage reports ([e11191a](https://github.com/ovh/manager/commit/e11191a24609d56e76fd3eacaeac79d4c3b1ab4a)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+* single html entry for all static and dynamic checks ([0556811](https://github.com/ovh/manager/commit/0556811b4f15ad3288f34b3ba8e468a1c9fee061)), closes [#MANAGER-18576](https://github.com/ovh/manager/issues/MANAGER-18576)
+* typeScript types coverage analysis ([65f7d2f](https://github.com/ovh/manager/commit/65f7d2f22e4c68aa897d135e11642cd26073846b)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+* update documentation ([316add2](https://github.com/ovh/manager/commit/316add2055f4a27a3446d5361ee26e0baadbf2b8)), closes [#MANAGER-17958](https://github.com/ovh/manager/issues/MANAGER-17958)
+
+
+
+
+
+# [0.8.0](https://github.com/ovh/manager/compare/@ovh-ux/manager-static-analysis-kit@0.7.1...@ovh-ux/manager-static-analysis-kit@0.8.0) (2025-09-11)
+
+
+### Bug Fixes
+
+* adjust folder naming conventions rules ([fc7f608](https://github.com/ovh/manager/commit/fc7f6083038831902657e58f24792c7847f42d9c)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* adjust thresholds ([bd950f1](https://github.com/ovh/manager/commit/bd950f1fb8e972475e9c0a26915470f4f2e29fd4)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* ci lint issues ([c7b389e](https://github.com/ovh/manager/commit/c7b389e552cc1478998ad6dd24eb5c59328751da)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* indentation issues ([f106dcf](https://github.com/ovh/manager/commit/f106dcf283eb453d97a5f575327f4bd7e8eb9ccb)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* perf budgets readme doc indentation ([00660ba](https://github.com/ovh/manager/commit/00660ba9c418757dfc25dbb92be2af0a6e3dfea6)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* readme doc indentation ([e54e5eb](https://github.com/ovh/manager/commit/e54e5eb4c0bda11f7dc1c9e41bde804664420939)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* static kit integration status ([9a49e4f](https://github.com/ovh/manager/commit/9a49e4f992311de0ec2ac2876720dc46202ed118)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+
+
+### Features
+
+* add new cli commands ([cfe81c2](https://github.com/ovh/manager/commit/cfe81c255885165fdfd12bb9ba6e0a81fc8f4d18)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* add safety check and testing scenarios cases ([04d9b74](https://github.com/ovh/manager/commit/04d9b747f84e7475eee267f5311bebcdb1a6749a)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* include shared in turbo build by default ([d006428](https://github.com/ovh/manager/commit/d0064281ef1a4c844fa574169fac17d2301e976b)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* integrate and configure bundle analysis ([514d424](https://github.com/ovh/manager/commit/514d4247b6b6e4b37379e64e5260636b5d1c7c4d)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* remove debug features ([7d1ac89](https://github.com/ovh/manager/commit/7d1ac892639831ace9a539d156775dbeeae19579)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+
+
+
+
+
 ## [0.7.1](https://github.com/ovh/manager/compare/@ovh-ux/manager-static-analysis-kit@0.7.0...@ovh-ux/manager-static-analysis-kit@0.7.1) (2025-08-14)
 
 

package/README.md

@@ -1,4 +1,4 @@
-# 🧪static-analysis-kit
+# 🧪 static-analysis-kit
 
 A modular, extensible, and future-ready toolkit for defining, adapting, and sharing static analysis rules across projects in the `manager` monorepo.
 
@@ -6,103 +6,93 @@ A modular, extensible, and future-ready toolkit for defining, adapting, and shar
 
 ## 🚀 What Is It?
 
-`static-analysis-kit` provides a unified platform for code quality, complexity, duplication, and architectural analysis. It separates semantic rule definitions from tool-specific integrations using a clean adapter-based architecture.
+`static-analysis-kit` provides a unified platform for **static & dynamic quality checks**: linting, duplication, type coverage, tests coverage, and performance budgets.
 
-It currently supports:
-- ESLint (flat config)
-- Madge (dependency graph & circular analysis)
-- JSCPD (code duplication detection)
-- Code Health Meter (complexity, Halstead, maintainability, SLOC, architecture)
+It separates semantic rule definitions from tool-specific integrations using a clean adapter-based architecture.
 
 ---
 
-## 🎯 Why We Built This
+## 📦 Tools Exposed by the Kit
 
-- Reuse rules across projects and tools
-- Avoid duplication of `.eslintrc`, `.prettierrc`, `.madgerc`, etc.
-- Standardize how we measure code health and enforce architectural boundaries
-- Enable safe and gradual migration to new tooling
+The kit currently provides:
 
----
+- **ESLint** (flat config, adapters for React, TS, a11y, imports, naming, Storybook, Tailwind, TanStack, Vitest)
+- **Code Duplication Reports** (`manager-code-duplication`)
+- **Performance Budgets** (`manager-perf-budgets`)
+- **Tests Coverage Reports** (`manager-tests-coverage`)
+- **Types Coverage Reports** (`manager-types-coverage`)
+- **W3C & A11Y Unit Tests Matchers** (`expect(container).toBeAccessible()`, `await expect(html).toBeValidHtml()`)
 
-## 🧱 Structure Overview
+Coming soon:
+- **Madge** (dependency graph & circular analysis)
+- **Code Health Meter** (complexity, Halstead, maintainability, SLOC)
 
-```
-static-analysis-kit/
-├── src/
-│   ├── code-analysis.ts               # Central entry point (exports adapters)
-│   ├── configs/                       # Tool-agnostic semantic rule definitions
-│   │   ├── complexity.ts
-│   │   ├── madge-options.ts
-│   │   └── jscpd-options.ts
-│   └── adapters/
-│       ├── eslint/                    # ESLint flat config + rules
-│       │   ├── config/
-│       │   │   └── eslint.config.ts
-│       │   └── rules/
-│       ├── madge/                     # Madge analysis adapter
-│       ├── jscpd/                     # JSCPD (duplication) adapter
-│       ├── prettier/                  # Optional: shared formatting config
-│       └── code-health-meter/         # Halstead, MI, Cyclomatic, SLOC
-```
+> Each tool has its own README inside the kit with full usage & configuration details.  
+> See:
+> - [Code Duplication](src/adapters/code-duplication/README.md)
+> - [Performance Budgets](src/adapters/perf-budgets/README.md)
+> - [Tests Coverage](src/adapters/tests-coverage/README.md)
+> - [Types Coverage](src/adapters/types-coverage/README.md)
+> - [HTML W3C Validation](src/adapters/html-w3c-validation/README.md)
+> - [HTML Accessibility Matcher](src/adapters/html-a11y-validation/README.md)
 
 ---
 
-## 🛠️ Usage in an App
-
-```ts
-// apps/zimbra/eslint.config.ts
-import { eslintConfig } from '@ovh-ux/manager-static-analysis-kit';
-
-export default [...eslintConfig];
-```
+## 🧑‍💻 Combined Quality Checks
 
-This will apply all enabled ESLint rule groups from the toolkit, using flat config format (ESLint v8+).
+The kit also provides a **single entrypoint** for running all static & dynamic quality checks in parallel:
 
-```ts
-// apps/zimbra/prettier.config.ts
-import { prettierConfig } from '@ovh-ux/manager-static-analysis-kit';
+```bash
+# Run all quality checks
+yarn manager-static-dynamic-quality-checks
 
-export default [...prettierConfig];
+# Run only tests-related checks
+yarn manager-static-dynamic-quality-checks --tests
 ```
 
----
+### Run by Type
 
-## 🧠 Design Principles
+You can also target subsets of checks:
 
-- **Composable**: Adapters are modular, rules are grouped by category
-- **Decoupled**: Semantic configs live separately from tool logic
-- **Pluggable**: Easy to add new tools (e.g. Biome, Oxlint)
-- **Testable**: Configs are plain TS, easy to mock and verify
+```bash
+yarn manager-code-duplication
+yarn manager-perf-budgets
+yarn manager-tests-coverage
+yarn manager-types-coverage
+```
 
 ---
 
-## 🔮 Future Flexibility
-
-This architecture is designed to easily accommodate:
-
-- `biome/` adapter (Rust-based formatter/linter)
-- `oxlint/` adapter (high-performance Rust linter)
-- `depcruise/`, `pmd/`, `stylelint/` or internal tools
+## 🧱 Structure Overview
 
-Each would follow the same adapter pattern and pull from shared `configs/` where applicable.
+```
+static-analysis-kit/
+├── src/
+│   ├── code-analysis.ts               # Central entry point (exports adapters)
+│   ├── configs/                       # Tool-agnostic semantic rule definitions
+│   └── adapters/                      # Tool integrations
+│       ├── eslint/                    
+│       ├── code-duplication/          # Duplication reports
+│       ├── perf-budgets/              # Performance analyzer
+│       ├── tests-coverage/            # Test coverage reports
+│       ├── types-coverage/            # TS coverage reports
+│       ├── madge/                     # Coming soon
+│       └── code-health-meter/         # Coming soon
+```
 
 ---
 
-## 🧑‍💻 Contributing
-
-If you’re adding a new rule or adapter:
+## 🧠 Design Principles
 
-1. Put semantic/shared config in `configs/` if reusable.
-2. Create a new adapter directory in `adapters/` (e.g., `eslint`, `madge`).
-3. Add a domain-specific config, transformer, or wrapper.
-4. Wire into `code-analysis.ts` as needed.
-5. Document your addition.
+- **Composable**: Adapters are modular, rules are grouped by category.
+- **Decoupled**: Semantic configs live separately from tool logic.
+- **Pluggable**: Easy to add new tools (e.g., Biome, Oxlint).
+- **CI/CD Ready**: All tools produce JSON + HTML reports for pipelines.
 
 ---
 
 ## 📬 Feedback Welcome
 
-The goal is to create a robust, composable, and organization-wide standard for static analysis.
+The goal is to create a **robust, composable, and organization-wide standard** for static analysis and dynamic quality checks.
 
-Feel free to suggest improvements or new integrations!
+Suggestions & contributions are welcome.  

package/bin/cli-path-config.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const rootDir = path.resolve(__dirname, '../../..');
+export const outputRootDir = path.resolve(__dirname, '../../../../static-dynamic-quality-reports');
+
+export const appsDir = path.join(rootDir, 'manager/apps');
+
+export const bundleAnalyzerBinPath = path.resolve(__dirname, '../node_modules/.bin/analyze');
+export const perfBudgetsReportDirName = 'perf-budgets-reports';
+export const perfBudgetCombinedJsonReportName = 'perf-budgets-combined-report.json';
+export const perfBudgetCombinedHtmlReportName = 'perf-budgets-combined-report.html';
+
+export const jscpdBinPath = path.resolve(__dirname, '../node_modules/.bin/jscpd');
+export const codeDupReportsRootDirName = 'code-duplication-reports';
+export const codeDupCombinedJsonReportName = 'code-duplication-combined-report.json';
+export const codeDupCombinedHtmlReportName = 'code-duplication-combined-report.html';
+
+export const testsCoverageReportsRootDirName = 'tests-coverage-reports';
+export const testsCoverageCombinedJsonReportName = 'tests-coverage-combined-report.json';
+export const testsCoverageCombinedHtmlReportName = 'tests-coverage-combined-report.html';
+
+export const tsTypesCoverageBin = path.resolve(
+  __dirname,
+  '../node_modules/.bin/typescript-coverage-report',
+);
+export const typesCoverageReportsRootDirName = 'types-coverage-reports';
+export const typesCoverageCombinedJsonReportName = 'types-coverage-combined-report.json';
+export const typesCoverageCombinedHtmlReportName = 'types-coverage-combined-report.html';

package/bin/code-duplication-cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import {
+  collectCodeDuplication,
+  generateCodeDuplicationHtml,
+} from '../dist/adapters/code-duplication/helpers/code-duplication-analysis-helper.js';
+import {
+  appsDir,
+  codeDupCombinedHtmlReportName,
+  codeDupCombinedJsonReportName,
+  codeDupReportsRootDirName,
+  jscpdBinPath,
+  outputRootDir,
+} from './cli-path-config.js';
+import { buildCodeDuplicationArgs, parseCliTargets } from './utils/args-parse-utils.js';
+import { logError, logInfo, logWarn } from './utils/log-utils.js';
+import { ensureBinExists, runAppsAnalysis, runCommand } from './utils/runner-utils.js';
+
+/**
+ * Run `jscpd` code duplication analysis for a single app.
+ *
+ * @param {string} appDir - Absolute path to the app’s root directory.
+ * @param {string} appShortName - Shortened app name (from package.json or folder).
+ * @returns {boolean} True if analysis completed successfully, false otherwise.
+ */
+function runAppCodeDuplication(appDir, appShortName) {
+  try {
+    const absoluteOutputDir = path.join(outputRootDir, codeDupReportsRootDirName, appShortName);
+    fs.mkdirSync(absoluteOutputDir, { recursive: true });
+
+    // Relative output path from the app dir (keeps paths clean inside HTML reports)
+    const relativeOutputDir = path.relative(appDir, absoluteOutputDir);
+
+    logInfo(`Running jscpd for ${appShortName} → ${absoluteOutputDir}`);
+
+    const args = [...buildCodeDuplicationArgs(relativeOutputDir), appDir];
+    const ok = runCommand(jscpdBinPath, args, appDir);
+
+    // Validate expected reports
+    const jsonReport = path.join(absoluteOutputDir, 'jscpd-report.json');
+    const htmlReport = path.join(absoluteOutputDir, 'html', 'index.html');
+
+    if (!fs.existsSync(jsonReport)) {
+      logWarn(`⚠️ Missing jscpd-report.json at ${jsonReport}`);
+    }
+    if (!fs.existsSync(htmlReport)) {
+      logWarn(`⚠️ Missing html/index.html at ${htmlReport}`);
+    }
+
+    return ok;
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main CLI entrypoint for code duplication analysis.
+ *
+ * - Ensures the `jscpd` binary is available
+ * - Resolves target app folders from CLI args
+ * - Runs per-app analysis via {@link runAppCodeDuplication}
+ * - Generates combined JSON + HTML reports across all apps
+ *
+ * Exits process with code `1` if no apps were analyzed successfully
+ * or if a fatal error occurred.
+ */
+function main() {
+  try {
+    ensureBinExists(jscpdBinPath, 'jscpd');
+
+    const { appFolders } = parseCliTargets(appsDir);
+
+    runAppsAnalysis({
+      appsDir,
+      appFolders,
+      requireReact: true,
+      binaryLabel: 'Code duplication',
+      appRunner: runAppCodeDuplication,
+      reportsRootDirName: codeDupReportsRootDirName,
+      combinedJson: codeDupCombinedJsonReportName,
+      combinedHtml: codeDupCombinedHtmlReportName,
+      collectFn: collectCodeDuplication,
+      generateHtmlFn: generateCodeDuplicationHtml,
+      outputRootDir,
+    });
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/code-duplication-tests-cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+
+import { logError, logInfo } from './utils/log-utils.js';
+
+// Define the set of validation test cases for code-duplication CLI
+const cases = [
+  // Debug only — very slow, runs across all apps
+  // { name: 'Auto-discovery (all apps)', cmd: 'yarn manager-code-duplication', expect: 0 },
+
+  { name: 'Single app (zimbra)', cmd: 'yarn manager-code-duplication --app zimbra', expect: 0 },
+  {
+    name: 'Multiple apps (container,zimbra,web-ongoing-operations,key-management-service)',
+    cmd: 'yarn manager-code-duplication --apps container,zimbra,web-ongoing-operations,key-management-service',
+    expect: 0,
+  },
+  {
+    name: 'Single package (container)',
+    cmd: 'yarn manager-code-duplication --package @ovh-ux/manager-container-app',
+    expect: 0,
+  },
+  {
+    name: 'Multiple packages (zimbra,pci-workflow)',
+    cmd: 'yarn manager-code-duplication --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-pci-workflow-app',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid apps',
+    cmd: 'yarn manager-code-duplication --apps zimbra,unknown-app,container',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid packages',
+    cmd: 'yarn manager-code-duplication --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-ghost-app',
+    expect: 0,
+  },
+  {
+    name: 'All invalid apps',
+    cmd: 'yarn manager-code-duplication --apps doesnotexist1,doesnotexist2',
+    expect: 1,
+  },
+  {
+    name: 'All invalid packages',
+    cmd: 'yarn manager-code-duplication --packages @ovh-ux/manager-ghost-app,@ovh-ux/manager-missing-app',
+    expect: 1,
+  },
+];
+
+let failed = 0;
+
+for (const test of cases) {
+  logInfo(`\n🔎 Running: ${test.name}`);
+  const [bin, ...args] = test.cmd.split(' ');
+  const result = spawnSync(bin, args, { stdio: 'inherit', shell: true });
+
+  if (result.status !== test.expect) {
+    logError(`❌ ${test.name} failed (expected exit ${test.expect}, got ${result.status})`);
+    failed++;
+  } else {
+    logInfo(`✅ ${test.name} passed`);
+  }
+}
+
+if (failed > 0) {
+  logError(`\n❌ ${failed} test(s) failed.`);
+} else {
+  logInfo('\n🎉 All code-duplication-tests CLI validation tests passed!');
+}

package/bin/lint-cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { spawn } from 'child_process';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { dirname, resolve, join } from 'path';
-import { cwd } from 'process';
-import { existsSync } from 'fs';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import process, { cwd } from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { logError, logInfo } from './utils/log-utils.js';
 
-// eslint-disable-next-line no-underscore-dangle
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const userCwd = cwd();
 const eslintBin = resolve(__dirname, '../node_modules/.bin/eslint');
@@ -13,11 +14,13 @@ const eslintBin = resolve(__dirname, '../node_modules/.bin/eslint');
 const args = process.argv.slice(2);
 const hasExplicitConfigArg = args.includes('--config');
 const localConfigPath = join(userCwd, 'eslint.config.ts');
-const sharedDefaultPath = resolve(__dirname, '../dist/adapters/eslint/config/eslint-shared-config.js');
+const sharedDefaultPath = resolve(
+  __dirname,
+  '../dist/adapters/eslint/config/eslint-shared-config.js',
+);
 const hasLocalConfig = existsSync(localConfigPath);
 
 // Determine effective config path
-// eslint-disable-next-line no-nested-ternary
 const configPath = hasExplicitConfigArg
   ? args[args.indexOf('--config') + 1]
   : hasLocalConfig
@@ -34,8 +37,8 @@ function runLint(command, args, cwd) {
     });
 
     child.on('error', (err) => {
-      console.error('[manager-lint] Failed to run ESLint');
-      console.error(err);
+      logError('[manager-lint] Failed to run ESLint');
+      logError(err);
       reject(1);
     });
 
@@ -52,20 +55,19 @@ function runLint(command, args, cwd) {
     try {
       const mod = await import(url);
       const configContent = mod.default ?? mod;
-      console.log('[manager-lint] Loaded ESLint config from:', configPath);
+      logInfo('[manager-lint] Loaded ESLint config from:', configPath);
       console.dir(configContent, { depth: null });
     } catch (err) {
-      console.error(`[manager-lint] Failed to load config at ${configPath}`);
-      console.error(err);
+      logError(`[manager-lint] Failed to load config at ${configPath}`);
+      logError(err);
       process.exit(1);
     }
     process.exit(0);
   }
 
   // Construct full args
-  const fullArgs = hasExplicitConfigArg || hasLocalConfig
-    ? args
-    : ['--config', sharedDefaultPath, ...args];
+  const fullArgs =
+    hasExplicitConfigArg || hasLocalConfig ? args : ['--config', sharedDefaultPath, ...args];
 
   // Run ESLint using tsx and wait for completion
   const exitCode = await runLint('tsx', [eslintBin, ...fullArgs], userCwd);

package/bin/perf-budgets-cli.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import {
+  collectPerfBudgets,
+  generatePerfBudgetsHtml,
+} from '../dist/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.js';
+import { bundleAnalysisConfig } from '../dist/configs/bundle-analysis-config.js';
+import {
+  appsDir,
+  bundleAnalyzerBinPath,
+  outputRootDir,
+  perfBudgetCombinedHtmlReportName,
+  perfBudgetCombinedJsonReportName,
+  perfBudgetsReportDirName,
+  rootDir,
+} from './cli-path-config.js';
+import { parseCliTargets } from './utils/args-parse-utils.js';
+import { logError, logInfo, logWarn } from './utils/log-utils.js';
+import { ensureBinExists, runAppsAnalysis, runCommand } from './utils/runner-utils.js';
+import { resolveTurboFilters, runTurboBuild } from './utils/turbo-utils.js';
+
+/**
+ * Run vite-bundle-analyzer for a given mode (html or json).
+ *
+ * @param {string} appDir - Absolute app directory
+ * @param {string} appShortName - Shortened app name
+ * @param {"static"|"json"} mode - Analyzer mode
+ * @returns {boolean} True if analyzer produced output, false otherwise
+ */
+function runAppBundleAnalyzer(appDir, appShortName, mode) {
+  const reportFile = `${bundleAnalysisConfig?.reportFile || 'bundle-report'}${
+    mode === 'json' ? '.json' : '.html'
+  }`;
+  const outputDir = path.join(outputRootDir, perfBudgetsReportDirName, appShortName);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  logInfo(`Running bundle analyzer (${mode}) for ${appShortName} → ${outputDir}`);
+
+  const analyzerArgs = [
+    '--mode',
+    mode,
+    '--no-open',
+    '--filename',
+    bundleAnalysisConfig?.reportFile || 'bundle-report',
+  ];
+
+  const ok = runCommand(bundleAnalyzerBinPath, analyzerArgs, appDir);
+  if (!ok) {
+    logError(`❌ Analyzer (${mode}) failed for ${appShortName}`);
+    return false;
+  }
+
+  const distReport = path.join(appDir, 'dist', reportFile);
+  const targetReport = path.join(outputDir, reportFile);
+
+  if (fs.existsSync(distReport)) {
+    fs.copyFileSync(distReport, targetReport);
+    logInfo(`✅ ${mode.toUpperCase()} report copied to ${targetReport}`);
+    return true;
+  } else {
+    logWarn(`⚠️ Expected ${mode} report not found at ${distReport}`);
+    return false;
+  }
+}
+
+/**
+ * Run perf budgets analysis for one app (both static + json).
+ *
+ * @param {string} appDir
+ * @param {string} appShortName
+ * @returns {boolean} True if at least one report succeeded
+ */
+function runAppPerfBudgets(appDir, appShortName) {
+  const okStatic = runAppBundleAnalyzer(appDir, appShortName, 'static');
+  const okJson = runAppBundleAnalyzer(appDir, appShortName, 'json');
+  return okStatic || okJson;
+}
+
+/**
+ * Main CLI entrypoint for perf budgets analysis.
+ *
+ * - Ensures analyzer binary is available
+ * - Runs a turbo build for the selected apps
+ * - Executes analyzer per app via {@link runAppPerfBudgets}
+ * - Generates combined JSON + HTML reports
+ */
+function main() {
+  try {
+    ensureBinExists(bundleAnalyzerBinPath, 'vite-bundle-analyzer');
+
+    const { appFolders, packageNames } = parseCliTargets(appsDir);
+    const turboFilters = resolveTurboFilters({ appsDir, appFolders, packageNames });
+
+    // Step 1: build
+    runTurboBuild(rootDir, turboFilters);
+
+    // Step 2: analyze apps + combined
+    runAppsAnalysis({
+      appsDir,
+      appFolders,
+      requireReact: false,
+      binaryLabel: 'Perf budgets',
+      appRunner: runAppPerfBudgets,
+      reportsRootDirName: perfBudgetsReportDirName,
+      combinedJson: perfBudgetCombinedJsonReportName,
+      combinedHtml: perfBudgetCombinedHtmlReportName,
+      collectFn: collectPerfBudgets,
+      generateHtmlFn: generatePerfBudgetsHtml,
+      outputRootDir,
+    });
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    process.exit(1);
+  }
+}
+
+main();