refactor(create-cli): address review feedback

Author: hanna-skryl

packages/create-cli/README.md

@@ -9,7 +9,7 @@ An interactive setup wizard that scaffolds a `code-pushup.config.ts` file in you
 ## Usage
 
 ```bash
-npx @code-pushup/create-cli
+npm init @code-pushup/cli
 ```
 
 The wizard will prompt you to select plugins and configure their options, then generate a `code-pushup.config.ts` file.
@@ -27,17 +27,17 @@ The wizard will prompt you to select plugins and configure their options, then g
 Run interactively (default):
 
 ```bash
-npx @code-pushup/create-cli
+npm init @code-pushup/cli
 ```
 
 Skip prompts and enable specific plugins:
 
 ```bash
-npx @code-pushup/create-cli -y --plugins=eslint,coverage
+npm init @code-pushup/cli -y --plugins=eslint,coverage
 ```
 
 Preview the generated config without writing:
 
 ```bash
-npx @code-pushup/create-cli -y --dry-run
+npm init @code-pushup/cli -y --dry-run
 ```

packages/create-cli/eslint.config.js

@@ -1,24 +1,12 @@
 import tseslint from 'typescript-eslint';
 import baseConfig from '../../eslint.config.js';
 
-export default tseslint.config(
-  ...baseConfig,
-  {
-    files: ['**/*.ts'],
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
+export default tseslint.config(...baseConfig, {
+  files: ['**/*.ts'],
+  languageOptions: {
+    parserOptions: {
+      projectService: true,
+      tsconfigRootDir: import.meta.dirname,
     },
   },
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        { ignoredDependencies: ['@code-pushup/models'] },
-      ],
-    },
-  },
-);
+});

packages/create-cli/package.json

@@ -26,6 +26,7 @@
   },
   "type": "module",
   "dependencies": {
+    "@code-pushup/models": "0.113.0",
     "@code-pushup/utils": "0.113.0",
     "@inquirer/prompts": "^8.0.0",
     "yargs": "^17.7.2"

packages/create-cli/src/index.ts

@@ -1,7 +1,6 @@
 #! /usr/bin/env node
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import type { CliArgs } from './lib/setup/types.js';
 import { runSetupWizard } from './lib/setup/wizard.js';
 
 const argv = await yargs(hideBin(process.argv))
@@ -19,4 +18,4 @@ const argv = await yargs(hideBin(process.argv))
   .parse();
 
 // TODO: #1244 — provide plugin bindings from registry
-await runSetupWizard([], argv as CliArgs);
+await runSetupWizard([], argv);

packages/create-cli/src/lib/setup/types.ts

@@ -3,9 +3,9 @@ import type { PluginMeta } from '@code-pushup/models';
 /** Virtual file system that buffers writes in memory until flushed to disk. */
 export type Tree = {
   root: string;
-  exists: (filePath: string) => boolean;
-  read: (filePath: string) => string | null;
-  write: (filePath: string, content: string) => void;
+  exists: (filePath: string) => Promise<boolean>;
+  read: (filePath: string) => Promise<string | null>;
+  write: (filePath: string, content: string) => Promise<void>;
   listChanges: () => FileChange[];
   flush: () => Promise<void>;
 };
@@ -17,10 +17,13 @@ export type FileChange = {
 };
 
 export type FileSystemAdapter = {
-  readFileSync: (path: string, encoding: 'utf8') => string;
-  writeFileSync: (path: string, content: string) => void;
-  existsSync: (path: string) => boolean;
-  mkdirSync: (path: string, options: { recursive: boolean }) => void;
+  readFile: (path: string, encoding: 'utf8') => Promise<string>;
+  writeFile: (path: string, content: string) => Promise<void>;
+  exists: (path: string) => Promise<boolean>;
+  mkdir: (
+    path: string,
+    options: { recursive: true },
+  ) => Promise<string | undefined>;
 };
 
 export type PluginSetupBinding = {
@@ -29,7 +32,7 @@ export type PluginSetupBinding = {
   packageName: NonNullable<PluginMeta['packageName']>;
   // TODO: #1244 — add async pre-selection callback (e.g. detect eslint.config.js in repo)
   prompts?: PluginPromptDescriptor[];
-  codegenConfig: (
+  generateConfig: (
     answers: Record<string, string | string[]>,
   ) => PluginCodegenResult;
 };
@@ -52,23 +55,23 @@ type PromptBase = {
   message: string;
 };
 
-type PromptChoice = { name: string; value: string };
+type PromptChoice<T extends string> = { name: string; value: T };
 
 type InputPrompt = PromptBase & {
   type: 'input';
   default: string;
 };
 
-type SelectPrompt = PromptBase & {
+type SelectPrompt<T extends string = string> = PromptBase & {
   type: 'select';
-  choices: PromptChoice[];
-  default: string;
+  choices: PromptChoice<T>[];
+  default: T;
 };
 
-type CheckboxPrompt = PromptBase & {
+type CheckboxPrompt<T extends string = string> = PromptBase & {
   type: 'checkbox';
-  choices: PromptChoice[];
-  default: string[];
+  choices: PromptChoice<T>[];
+  default: T[];
 };
 
 export type PluginPromptDescriptor =

packages/create-cli/src/lib/setup/virtual-fs.ts

@@ -1,46 +1,43 @@
-/* eslint-disable n/no-sync */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { fileExists } from '@code-pushup/utils';
 import type { FileChange, FileSystemAdapter, Tree } from './types.js';
 
 const DEFAULT_FS: FileSystemAdapter = {
-  readFileSync,
-  writeFileSync,
-  existsSync,
-  mkdirSync,
+  readFile,
+  writeFile,
+  exists: fileExists,
+  mkdir,
 };
 
 export function createTree(
   root: string,
   fs: FileSystemAdapter = DEFAULT_FS,
 ): Tree {
-  const pending = new Map<
-    string,
-    { content: string; type: 'CREATE' | 'UPDATE' }
-  >();
+  const pending = new Map<FileChange['path'], Omit<FileChange, 'path'>>();
 
   const resolve = (filePath: string): string => path.resolve(root, filePath);
 
   return {
     root,
 
-    exists: (filePath: string): boolean =>
-      pending.has(filePath) || fs.existsSync(resolve(filePath)),
+    exists: async (filePath: string): Promise<boolean> =>
+      pending.has(filePath) || fs.exists(resolve(filePath)),
 
-    read: (filePath: string): string | null => {
+    read: async (filePath: string): Promise<string | null> => {
       const entry = pending.get(filePath);
       if (entry) {
         return entry.content;
       }
       const absolutePath = resolve(filePath);
-      if (!fs.existsSync(absolutePath)) {
+      if (!(await fs.exists(absolutePath))) {
         return null;
       }
-      return fs.readFileSync(absolutePath, 'utf8');
+      return fs.readFile(absolutePath, 'utf8');
     },
 
-    write: (filePath: string, content: string): void => {
-      const type = fs.existsSync(resolve(filePath)) ? 'UPDATE' : 'CREATE';
+    write: async (filePath: string, content: string): Promise<void> => {
+      const type = (await fs.exists(resolve(filePath))) ? 'UPDATE' : 'CREATE';
       pending.set(filePath, { content, type });
     },
 
@@ -52,11 +49,13 @@ export function createTree(
       })),
 
     async flush(): Promise<void> {
-      [...pending.entries()].forEach(([filePath, { content }]) => {
-        const absolutePath = resolve(filePath);
-        fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-        fs.writeFileSync(absolutePath, content);
-      });
+      await Promise.all(
+        [...pending.entries()].map(async ([filePath, { content }]) => {
+          const absolutePath = resolve(filePath);
+          await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+          await fs.writeFile(absolutePath, content);
+        }),
+      );
       pending.clear();
     },
   };

packages/create-cli/src/lib/setup/virtual-fs.unit.test.ts

@@ -12,21 +12,21 @@ function createMockFs(
   return {
     written,
     dirs,
-    readFileSync(path: string) {
+    async readFile(path: string) {
       const content = store.get(toUnixPath(path));
       if (content == null) {
         throw new Error(`ENOENT: no such file or directory, open '${path}'`);
       }
       return content;
     },
-    writeFileSync(path: string, content: string) {
+    async writeFile(path: string, content: string) {
       store.set(toUnixPath(path), content);
       written.set(toUnixPath(path), content);
     },
-    existsSync(path: string) {
+    async exists(path: string) {
       return store.has(toUnixPath(path));
     },
-    mkdirSync(_path: string, _options: { recursive: boolean }) {
+    async mkdir(_path: string, _options: { recursive: boolean }) {
       // eslint-disable-next-line functional/immutable-data
       dirs.push(toUnixPath(_path));
     },
@@ -39,70 +39,70 @@ describe('createTree', () => {
   });
 
   describe('exists', () => {
-    it('should return false for non-existent files', () => {
-      expect(
+    it('should return false for non-existent files', async () => {
+      await expect(
         createTree('/project', createMockFs()).exists('missing.ts'),
-      ).toBeFalse();
+      ).resolves.toBeFalse();
     });
 
-    it('should return true for files on disk', () => {
-      expect(
+    it('should return true for files on disk', async () => {
+      await expect(
         createTree(
           '/project',
           createMockFs({ '/project/existing.ts': 'content' }),
         ).exists('existing.ts'),
-      ).toBeTrue();
+      ).resolves.toBeTrue();
     });
 
-    it('should return true for files written to the tree', () => {
+    it('should return true for files written to the tree', async () => {
       const tree = createTree('/project', createMockFs());
-      tree.write('new.ts', 'content');
-      expect(tree.exists('new.ts')).toBeTrue();
+      await tree.write('new.ts', 'content');
+      await expect(tree.exists('new.ts')).resolves.toBeTrue();
     });
   });
 
   describe('read', () => {
-    it('should return null for non-existent files', () => {
-      expect(
+    it('should return null for non-existent files', async () => {
+      await expect(
         createTree('/project', createMockFs()).read('missing.ts'),
-      ).toBeNull();
+      ).resolves.toBeNull();
     });
 
-    it('should read files from disk', () => {
-      expect(
+    it('should read files from disk', async () => {
+      await expect(
         createTree(
           '/project',
           createMockFs({ '/project/existing.ts': 'disk content' }),
         ).read('existing.ts'),
-      ).toBe('disk content');
+      ).resolves.toBe('disk content');
     });
 
-    it('should return pending content over disk content', () => {
+    it('should return pending content over disk content', async () => {
       const tree = createTree(
         '/project',
         createMockFs({ '/project/file.ts': 'old' }),
       );
-      tree.write('file.ts', 'new');
-      expect(tree.read('file.ts')).toBe('new');
+      await tree.write('file.ts', 'new');
+      await expect(tree.read('file.ts')).resolves.toBe('new');
     });
   });
 
   describe('write', () => {
-    it('should mark new files as CREATE', () => {
+    it('should mark new files as CREATE', async () => {
       const tree = createTree('/project', createMockFs());
-      tree.write('new.ts', 'content');
+      await tree.write('new.ts', 'content');
 
       expect(tree.listChanges()).toStrictEqual([
         { path: 'new.ts', type: 'CREATE', content: 'content' },
       ]);
     });
 
-    it('should mark existing files as UPDATE', () => {
+    it('should mark existing files as UPDATE', async () => {
       const tree = createTree(
         '/project',
         createMockFs({ '/project/existing.ts': 'old' }),
       );
-      tree.write('existing.ts', 'new');
+      await tree.write('existing.ts', 'new');
 
       expect(tree.listChanges()).toStrictEqual([
         { path: 'existing.ts', type: 'UPDATE', content: 'new' },
@@ -117,13 +117,13 @@ describe('createTree', () => {
       ).toStrictEqual([]);
     });
 
-    it('should return all pending changes', () => {
+    it('should return all pending changes', async () => {
       const tree = createTree(
         '/project',
         createMockFs({ '/project/existing.ts': 'old' }),
       );
-      tree.write('new.ts', 'created');
-      tree.write('existing.ts', 'updated');
+      await tree.write('new.ts', 'created');
+      await tree.write('existing.ts', 'updated');
 
       expect(tree.listChanges()).toHaveLength(2);
       expect(tree.listChanges()).toContainEqual({
@@ -143,7 +143,7 @@ describe('createTree', () => {
     it('should write all pending files to the fs', async () => {
       const fs = createMockFs();
       const tree = createTree('/project', fs);
-      tree.write('src/config.ts', 'export default {};');
+      await tree.write('src/config.ts', 'export default {};');
 
       await tree.flush();
 
@@ -155,7 +155,7 @@ describe('createTree', () => {
     it('should create parent directories', async () => {
       const fs = createMockFs();
       const tree = createTree('/project', fs);
-      tree.write('src/deep/config.ts', 'content');
+      await tree.write('src/deep/config.ts', 'content');
 
       await tree.flush();
 
@@ -164,7 +164,7 @@ describe('createTree', () => {
 
     it('should clear pending changes after flush', async () => {
       const tree = createTree('/project', createMockFs());
-      tree.write('file.ts', 'content');
+      await tree.write('file.ts', 'content');
 
       await tree.flush();