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

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

@@ -0,0 +1,72 @@
+#!/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
+const cases = [
+  // This case take too much time since it builds all apps, use it only for debug
+  // { name: 'Auto-discovery (all apps)', cmd: 'yarn manager-perf-budgets', expect: 0 },
+  { name: 'Single app (zimbra)', cmd: 'yarn manager-perf-budgets --app zimbra', expect: 0 },
+  {
+    name: 'Multiple apps (container,zimbra)',
+    cmd: 'yarn manager-perf-budgets --apps container,zimbra',
+    expect: 0,
+  },
+  {
+    name: 'Single package (container)',
+    cmd: 'yarn manager-perf-budgets --package @ovh-ux/manager-container-app',
+    expect: 0,
+  },
+  {
+    name: 'Multiple packages (zimbra,pci-workflow)',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-pci-workflow-app',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid apps',
+    cmd: 'yarn manager-perf-budgets --apps zimbra,unknown-app,container',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid packages',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-ghost-app',
+    expect: 0,
+  },
+  {
+    name: 'All invalid apps',
+    cmd: 'yarn manager-perf-budgets --apps doesnotexist1,doesnotexist2',
+    expect: 1,
+  },
+  {
+    name: 'All invalid packages',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-ghost-app,@ovh-ux/manager-missing-app',
+    expect: 1,
+  },
+  {
+    name: 'Turbo build failure simulation (pci-ai-tools)',
+    cmd: 'yarn manager-perf-budgets --app pci-ai-tools',
+    expect: 0,
+  },
+];
+
+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 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!');
+}

package/bin/tests-coverage-cli.js

@@ -0,0 +1,135 @@
+#!/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);
+
+    // 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, [
+      '--',
+      '--coverage',
+      '--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,127 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+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}`);
+    }
+  }
+}
+
+/**
+ * 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 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}`);
+    }
+
+    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),
+  };
+}