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

package/bin/utils/args-parse-utils.js

@@ -0,0 +1,222 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import { codeDuplicationConfig } from '../../dist/configs/code-duplication-config.js';
+import { typesCoverageConfig } from '../../dist/configs/types-coverage-config.js';
+import { isReactApp } from './apps-utils.js';
+import { logError, logInfo, logWarn } from './log-utils.js';
+
+/**
+ * Extract an app folder name from an OVH Manager package name.
+ *
+ * Example:
+ *   "@ovh-ux/manager-zimbra-app" → "zimbra"
+ *
+ * @param {string} packageName - Full npm package name.
+ * @returns {string|null} The extracted app folder name, or null if the format is invalid.
+ */
+function extractAppFolderFromPackageName(packageName) {
+  const match = packageName.match(/^@ovh-ux\/manager-(.+)-app$/);
+  if (!match) {
+    logError(`❌ Invalid package name format: ${packageName}`);
+    return null;
+  }
+  return match[1];
+}
+
+/**
+ * Parse CLI arguments for `--apps` or `--app` flags.
+ *
+ * Accepts a comma-separated list of app folder names. Example:
+ *   `--apps zimbra,web`
+ *
+ * @param {string} appsDir - Absolute path to the apps root directory.
+ * @returns {{appFolders: string[], packageNames: string[]} | null}
+ *   Object containing valid app folders and an empty `packageNames` array,
+ *   or null if no `--apps`/`--app` flag is provided.
+ */
+function parseAppsArg(appsDir) {
+  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.
+ *
+ * Accepts a comma-separated list of package names. Example:
+ *   `--packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-web-app`
+ *
+ * Each package name is mapped to its corresponding app folder.
+ *
+ * @param {string} appsDir - Absolute path to the apps root directory.
+ * @returns {{appFolders: string[], packageNames: string[]} | null}
+ *   Object mapping package names to discovered app folders,
+ *   or null if no `--packages`/`--package` flag is provided.
+ */
+function parsePackagesArg(appsDir) {
+  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 in the apps directory when no CLI flags are provided.
+ *
+ * Only apps that contain a `package.json` file and are identified as React apps
+ * (via `isReactApp`) will be included.
+ *
+ * @param {string} appsDir - Absolute path to the apps root directory.
+ * @returns {{appFolders: string[], packageNames: string[]}}
+ *   Object containing discovered app folders and an empty `packageNames` array.
+ */
+function discoverApps(appsDir) {
+  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: [] };
+}
+
+/**
+ * Parse CLI arguments to resolve which apps or packages should be analyzed.
+ *
+ * Priority order:
+ *  1. Explicit `--apps` flag
+ *  2. Explicit `--packages` flag
+ *  3. Auto-discovery fallback
+ *
+ * @param {string} appsDir - Absolute path to the apps root directory.
+ * @returns {{appFolders: string[], packageNames: string[]}}
+ *   Object containing app folder names and package names for analysis.
+ */
+export function parseCliTargets(appsDir) {
+  return parseAppsArg(appsDir) || parsePackagesArg(appsDir) || discoverApps(appsDir);
+}
+
+/**
+ * Build CLI arguments for `typescript-coverage-report` from config.
+ *
+ * @param {string} outputDir - Output directory for the report.
+ * @returns {string[]} Array of CLI arguments.
+ */
+export function buildTypesCoverageArgs(outputDir) {
+  const args = ['--outputDir', outputDir];
+
+  const mapping = {
+    threshold: '--threshold',
+    strict: '--strict',
+    debug: '--debug',
+    cache: '--cache',
+    project: '--project',
+    ignoreUnread: '--ignore-unread',
+  };
+
+  for (const [key, flag] of Object.entries(mapping)) {
+    const value = typesCoverageConfig[key];
+    if (value === undefined || value === false) continue;
+
+    if (typeof value === 'boolean') {
+      if (value) args.push(flag);
+    } else {
+      args.push(flag, String(value));
+    }
+  }
+
+  // Handle array options separately
+  if (Array.isArray(typesCoverageConfig.ignoreFiles)) {
+    for (const pattern of typesCoverageConfig.ignoreFiles) {
+      args.push('--ignore-files', pattern);
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Translate our config → jscpd CLI flags.
+ * @param {string} outputDir - output directory for jscpd reports
+ * @returns {string[]}
+ */
+export function buildCodeDuplicationArgs(outputDir) {
+  const cfg = codeDuplicationConfig;
+  const args = [
+    '--output',
+    outputDir,
+    '--reporters',
+    Array.isArray(cfg.reporters) ? cfg.reporters.join(',') : String(cfg.reporters || 'console'),
+    '--mode',
+    cfg.mode,
+    '--min-lines',
+    String(cfg.minLines),
+    '--min-tokens',
+    String(cfg.minTokens),
+    '--max-lines',
+    String(cfg.maxLines),
+    '--max-size',
+    String(cfg.maxSize),
+  ];
+
+  if (cfg.threshold !== null && cfg.threshold !== undefined) {
+    args.push('--threshold', String(cfg.threshold));
+  }
+  if (cfg.absolute) {
+    args.push('--absolute');
+  }
+  if (Array.isArray(cfg.formats) && cfg.formats.length > 0) {
+    args.push('--format', cfg.formats.join(','));
+  }
+  if (Array.isArray(cfg.ignore) && cfg.ignore.length > 0) {
+    // jscpd accepts comma-separated ignore globs
+    // https://github.com/kucherenko/jscpd/blob/master/apps/jscpd/README.md#ignore
+    args.push('--ignore', cfg.ignore.join(','));
+  }
+
+  return args;
+}

package/bin/utils/file-utils.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { logError, logInfo } from './log-utils.js';
+
+/**
+ * Safe JSON read.
+ */
+export function readJsonSafe(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove old combined report files (JSON & HTML).
+ */
+export function removeOldCombinedReports(root, dirName, jsonFile, htmlFile) {
+  const combinedJson = path.join(root, dirName, jsonFile);
+  const combinedHtml = path.join(root, dirName, htmlFile);
+
+  [combinedJson, combinedHtml].forEach((file) => {
+    if (fs.existsSync(file)) {
+      fs.rmSync(file, { force: true });
+      logInfo(`🧹 Removed old combined report ${file}`);
+    }
+  });
+}
+
+/**
+ * Generate combined JSON & HTML reports.
+ * @param {string} reportRoot - output root
+ * @param {string} jsonFile - filename for combined JSON
+ * @param {string} htmlFile - filename for combined HTML
+ * @param {Function} collectorFn - e.g., collectTsTypesCoverage or collectPerfBudgets
+ * @param {Function} htmlGenFn - e.g., generateTsTypesCoverageHtml or generatePerfBudgetsHtml
+ */
+// eslint-disable-next-line max-params
+export function generateCombinedReports(reportRoot, jsonFile, htmlFile, collectorFn, htmlGenFn) {
+  try {
+    const combinedJsonPath = path.join(reportRoot, jsonFile);
+    const combinedHtmlPath = path.join(reportRoot, htmlFile);
+
+    const summary = collectorFn(reportRoot);
+    fs.writeFileSync(combinedJsonPath, JSON.stringify(summary, null, 2));
+    fs.writeFileSync(combinedHtmlPath, htmlGenFn(summary));
+  } catch (err) {
+    logError(`❌ Failed to generate combined reports: ${err.message}`);
+  }
+}

package/bin/utils/log-utils.js

@@ -0,0 +1,29 @@
+/**
+ * Log an informational message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logInfo(msg) {
+  console.log(`[manager-static-analysis-kit] ${msg}`);
+}
+
+/**
+ * Log a warning message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logWarn(msg) {
+  console.warn(`⚠️  [manager-static-analysis-kit] ${msg}`);
+}
+
+/**
+ * Log an error message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logError(msg) {
+  console.error(`❌ [manager-static-analysis-kit] ${msg}`);
+}

package/bin/utils/runner-utils.js

@@ -0,0 +1,85 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import { resolveAppInfo } from './apps-utils.js';
+import { generateCombinedReports } from './file-utils.js';
+import { logError, logInfo } from './log-utils.js';
+
+/**
+ * Ensure the given binary exists.
+ */
+export function ensureBinExists(binPath, label) {
+  if (!fs.existsSync(binPath)) {
+    logError(`❌ ${label} binary not found at ${binPath}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Run a child process with consistent defaults.
+ */
+export function runCommand(bin, args, cwd) {
+  const result = spawnSync(bin, args, {
+    cwd,
+    stdio: 'inherit',
+    shell: true,
+  });
+  return result.status === 0;
+}
+
+/**
+ * Generic per-app analysis runner with safety.
+ */
+export function runAppsAnalysis({
+  appsDir,
+  appFolders,
+  requireReact = false,
+  binaryLabel,
+  appRunner, // (appDir, appShortName, appInfo) => boolean
+  reportsRootDirName,
+  combinedJson,
+  combinedHtml,
+  collectFn,
+  generateHtmlFn,
+  outputRootDir,
+}) {
+  const analyzed = [];
+
+  for (const appFolder of appFolders) {
+    const appInfo = resolveAppInfo(appsDir, appFolder, { requireReact });
+    if (!appInfo) continue;
+
+    let ok = false;
+    try {
+      ok = appRunner(appInfo.appDir, appInfo.appShortName, appInfo);
+    } catch (err) {
+      logError(
+        `❌ Fatal error while analyzing ${appInfo.appShortName}: ${err.stack || err.message}`,
+      );
+    }
+    if (ok) analyzed.push(appInfo.appShortName);
+  }
+
+  if (analyzed.length > 0) {
+    if (typeof collectFn !== 'function' || typeof generateHtmlFn !== 'function') {
+      logError(`❌ Invalid collector or HTML generator passed to ${binaryLabel} analysis`);
+      process.exit(1);
+    }
+
+    generateCombinedReports(
+      path.join(outputRootDir, reportsRootDirName),
+      combinedJson,
+      combinedHtml,
+      collectFn,
+      generateHtmlFn,
+    );
+    logInfo(`✅ ${binaryLabel} reports generated (per-app + combined).`);
+  } else {
+    logError('❌ No apps successfully analyzed. Exiting.');
+    process.exit(1);
+  }
+
+  return analyzed;
+}

package/bin/utils/turbo-utils.js

@@ -0,0 +1,139 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { logError, logInfo, logWarn } from './log-utils.js';
+
+/**
+ * Convert app folder names into Turbo filters by resolving their package.json names.
+ *
+ * Each app folder must contain a valid `package.json`. If not found, the app is skipped.
+ *
+ * @param {string} appsDir - Absolute path to the apps root directory.
+ * @param {string[]} appFolders - List of app folder names inside the apps directory.
+ * @returns {string[]} Array of package names to be used as Turbo filters.
+ *
+ * @example
+ * // appsDir = "/workspace/manager/apps"
+ * // appFolders = ["zimbra", "web"]
+ * // Returns: ["@ovh-ux/manager-zimbra-app", "@ovh-ux/manager-web-app"]
+ */
+function resolveTurboFiltersFromAppFolders(appsDir, 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);
+}
+
+/**
+ * Resolve Turbo filters (package names) based on input mode.
+ *
+ * - If only `appFolders` are provided, resolves their corresponding package names.
+ * - If `packageNames` are provided, they are used directly as filters.
+ *
+ * @param {Object} options
+ * @param {string} options.appsDir - Absolute path to the apps root directory.
+ * @param {string[]} options.appFolders - List of app folders to analyze.
+ * @param {string[]} options.packageNames - List of package names (overrides appFolders).
+ * @returns {string[]} List of resolved Turbo filters (package names).
+ *
+ * @example
+ * resolveTurboFilters({
+ *   appsDir: "/workspace/manager/apps",
+ *   appFolders: ["zimbra"],
+ *   packageNames: []
+ * });
+ * // → ["@ovh-ux/manager-zimbra-app"]
+ *
+ * @example
+ * resolveTurboFilters({
+ *   appsDir: "/workspace/manager/apps",
+ *   appFolders: [],
+ *   packageNames: ["@ovh-ux/manager-web-app"]
+ * });
+ * // → ["@ovh-ux/manager-web-app"]
+ */
+export function resolveTurboFilters({ appsDir, appFolders, packageNames }) {
+  let filters = [];
+
+  if (appFolders.length > 0 && packageNames.length === 0) {
+    filters = resolveTurboFiltersFromAppFolders(appsDir, appFolders);
+  } else if (packageNames.length > 0) {
+    filters = packageNames;
+  }
+
+  return filters;
+}
+
+/**
+ * Run a Turbo build for the provided filters.
+ *
+ * - Executes `turbo run build` with `--filter` for each package name.
+ * - Runs in the specified root directory.
+ * - If no filters are provided, the build step is skipped with a warning.
+ *
+ * @param {string} rootDir - Root directory where Turbo should be executed.
+ * @param {string[]} filters - List of Turbo build filters (package names).
+ * @returns {void}
+ *
+ * @example
+ * runTurboBuild("/workspace", ["@ovh-ux/manager-zimbra-app"]);
+ * // Executes: turbo run build --filter @ovh-ux/manager-zimbra-app
+ */
+export function runTurboBuild(rootDir, 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.');
+  }
+}
+
+/**
+ * Run Turbo tests with optional filters and extra arguments.
+ *
+ * This function spawns a synchronous Turbo process to run tests,
+ * applying filters for specific packages if provided. It logs
+ * progress and warns if any tests fail, but does not throw.
+ *
+ * @param {string} rootDir - Root directory to run Turbo in (typically the monorepo root).
+ * @param {string[]} filters - List of package filters (Turbo `--filter` flags).
+ * @param {string[]} [extraArgs=[]] - Additional arguments to forward to Turbo.
+ * @returns {void}
+ *
+ * @example
+ * // Run tests for "web" and "zimbra" apps with coverage
+ * runTurboTests(process.cwd(), ['web', 'zimbra'], ['--', '--coverage']);
+ */
+export function runTurboTests(rootDir, filters, extraArgs = []) {
+  const args = ['run', 'test', ...filters.flatMap((pkg) => ['--filter', pkg]), ...extraArgs];
+  logInfo(`Testing with Turbo (filters: ${filters.join(', ')})`);
+
+  const res = spawnSync('turbo', args, {
+    cwd: rootDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  if (res.status !== 0) {
+    logWarn('⚠️ Turbo tests failed for one or more targets. Will still harvest coverage if any.');
+  }
+}

package/dist/adapters/code-duplication/helpers/code-duplication-analysis-helper.d.ts

@@ -0,0 +1,6 @@
+import { CombinedCodeDuplicationSummary, JscpdReportV4, WorstCodeDuplicationFile } from '../types/CodeDuplication.js';
+export declare const extPriority: (file: string) => number;
+export declare function extractWorstFiles(report: JscpdReportV4): WorstCodeDuplicationFile[];
+export declare function collectCodeDuplication(reportOutputDir: string): CombinedCodeDuplicationSummary;
+export declare function generateCodeDuplicationHtml(summary: CombinedCodeDuplicationSummary): string;
+//# sourceMappingURL=code-duplication-analysis-helper.d.ts.map

package/dist/adapters/code-duplication/helpers/code-duplication-analysis-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-duplication-analysis-helper.d.ts","sourceRoot":"","sources":["../../../../src/adapters/code-duplication/helpers/code-duplication-analysis-helper.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,8BAA8B,EAC9B,aAAa,EACb,wBAAwB,EAEzB,MAAM,0BAA0B,CAAC;AAUlC,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MAc1C,CAAC;AAkEF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,wBAAwB,EAAE,CAsEnF;AAkED,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,MAAM,GAAG,8BAA8B,CA+B9F;AAyGD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,8BAA8B,GAAG,MAAM,CAmC3F"}