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

package/bin/perf-budgets-cli.js

@@ -1,39 +1,36 @@
 #!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { fileURLToPath } from 'node:url';
 
 import {
   collectPerfBudgets,
   generatePerfBudgetsHtml,
 } from '../dist/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.js';
 import { bundleAnalysisConfig } from '../dist/configs/bundle-analysis-config.js';
-import { isReactApp, logError, logInfo, logWarn } from './cli-utils.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const rootDir = path.resolve(__dirname, '../../..');
-const outputRootDir = path.resolve(__dirname, '../../../..');
-const appsDir = path.join(rootDir, 'manager/apps');
-const bundleAnalyzerBin = path.resolve(__dirname, '../node_modules/.bin/analyze');
-const perfBudgetsReportDirName = 'perf-budgets-reports';
-const perfBudgetCombinedJsonReportName = 'perf-budgets-combined-report.json';
-const perfBudgetCombinedHtmlReportName = 'perf-budgets-combined-report.html';
-
-// Shared packages that must always be built
-const sharedPackages = [
-  {
-    name: '@ovh-ux/manager-react-components',
-    folder: 'manager-react-components',
-    path: path.join(rootDir, 'packages/manager-react-components'),
-  },
-];
+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 given mode (html or json).
+ * 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 runBundleAnalyzer(appDirectory, appShortName, mode) {
+function runAppBundleAnalyzer(appDir, appShortName, mode) {
   const reportFile = `${bundleAnalysisConfig?.reportFile || 'bundle-report'}${
     mode === 'json' ? '.json' : '.html'
   }`;
@@ -50,306 +47,70 @@ function runBundleAnalyzer(appDirectory, appShortName, mode) {
     bundleAnalysisConfig?.reportFile || 'bundle-report',
   ];
 
-  const result = spawnSync(bundleAnalyzerBin, analyzerArgs, {
-    cwd: appDirectory,
-    stdio: 'inherit',
-    shell: true,
-  });
-
-  if (result.status !== 0) {
+  const ok = runCommand(bundleAnalyzerBinPath, analyzerArgs, appDir);
+  if (!ok) {
     logError(`❌ Analyzer (${mode}) failed for ${appShortName}`);
-    return;
+    return false;
   }
 
-  const distReport = path.join(appDirectory, 'dist', reportFile);
+  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 targetReport;
+    return true;
   } else {
     logWarn(`⚠️ Expected ${mode} report not found at ${distReport}`);
+    return false;
   }
 }
 
 /**
- * Build selected targets with Turbo.
- */
-function runTurboBuild(filters) {
-  if (filters.length === 0) {
-    logWarn('⚠️ No Turbo build filters provided, skipping build step.');
-    return;
-  }
-
-  const turboArgs = ['run', 'build', ...filters.flatMap((pkgName) => ['--filter', pkgName])];
-  logInfo(`Building with Turbo (filters: ${filters.join(', ')})`);
-
-  const buildResult = spawnSync('turbo', turboArgs, {
-    cwd: rootDir,
-    stdio: 'inherit',
-    shell: true,
-  });
-
-  if (buildResult.status !== 0) {
-    logWarn('⚠️ Turbo build failed for one or more targets. Will still try to analyze apps.');
-  }
-}
-
-/**
- * Analyze all given app folders.
- */
-function analyzeAppFolders(appFolders) {
-  const analyzed = [];
-  for (const appFolder of appFolders) {
-    try {
-      const appDir = path.join(appsDir, appFolder);
-      if (!fs.existsSync(appDir)) {
-        logError(`❌ App folder not found: ${appFolder} → skipping`);
-        continue;
-      }
-
-      const pkg = JSON.parse(fs.readFileSync(path.join(appDir, 'package.json'), 'utf-8'));
-      const appName = pkg.name;
-      const appShortName = appName.replace(/^@ovh-ux\//, '');
-
-      runBundleAnalyzer(appDir, appShortName, 'static');
-      runBundleAnalyzer(appDir, appShortName, 'json');
-
-      analyzed.push(appName);
-    } catch (err) {
-      logError(`❌ Failed to analyze ${appFolder}: ${err.message}`);
-    }
-  }
-  return analyzed;
-}
-
-/**
- * Remove old combined perf budget reports.
- */
-function removeOldCombinedReports() {
-  const combinedJsonPath = path.join(
-    outputRootDir,
-    perfBudgetsReportDirName,
-    perfBudgetCombinedJsonReportName,
-  );
-  const combinedHtmlPath = path.join(
-    outputRootDir,
-    perfBudgetsReportDirName,
-    perfBudgetCombinedHtmlReportName,
-  );
-
-  [combinedJsonPath, combinedHtmlPath].forEach((file) => {
-    if (fs.existsSync(file)) {
-      fs.unlinkSync(file);
-      logInfo(`🗑️ Removed old report: ${file}`);
-    }
-  });
-}
-
-/**
- * Collect budgets and regenerate combined reports.
- */
-function generateCombinedReports(root) {
-  removeOldCombinedReports();
-
-  const summary = collectPerfBudgets(root);
-
-  const combinedJsonPath = path.join(
-    root,
-    perfBudgetsReportDirName,
-    perfBudgetCombinedJsonReportName,
-  );
-  fs.writeFileSync(combinedJsonPath, JSON.stringify(summary, null, 2));
-  logInfo(`✅ Combined JSON report written to ${combinedJsonPath}`);
-
-  const combinedHtmlPath = path.join(
-    root,
-    perfBudgetsReportDirName,
-    perfBudgetCombinedHtmlReportName,
-  );
-  fs.writeFileSync(combinedHtmlPath, generatePerfBudgetsHtml(summary));
-  logInfo(`✅ Combined HTML report written to ${combinedHtmlPath}`);
-}
-
-/**
- * Guess app folder name from package name.
- * Example: @ovh-ux/manager-zimbra-app -> zimbra
- */
-function extractAppFolderFromPackageName(packageName) {
-  const match = packageName.match(/^@ovh-ux\/manager-(.+)-app$/);
-  if (!match) {
-    logError(`❌ Invalid package name format: ${packageName}`);
-    return null;
-  }
-  return match[1];
-}
-
-/**
- * Convert app folders to Turbo filters (package names).
- */
-function resolveTurboFiltersFromAppFolders(appFolders) {
-  return appFolders
-    .map((appFolder) => {
-      const pkgPath = path.join(appsDir, appFolder, 'package.json');
-      if (!fs.existsSync(pkgPath)) {
-        logError(`❌ No package.json for app folder ${appFolder}, skipping`);
-        return null;
-      }
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-      return pkg.name;
-    })
-    .filter(Boolean);
-}
-
-/**
- * Parse CLI arguments for `--apps` or `--app` flags.
- *
- * @returns {{appFolders: string[], packageNames: string[]} | null}
- *   An object with valid app folder names and an empty packageNames array,
- *   or null if the flag is not present.
- */
-function parseAppsArg() {
-  const appsArg = process.argv.find((arg) => arg === '--apps' || arg === '--app');
-  if (!appsArg) return null;
-
-  const index = process.argv.indexOf(appsArg);
-  const rawValue = process.argv[index + 1] || '';
-  const appFolders = rawValue
-    .split(',')
-    .map((n) => n.trim())
-    .filter(Boolean);
-
-  const validFolders = appFolders.filter((folder) => {
-    if (!fs.existsSync(path.join(appsDir, folder))) {
-      logError(`❌ App not found: ${folder} → skipping`);
-      return false;
-    }
-    return true;
-  });
-
-  logInfo(`Running in apps mode for: ${validFolders.join(', ')}`);
-  return { appFolders: validFolders, packageNames: [] };
-}
-
-/**
- * Parse CLI arguments for `--packages` or `--package` flags.
- *
- * @returns {{appFolders: string[], packageNames: string[]} | null}
- *   An object mapping package names to their corresponding app folders,
- *   or null if the flag is not present.
- */
-function parsePackagesArg() {
-  const packagesArg = process.argv.find((arg) => arg === '--packages' || arg === '--package');
-  if (!packagesArg) return null;
-
-  const index = process.argv.indexOf(packagesArg);
-  const rawValue = process.argv[index + 1] || '';
-  const packageNames = rawValue
-    .split(',')
-    .map((n) => n.trim())
-    .filter(Boolean);
-
-  const mappedFolders = [];
-  for (const pkgName of packageNames) {
-    const folder = extractAppFolderFromPackageName(pkgName);
-    if (folder && fs.existsSync(path.join(appsDir, folder))) {
-      mappedFolders.push(folder);
-    } else {
-      logError(`❌ Package ${pkgName} → app folder ${folder} not found, skipping`);
-    }
-  }
-
-  logInfo(
-    `Running in packages mode for: ${packageNames.join(', ')} → apps: ${mappedFolders.join(', ')}`,
-  );
-  return { appFolders: mappedFolders, packageNames };
-}
-
-/**
- * Discover all React apps automatically when no CLI flags are provided.
+ * Run perf budgets analysis for one app (both static + json).
  *
- * @returns {{appFolders: string[], packageNames: string[]}}
- *   An object containing discovered React app folders and an empty packageNames array.
+ * @param {string} appDir
+ * @param {string} appShortName
+ * @returns {boolean} True if at least one report succeeded
  */
-function discoverApps() {
-  const discoveredAppFolders = fs.readdirSync(appsDir).filter((dir) => {
-    const pkgPath = path.join(appsDir, dir, 'package.json');
-    return fs.existsSync(pkgPath) && isReactApp(pkgPath);
-  });
-
-  if (discoveredAppFolders.length === 0) {
-    logWarn('⚠️ No React apps found to analyze.');
-    return { appFolders: [], packageNames: [] };
-  }
-
-  logInfo(`Running in auto-discovery mode (${discoveredAppFolders.length} apps).`);
-  return { appFolders: discoveredAppFolders, packageNames: [] };
+function runAppPerfBudgets(appDir, appShortName) {
+  const okStatic = runAppBundleAnalyzer(appDir, appShortName, 'static');
+  const okJson = runAppBundleAnalyzer(appDir, appShortName, 'json');
+  return okStatic || okJson;
 }
 
 /**
- * Parse CLI arguments to resolve which apps or packages should be analyzed.
+ * Main CLI entrypoint for perf budgets analysis.
  *
- * Priority:
- *  1. Explicit `--apps`
- *  2. Explicit `--packages`
- *  3. Auto-discovery fallback
- *
- * @returns {{appFolders: string[], packageNames: string[]}}
- *   Object containing app folder names and package names for analysis.
- */
-function parseCliTargets() {
-  return parseAppsArg() || parsePackagesArg() || discoverApps();
-}
-
-/**
- * Resolve Turbo filters (package names) depending on mode.
- */
-function resolveTurboFilters({ appFolders, packageNames }) {
-  let filters = [];
-  if (appFolders.length > 0 && packageNames.length === 0) {
-    filters = resolveTurboFiltersFromAppFolders(appFolders);
-  } else if (packageNames.length > 0) {
-    filters = packageNames;
-  }
-
-  // Always include shared packages for build
-  for (const pkg of sharedPackages) {
-    if (fs.existsSync(pkg.path) && !filters.includes(pkg.name)) {
-      filters.push(pkg.name);
-      logInfo(`Including shared dependency in build: ${pkg.name}`);
-    }
-  }
-
-  return filters;
-}
-
-/**
- * Main CLI entrypoint.
+ * - 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 {
-    if (!fs.existsSync(bundleAnalyzerBin)) {
-      logError(`❌ Analyzer binary not found at ${bundleAnalyzerBin}`);
-      return;
-    }
+    ensureBinExists(bundleAnalyzerBinPath, 'vite-bundle-analyzer');
 
-    const { appFolders, packageNames } = parseCliTargets();
-    const turboFilters = resolveTurboFilters({ appFolders, packageNames });
+    const { appFolders, packageNames } = parseCliTargets(appsDir);
+    const turboFilters = resolveTurboFilters({ appsDir, appFolders, packageNames });
 
     // Step 1: build
-    runTurboBuild(turboFilters);
-
-    // Step 2: analyze
-    const analyzedApps = analyzeAppFolders(appFolders);
-
-    // Step 3: combined reports
-    if (analyzedApps.length > 0) {
-      generateCombinedReports(outputRootDir);
-    } else {
-      logError('❌ No apps successfully analyzed. Exiting.');
-      process.exit(1);
-    }
+    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);

package/bin/perf-budgets-tests-cli.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
-import process from 'node:process';
 
-import { logError, logInfo } from './cli-utils.js';
+import { logError, logInfo } from './utils/log-utils.js';
 
 // Define the set of validation test cases
 const cases = [
@@ -68,7 +67,6 @@ for (const test of cases) {
 
 if (failed > 0) {
   logError(`\n❌ ${failed} test(s) failed.`);
-  process.exit(1);
 } else {
   logInfo('\n🎉 All perf-budgets CLI validation tests passed!');
 }

package/bin/static-dynamic-quality-checks.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import process from 'node:process';
+
+import { outputRootDir } from './cli-path-config.js';
+
+const qualityCheckEntryFile = resolve(outputRootDir, 'index.html');
+
+const isTests = process.argv.includes('--tests');
+
+const mainScripts = [
+  'manager-code-duplication',
+  'manager-types-coverage',
+  'manager-tests-coverage',
+  'manager-perf-budgets',
+];
+
+const testScripts = [
+  'manager-code-duplication-tests',
+  'manager-types-coverage-tests',
+  'manager-tests-coverage-tests',
+  'manager-perf-budgets-tests',
+];
+
+const scripts = isTests ? testScripts : mainScripts;
+
+const reports = [
+  {
+    name: `Code Duplication${isTests ? ' (Tests)' : ''}`,
+    folder: 'code-duplication-reports',
+    base: 'code-duplication-combined-report',
+  },
+  {
+    name: `Performance Budgets${isTests ? ' (Tests)' : ''}`,
+    folder: 'perf-budgets-reports',
+    base: 'perf-budgets-combined-report',
+  },
+  {
+    name: `Tests Coverage${isTests ? ' (Tests)' : ''}`,
+    folder: 'tests-coverage-reports',
+    base: 'tests-coverage-combined-report',
+  },
+  {
+    name: `Types Coverage${isTests ? ' (Tests)' : ''}`,
+    folder: 'types-coverage-reports',
+    base: 'types-coverage-combined-report',
+  },
+];
+
+console.log(`🚀 Running static & dynamic quality ${isTests ? 'tests' : 'checks'}...\n`);
+
+let remaining = scripts.length;
+let failed = false;
+const statuses = {};
+
+function generateEntryReport() {
+  const links = reports
+    .map((report) => {
+      const status = statuses[report.name] ?? 'unknown';
+      const badge =
+        status === 'success'
+          ? '<span class="badge success">✅ Success</span>'
+          : status === 'fail'
+            ? '<span class="badge fail">❌ Failed</span>'
+            : '<span class="badge unknown">❔ Unknown</span>';
+
+      return `
+        <li>
+          <strong>${report.name}</strong> ${badge}<br/>
+          <a href="./${report.folder}/${report.base}.html">📊 HTML Report</a> |
+          <a href="./${report.folder}/${report.base}.json">📄 JSON Report</a>
+        </li>`;
+    })
+    .join('\n');
+
+  const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Static & Dynamic Quality ${isTests ? 'Tests' : 'Checks'} Reports</title>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 2rem; background: #f9f9f9; color: #333; }
+    h1 { color: #2c3e50; }
+    p.note { font-size: 0.9rem; color: #666; margin-bottom: 1.5rem; }
+    ul { list-style-type: none; padding: 0; }
+    li { margin: 1rem 0; padding: 1rem; background: #fff; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+    a { text-decoration: none; margin-right: 1rem; }
+    .badge { padding: 0.2rem 0.6rem; border-radius: 6px; font-size: 0.85rem; margin-left: 0.5rem; }
+    .success { background: #2ecc71; color: #fff; }
+    .fail { background: #e74c3c; color: #fff; }
+    .unknown { background: #95a5a6; color: #fff; }
+  </style>
+</head>
+<body>
+  <h1>Static & Dynamic Quality ${isTests ? 'Tests' : 'Checks'} Reports</h1>
+  <p class="note">ℹ️ Status badges below reflect the <strong>script execution status</strong> (whether the CLI completed without error), <br/>not the actual content or results of the analysis.</p>
+  <ul>
+    ${links}
+  </ul>
+</body>
+</html>`;
+
+  writeFileSync(qualityCheckEntryFile, html, 'utf-8');
+  console.log(`📄 Entry report generated at ${qualityCheckEntryFile}`);
+}
+
+scripts.forEach((cmd, idx) => {
+  const child = spawn(cmd, { stdio: 'inherit', shell: true });
+
+  child.on('exit', (code) => {
+    console.log(`\n${code === 0 ? '✅' : '❌'} ${cmd} finished with code ${code}`);
+    if (code === 0) {
+      statuses[reports[idx].name] = 'success';
+    } else {
+      statuses[reports[idx].name] = 'fail';
+      failed = true;
+    }
+    remaining -= 1;
+
+    if (remaining === 0) {
+      console.log(
+        failed
+          ? '\n⚠️ Some quality scripts failed, but reports will still be generated.'
+          : `\n🎉 All quality ${isTests ? 'tests' : 'checks'} completed successfully`,
+      );
+
+      try {
+        generateEntryReport();
+      } catch (err) {
+        console.error('❌ Failed to generate entry report:', err);
+      }
+
+      process.exit(failed ? 1 : 0);
+    }
+  });
+});

package/bin/tests-coverage-cli-tests.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+
+import { logError, logInfo } from './utils/log-utils.js';
+
+const cases = [
+  // Debug only — very slow, runs across all apps
+  // { name: 'Auto-discovery (all apps)', cmd: 'yarn manager-tests-coverage', expect: 0 },
+
+  { name: 'Single app (zimbra)', cmd: 'yarn manager-tests-coverage --app zimbra', expect: 0 },
+  {
+    name: 'Multiple apps (container,zimbra,web-ongoing-operations,key-management-service)',
+    cmd: 'yarn manager-tests-coverage --apps container,zimbra,web-ongoing-operations,key-management-service',
+    expect: 0,
+  },
+  {
+    name: 'Single package (container)',
+    cmd: 'yarn manager-tests-coverage --package @ovh-ux/manager-container-app',
+    expect: 0,
+  },
+  {
+    name: 'Multiple packages (zimbra,pci-workflow)',
+    cmd: 'yarn manager-tests-coverage --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-pci-workflow-app',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid apps',
+    cmd: 'yarn manager-tests-coverage --apps zimbra,unknown-app,container',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid packages',
+    cmd: 'yarn manager-tests-coverage --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-ghost-app',
+    expect: 0,
+  },
+  {
+    name: 'All invalid apps',
+    cmd: 'yarn manager-tests-coverage --apps doesnotexist1,doesnotexist2',
+    expect: 1,
+  },
+  {
+    name: 'All invalid packages',
+    cmd: 'yarn manager-tests-coverage --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 tests-coverage CLI validation tests passed!');
+}