chore: add adjust global cp logic

Author: BioPhoton

code-pushup.preset.ts

@@ -205,12 +205,14 @@ export const jsDocsCoreConfig = (
 
 export const eslintCoreConfigNx = async (
   projectName?: string,
+  opt?: { cwd?: string },
 ): Promise<CoreConfig> => ({
   plugins: [
     await eslintPlugin(
       await (projectName
         ? eslintConfigFromNxProject(projectName)
         : eslintConfigFromAllNxProjects()),
+      opt,
     ),
   ],
   categories: eslintCategories,

packages/models/code-pushup.config.ts

@@ -29,7 +29,7 @@ export default mergeConfigs(
   await typescriptPluginConfig({
     tsconfig: `packages/${projectName}/tsconfig.lib.json`,
   }),
-  await eslintCoreConfigNx(projectName),
+  await eslintCoreConfigNx(projectName, { cwd: `./packages/${projectName}` }),
   jsDocsCoreConfig([
     `packages/${projectName}/src/**/*.ts`,
     ...jsDocsExclusionPatterns,

packages/plugin-eslint/src/bin.ts

@@ -2,6 +2,6 @@ import process from 'node:process';
 import { Parser } from 'yargs/helpers';
 import { executeRunner } from './lib/runner/index.js';
 
-const { runnerConfigPath, runnerOutputPath } = Parser(process.argv);
+const { runnerConfigPath, runnerOutputPath, cwd } = Parser(process.argv);
 
-await executeRunner({ runnerConfigPath, runnerOutputPath });
+await executeRunner({ runnerConfigPath, runnerOutputPath }, { cwd });

packages/plugin-eslint/src/lib/config.ts

@@ -6,6 +6,10 @@ const patternsSchema = z.union([z.string(), z.array(z.string()).min(1)], {
     'Lint target files. May contain file paths, directory paths or glob patterns',
 });
 
+const envSchema = z.object({
+  cwd: z.string({ description: 'CWD path' }).optional(),
+});
+
 const eslintrcSchema = z.string({ description: 'Path to ESLint config file' });
 
 const eslintTargetObjectSchema = z.object({
@@ -62,7 +66,9 @@ const customGroupSchema = z.object({
 });
 export type CustomGroup = z.infer<typeof customGroupSchema>;
 
-export const eslintPluginOptionsSchema = z.object({
-  groups: z.array(customGroupSchema).optional(),
-});
+export const eslintPluginOptionsSchema = z
+  .object({
+    groups: z.array(customGroupSchema).optional(),
+  })
+  .merge(envSchema);
 export type ESLintPluginOptions = z.infer<typeof eslintPluginOptionsSchema>;

packages/plugin-eslint/src/lib/eslint-plugin.ts

@@ -41,6 +41,7 @@ export async function eslintPlugin(
     schemaType: 'ESLint plugin config',
   });
 
+  const cwd = options?.cwd || process.cwd();
   const customGroups = options
     ? parseSchema(eslintPluginOptionsSchema, options, {
         schemaType: 'ESLint plugin options',
@@ -71,6 +72,8 @@ export async function eslintPlugin(
     audits,
     groups,
 
-    runner: await createRunnerConfig(runnerScriptPath, audits, targets),
+    runner: await createRunnerConfig(runnerScriptPath, audits, targets, {
+      cwd,
+    }),
   };
 }

packages/plugin-eslint/src/lib/runner/index.ts

@@ -19,16 +19,19 @@ import type { ESLintPluginRunnerConfig, ESLintTarget } from '../config.js';
 import { lint } from './lint.js';
 import { lintResultsToAudits, mergeLinterOutputs } from './transform.js';
 
-export async function executeRunner({
-  runnerConfigPath,
-  runnerOutputPath,
-}: RunnerFilesPaths): Promise<void> {
+export async function executeRunner(
+  { runnerConfigPath, runnerOutputPath }: RunnerFilesPaths,
+  opt?: { cwd?: string },
+): Promise<void> {
+  const { cwd = process.cwd() } = opt || {};
   const { slugs, targets } =
     await readJsonFile<ESLintPluginRunnerConfig>(runnerConfigPath);
 
-  ui().logger.log(`ESLint plugin executing ${targets.length} lint targets`);
+  ui().logger.log(
+    `ESLint plugin executing ${targets.length} lint targets with cwd: ${cwd}`,
+  );
 
-  const linterOutputs = await asyncSequential(targets, lint);
+  const linterOutputs = await asyncSequential(targets, cfg => lint(cfg, opt));
   const lintResults = mergeLinterOutputs(linterOutputs);
   const failedAudits = lintResultsToAudits(lintResults);
 
@@ -51,6 +54,7 @@ export async function createRunnerConfig(
   scriptPath: string,
   audits: Audit[],
   targets: ESLintTarget[],
+  opt?: { cwd?: string },
 ): Promise<RunnerConfig> {
   const config: ESLintPluginRunnerConfig = {
     targets,
@@ -65,7 +69,11 @@ export async function createRunnerConfig(
     command: 'node',
     args: [
       filePathToCliArg(scriptPath),
-      ...objectToCliArgs({ runnerConfigPath, runnerOutputPath }),
+      ...objectToCliArgs({
+        runnerConfigPath,
+        runnerOutputPath,
+        ...(opt?.cwd ? { cwd: opt.cwd } : {}),
+      }),
     ],
     configFile: runnerConfigPath,
     outputFile: runnerOutputPath,

packages/plugin-eslint/src/lib/runner/lint.ts

@@ -1,5 +1,6 @@
 import type { ESLint, Linter } from 'eslint';
 import { platform } from 'node:os';
+import { join } from 'node:path';
 import {
   distinct,
   executeProcess,
@@ -10,20 +11,21 @@ import type { ESLintTarget } from '../config.js';
 import { setupESLint } from '../setup.js';
 import type { LinterOutput, RuleOptionsPerFile } from './types.js';
 
-export async function lint({
-  eslintrc,
-  patterns,
-}: ESLintTarget): Promise<LinterOutput> {
-  const results = await executeLint({ eslintrc, patterns });
+export async function lint(
+  { eslintrc, patterns }: ESLintTarget,
+  opt?: { cwd?: string },
+): Promise<LinterOutput> {
+  const results = await executeLint({ eslintrc, patterns }, opt);
   const eslint = await setupESLint(eslintrc);
   const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslint, results);
   return { results, ruleOptionsPerFile };
 }
 
-async function executeLint({
-  eslintrc,
-  patterns,
-}: ESLintTarget): Promise<ESLint.LintResult[]> {
+async function executeLint(
+  { eslintrc, patterns }: ESLintTarget,
+  opt?: { cwd?: string },
+): Promise<ESLint.LintResult[]> {
+  const { cwd = process.cwd() } = opt ?? {};
   // running as CLI because ESLint#lintFiles() runs out of memory
   const { stdout } = await executeProcess({
     command: 'npx',
@@ -33,13 +35,14 @@ async function executeLint({
       ...(typeof eslintrc === 'object' ? ['--no-eslintrc'] : []),
       '--no-error-on-unmatched-pattern',
       '--format=json',
+      `--output-file=${join(cwd, '.eslint-results.json')}`,
       ...toArray(patterns).map(pattern =>
         // globs need to be escaped on Unix
         platform() === 'win32' ? pattern : `'${pattern}'`,
       ),
     ],
     ignoreExitCode: true,
-    cwd: process.cwd(),
+    cwd,
   });
 
   return JSON.parse(stdout) as ESLint.LintResult[];