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

package/bin/tests-coverage-cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import {
+  collectTestsCoverage,
+  generateTestsCoverageHtml,
+} from '../dist/adapters/tests-coverage/helpers/tests-coverage-analysis-helper.js';
+import {
+  appsDir,
+  outputRootDir,
+  rootDir,
+  testsCoverageCombinedHtmlReportName,
+  testsCoverageCombinedJsonReportName,
+  testsCoverageReportsRootDirName,
+} from './cli-path-config.js';
+import { parseCliTargets } from './utils/args-parse-utils.js';
+import { logError, logInfo, logWarn } from './utils/log-utils.js';
+import { runAppsAnalysis } from './utils/runner-utils.js';
+import { resolveTurboFilters, runTurboBuild, runTurboTests } from './utils/turbo-utils.js';
+
+/**
+ * Locate common coverage artifacts inside an app directory.
+ * @param {string} appDir
+ * @returns {{ summary: string | null, lcov: string | null }}
+ */
+function findCoverageFiles(appDir) {
+  const candidates = [
+    // Vitest & Jest default
+    path.join(appDir, 'coverage', 'coverage-summary.json'),
+    // Sometimes coverage is nested (e.g., project subdir)
+    // We’ll scan one level deep for coverage-summary.json
+  ];
+
+  let summary = candidates.find((p) => fs.existsSync(p));
+  if (!summary) {
+    // one-level deep scan
+    for (const entry of fs.readdirSync(appDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (['node_modules', 'dist', 'build', '.next', 'coverage'].includes(entry.name)) continue;
+      const p = path.join(appDir, entry.name, 'coverage', 'coverage-summary.json');
+      if (fs.existsSync(p)) {
+        summary = p;
+        break;
+      }
+    }
+  }
+
+  // Best-effort extras (not mandatory)
+  const lcov =
+    (summary && path.join(path.dirname(summary), 'lcov.info')) ||
+    path.join(appDir, 'coverage', 'lcov.info');
+
+  return { summary, lcov: fs.existsSync(lcov) ? lcov : null };
+}
+
+/**
+ * Copy an app’s coverage files into tests-coverage-reports/<app>.
+ * @param {string} appDir
+ * @param {string} appShortName
+ * @returns {boolean} True if a summary was found and copied
+ */
+function harvestAppCoverage(appDir, appShortName) {
+  const { summary, lcov } = findCoverageFiles(appDir);
+  const outDir = path.join(outputRootDir, testsCoverageReportsRootDirName, appShortName);
+  fs.mkdirSync(outDir, { recursive: true });
+
+  if (!summary) {
+    logWarn(`⚠️  No coverage-summary.json found for ${appShortName}`);
+    return false;
+  }
+
+  const targetSummary = path.join(outDir, 'coverage-summary.json');
+  fs.copyFileSync(summary, targetSummary);
+  logInfo(`✅ Copied summary → ${targetSummary}`);
+
+  if (lcov) {
+    const targetLcov = path.join(outDir, 'lcov.info');
+    fs.copyFileSync(lcov, targetLcov);
+    logInfo(`✅ Copied lcov → ${targetLcov}`);
+  }
+
+  return true;
+}
+
+/**
+ * Main CLI entrypoint: build → test (with coverage) → harvest → combine.
+ */
+function main() {
+  try {
+    const { appFolders, packageNames } = parseCliTargets(appsDir);
+    const turboFilters = resolveTurboFilters({ appsDir, appFolders, packageNames });
+
+    // 1) Build all selected targets (best-effort)
+    runTurboBuild(rootDir, turboFilters, ['--continue']);
+
+    // 2) Run tests with coverage; keep args minimal for Vitest/Jest compatibility
+    //    (Projects should already be configured to emit json-summary/lcov.)
+    runTurboTests(rootDir, turboFilters, [
+      '--continue', // turbo: keep going even if some tests fail
+      '--', // pass the rest to the test runner
+      '--coverage',
+      '--coverage.reportOnFailure',
+      '--coverage.reporter',
+      'json-summary',
+      '--coverage.reporter',
+      'lcov',
+      '--coverage.reporter',
+      'html',
+    ]);
+
+    // 3) Per-app harvest + combined reports
+    runAppsAnalysis({
+      appsDir,
+      appFolders,
+      requireReact: false,
+      binaryLabel: 'Tests coverage',
+      appRunner: harvestAppCoverage,
+      reportsRootDirName: testsCoverageReportsRootDirName,
+      combinedJson: testsCoverageCombinedJsonReportName,
+      combinedHtml: testsCoverageCombinedHtmlReportName,
+      collectFn: collectTestsCoverage,
+      generateHtmlFn: (combined) =>
+        generateTestsCoverageHtml(
+          combined,
+          path.join(outputRootDir, testsCoverageReportsRootDirName),
+        ),
+      outputRootDir,
+    });
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/types-coverage-cli.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import ts from 'typescript';
+
+import {
+  collectTypesCoverage,
+  generateTypesCoverageHtml,
+} from '../dist/adapters/types-coverage/helpers/types-coverage-analysis-helper.js';
+import {
+  appsDir,
+  outputRootDir,
+  tsTypesCoverageBin,
+  typesCoverageCombinedHtmlReportName,
+  typesCoverageCombinedJsonReportName,
+  typesCoverageReportsRootDirName,
+} from './cli-path-config.js';
+import { buildTypesCoverageArgs, 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';
+
+/**
+ * Temporarily strip "extends" from tsconfig.json before analysis,
+ * then restore it after.
+ *
+ * @param {string} appDir - Absolute app directory
+ * @param {() => boolean} fn - Callback running the analysis
+ * @returns {boolean} Result of the callback
+ */
+function patchTsConfig(appDir, fn) {
+  const tsconfigPath = path.join(appDir, 'tsconfig.json');
+  if (!fs.existsSync(tsconfigPath)) {
+    return fn();
+  }
+
+  const original = fs.readFileSync(tsconfigPath, 'utf-8');
+  let parsed;
+  try {
+    parsed = JSON.parse(original);
+  } catch {
+    logWarn(`⚠️ Invalid tsconfig.json in ${appDir}, skipping patch`);
+    return fn();
+  }
+
+  let modified = null;
+  if (parsed.extends) {
+    modified = { ...parsed };
+    delete modified.extends;
+    fs.writeFileSync(tsconfigPath, JSON.stringify(modified, null, 2));
+    logInfo(`⏳ Patched tsconfig.json in ${appDir} (removed extends)`);
+  }
+
+  try {
+    return fn();
+  } finally {
+    if (modified) {
+      fs.writeFileSync(tsconfigPath, original);
+      logInfo(`🔄 Restored tsconfig.json in ${appDir}`);
+    }
+  }
+}
+
+/**
+ * Count loose TypeScript constructs (`as`, `any`, `unknown`) in src/.
+ *
+ * Uses the TypeScript compiler API to avoid false positives from strings, comments, etc.
+ *
+ * @param {string} appDir Absolute path to app root
+ * @returns {{ as: number; any: number; unknown: number }}
+ */
+export function countLooseTypes(appDir) {
+  const srcDir = path.join(appDir, 'src');
+  let asCount = 0;
+  let anyCount = 0;
+  let unknownCount = 0;
+
+  function analyzeFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const source = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+
+    function visit(node) {
+      // "as" expressions: foo as string
+      if (ts.isAsExpression(node)) {
+        asCount++;
+        if (node.type.kind === ts.SyntaxKind.AnyKeyword) {
+          anyCount++;
+        } else if (node.type.kind === ts.SyntaxKind.UnknownKeyword) {
+          unknownCount++;
+        }
+      }
+
+      // Type annotations like let x: any or function foo(x: unknown)
+      if (node.kind === ts.SyntaxKind.AnyKeyword) {
+        anyCount++;
+      } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
+        unknownCount++;
+      }
+
+      ts.forEachChild(node, visit);
+    }
+
+    visit(source);
+  }
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (/\.(ts|tsx)$/.test(entry.name)) {
+        analyzeFile(fullPath);
+      }
+    }
+  }
+
+  if (fs.existsSync(srcDir)) {
+    walk(srcDir);
+  }
+
+  return { as: asCount, any: anyCount, unknown: unknownCount };
+}
+
+/**
+ * Run TypeScript coverage for one app.
+ *
+ * @param {string} appDir - Absolute app directory
+ * @param {string} appShortName - Shortened app name
+ * @returns {boolean} True if analysis completed successfully
+ */
+function runAppTypesCoverage(appDir, appShortName) {
+  return patchTsConfig(appDir, () => {
+    const absoluteOutputDir = path.join(
+      outputRootDir,
+      typesCoverageReportsRootDirName,
+      appShortName,
+    );
+    fs.mkdirSync(absoluteOutputDir, { recursive: true });
+
+    const relativeOutputDir = path.relative(appDir, absoluteOutputDir);
+    logInfo(`Running TypeScript coverage for ${appShortName} → ${absoluteOutputDir}`);
+
+    const args = buildTypesCoverageArgs(relativeOutputDir);
+    const ok = runCommand(tsTypesCoverageBin, args, appDir);
+
+    const looseTypes = countLooseTypes(appDir);
+    const looseTypeReport = path.join(absoluteOutputDir, 'loose-types.json');
+    fs.writeFileSync(looseTypeReport, JSON.stringify(looseTypes, null, 2));
+
+    const jsonReport = path.join(absoluteOutputDir, 'typescript-coverage.json');
+    const htmlReport = path.join(absoluteOutputDir, 'index.html');
+
+    if (!fs.existsSync(jsonReport)) {
+      logWarn(`⚠️ Missing typescript-coverage.json at ${jsonReport}`);
+    }
+    if (!fs.existsSync(htmlReport)) {
+      logWarn(`⚠️ Missing index.html at ${htmlReport}`);
+    }
+    if (!fs.existsSync(looseTypeReport)) {
+      logWarn(`⚠️ Missing loose-types.json at ${looseTypeReport}`);
+    }
+
+    return ok;
+  });
+}
+
+/**
+ * Main CLI entrypoint for TypeScript coverage analysis.
+ */
+function main() {
+  try {
+    ensureBinExists(tsTypesCoverageBin, 'typescript-coverage-report');
+
+    const { appFolders } = parseCliTargets(appsDir);
+
+    runAppsAnalysis({
+      appsDir,
+      appFolders,
+      requireReact: true,
+      binaryLabel: 'Type coverage',
+      appRunner: runAppTypesCoverage,
+      reportsRootDirName: typesCoverageReportsRootDirName,
+      combinedJson: typesCoverageCombinedJsonReportName,
+      combinedHtml: typesCoverageCombinedHtmlReportName,
+      collectFn: collectTypesCoverage,
+      generateHtmlFn: generateTypesCoverageHtml,
+      outputRootDir,
+    });
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

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

package/bin/utils/apps-utils.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { readJsonSafe } from './file-utils.js';
+import { logError, logWarn } from './log-utils.js';
+
+/**
+ * Check if a given package.json belongs to a React app.
+ */
+export function isReactApp(pkgPath) {
+  try {
+    if (!fs.existsSync(pkgPath)) return false;
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    if (!pkg || typeof pkg !== 'object') return false;
+
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+    return Boolean(deps.react);
+  } catch (err) {
+    logWarn(`Failed to read or parse ${pkgPath}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Resolve app short name from package.json (fallback to folder).
+ */
+export function getAppShortName(pkgPath, folder) {
+  const pkg = readJsonSafe(pkgPath) || {};
+  return (pkg.name && String(pkg.name).replace(/^@ovh-ux\//, '')) || folder;
+}
+
+/**
+ * Unified app info resolver.
+ * - Ensures folder exists
+ * - Ensures package.json exists
+ * - Optionally enforces React app
+ */
+export function resolveAppInfo(appsDir, appFolder, { requireReact = false } = {}) {
+  const appDir = path.join(appsDir, appFolder);
+  if (!fs.existsSync(appDir)) {
+    logError(`❌ App folder not found: ${appFolder} → skipping`);
+    return null;
+  }
+
+  const pkgPath = path.join(appDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    logWarn(`⚠️ No package.json for ${appFolder}, skipping`);
+    return null;
+  }
+
+  if (requireReact && !isReactApp(pkgPath)) {
+    logWarn(`⚠️ ${appFolder} is not a React app, skipping`);
+    return null;
+  }
+
+  return {
+    appDir,
+    pkgPath,
+    appFolder,
+    appShortName: getAppShortName(pkgPath, appFolder),
+    pkg: readJsonSafe(pkgPath),
+  };
+}

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

@@ -0,0 +1,229 @@
+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(','));
+  }
+  // jscpd accepts regex patterns via `--ignore-pattern` (singular).
+  // Multiple regexes should be joined by comma.
+  // https://github.com/kucherenko/jscpd/blob/master/apps/jscpd/README.md#ignore-pattern
+  if (Array.isArray(cfg.ignorePatterns) && cfg.ignorePatterns.length > 0) {
+    for (const pat of cfg.ignorePatterns) {
+      args.push('--ignore-pattern', `'${pat}'`);
+    }
+  }
+  return args;
+}