refactor(create-cli): rework mode prompting

Author: hanna-skryl

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

@@ -4,44 +4,67 @@ import {
   MONOREPO_TOOL_DETECTORS,
   type MonorepoTool,
   type WorkspacePackage,
+  detectMonorepoTool,
   hasScript,
   listPackages,
   listWorkspaces,
   loadNxProjectGraph,
+  logger,
   readPnpmWorkspacePatterns,
   toUnixPath,
 } from '@code-pushup/utils';
-import {
-  type CliArgs,
-  SETUP_MODES,
-  type SetupMode,
-  type Tree,
-  type WizardProject,
+import type {
+  CliArgs,
+  ConfigContext,
+  SetupMode,
+  Tree,
+  WizardProject,
 } from './types.js';
 
 const TARGET_NAME = 'code-pushup';
 
 export async function promptSetupMode(
-  tool: MonorepoTool | null,
+  targetDir: string,
   cliArgs: CliArgs,
-): Promise<SetupMode> {
-  if (isSetupMode(cliArgs.mode)) {
-    return cliArgs.mode;
-  }
-  const mode = tool ? 'monorepo' : 'standalone';
-  if (cliArgs.yes) {
-    return mode;
+): Promise<ConfigContext> {
+  switch (cliArgs.mode) {
+    case 'standalone':
+      return toContext(cliArgs.mode, null);
+    case 'monorepo': {
+      const tool = await detectMonorepoTool(targetDir);
+      return toContext(cliArgs.mode, tool);
+    }
+    case undefined: {
+      const tool = await detectMonorepoTool(targetDir);
+      const mode = cliArgs.yes ? inferMode(tool) : await promptMode(tool);
+      return toContext(mode, tool);
+    }
   }
+}
+
+async function promptMode(tool: MonorepoTool | null): Promise<SetupMode> {
   return select<SetupMode>({
     message: 'Setup mode:',
     choices: [
       { name: 'Standalone (single config)', value: 'standalone' },
       { name: 'Monorepo (per-project configs)', value: 'monorepo' },
     ],
-    default: mode,
+    default: inferMode(tool),
   });
 }
 
+function inferMode(tool: MonorepoTool | null): SetupMode {
+  return tool ? 'monorepo' : 'standalone';
+}
+
+function toContext(mode: SetupMode, tool: MonorepoTool | null): ConfigContext {
+  if (mode === 'monorepo' && tool == null) {
+    logger.warn('No monorepo tool detected, falling back to standalone mode.');
+    return { mode: 'standalone', tool: null };
+  }
+  return { mode, tool };
+}
+
 export async function listProjects(
   cwd: string,
   tool: MonorepoTool,
@@ -157,8 +180,3 @@ function toProject(cwd: string, pkg: WorkspacePackage): WizardProject {
     relativeDir: toUnixPath(path.relative(cwd, pkg.directory)),
   };
 }
-
-function isSetupMode(value: string | undefined): value is SetupMode {
-  const validValues: readonly string[] = SETUP_MODES;
-  return value != null && validValues.includes(value);
-}

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

@@ -1,6 +1,7 @@
 import { select } from '@inquirer/prompts';
 import { vol } from 'memfs';
 import { MEMFS_VOLUME } from '@code-pushup/test-utils';
+import { logger } from '@code-pushup/utils';
 import { addCodePushUpCommand, promptSetupMode } from './monorepo.js';
 import type { WizardProject } from './types.js';
 import { createTree } from './virtual-fs.js';
@@ -10,45 +11,93 @@ vi.mock('@inquirer/prompts', () => ({
 }));
 
 describe('promptSetupMode', () => {
-  it('should return CLI arg when --mode is provided', async () => {
-    await expect(promptSetupMode('nx', { mode: 'standalone' })).resolves.toBe(
-      'standalone',
+  it('should skip detection when --mode standalone is provided', async () => {
+    await expect(
+      promptSetupMode(MEMFS_VOLUME, { mode: 'standalone' }),
+    ).resolves.toStrictEqual({ mode: 'standalone', tool: null });
+    expect(select).not.toHaveBeenCalled();
+  });
+
+  it('should detect tool when --mode monorepo is provided', async () => {
+    vol.fromJSON(
+      { 'pnpm-workspace.yaml': 'packages:\n  - packages/*' },
+      MEMFS_VOLUME,
     );
+
+    await expect(
+      promptSetupMode(MEMFS_VOLUME, { mode: 'monorepo' }),
+    ).resolves.toStrictEqual({ mode: 'monorepo', tool: 'pnpm' });
     expect(select).not.toHaveBeenCalled();
   });
 
+  it('should fall back to standalone with warning when --mode monorepo but no tool detected', async () => {
+    vol.fromJSON({ 'package.json': '{}' }, MEMFS_VOLUME);
+
+    await expect(
+      promptSetupMode(MEMFS_VOLUME, { mode: 'monorepo' }),
+    ).resolves.toStrictEqual({ mode: 'standalone', tool: null });
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('falling back to standalone'),
+    );
+  });
+
   it('should auto-select monorepo when --yes and tool detected', async () => {
-    await expect(promptSetupMode('nx', { yes: true })).resolves.toBe(
-      'monorepo',
+    vol.fromJSON(
+      { 'pnpm-workspace.yaml': 'packages:\n  - packages/*' },
+      MEMFS_VOLUME,
     );
+
+    await expect(
+      promptSetupMode(MEMFS_VOLUME, { yes: true }),
+    ).resolves.toStrictEqual({ mode: 'monorepo', tool: 'pnpm' });
     expect(select).not.toHaveBeenCalled();
   });
 
   it('should auto-select standalone when --yes and no tool', async () => {
-    await expect(promptSetupMode(null, { yes: true })).resolves.toBe(
-      'standalone',
-    );
+    vol.fromJSON({ 'package.json': '{}' }, MEMFS_VOLUME);
+
+    await expect(
+      promptSetupMode(MEMFS_VOLUME, { yes: true }),
+    ).resolves.toStrictEqual({ mode: 'standalone', tool: null });
   });
 
   it('should prompt interactively with monorepo pre-selected when tool detected', async () => {
+    vol.fromJSON(
+      { 'pnpm-workspace.yaml': 'packages:\n  - packages/*' },
+      MEMFS_VOLUME,
+    );
     vi.mocked(select).mockResolvedValue('monorepo');
 
-    await promptSetupMode('pnpm', {});
+    await promptSetupMode(MEMFS_VOLUME, {});
 
     expect(select).toHaveBeenCalledWith(
       expect.objectContaining({ default: 'monorepo' }),
     );
   });
 
-  it('should prompt interactively with standalone pre-selected when no tool detected', async () => {
+  it('should prompt interactively with standalone pre-selected when no tool', async () => {
+    vol.fromJSON({ 'package.json': '{}' }, MEMFS_VOLUME);
     vi.mocked(select).mockResolvedValue('standalone');
 
-    await promptSetupMode(null, {});
+    await promptSetupMode(MEMFS_VOLUME, {});
 
     expect(select).toHaveBeenCalledWith(
       expect.objectContaining({ default: 'standalone' }),
     );
   });
+
+  it('should fall back to standalone with warning when user selects monorepo but no tool detected', async () => {
+    vol.fromJSON({ 'package.json': '{}' }, MEMFS_VOLUME);
+    vi.mocked(select).mockResolvedValue('monorepo');
+
+    await expect(promptSetupMode(MEMFS_VOLUME, {})).resolves.toStrictEqual({
+      mode: 'standalone',
+      tool: null,
+    });
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('falling back to standalone'),
+    );
+  });
 });
 
 describe('addCodePushUpCommand', () => {

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

@@ -2,7 +2,6 @@ import path from 'node:path';
 import {
   type MonorepoTool,
   asyncSequential,
-  detectMonorepoTool,
   formatAsciiTable,
   getGitRoot,
   logger,
@@ -49,8 +48,7 @@ export async function runSetupWizard(
 ): Promise<void> {
   const targetDir = cliArgs['target-dir'] ?? process.cwd();
 
-  const tool = await detectMonorepoTool(targetDir);
-  const mode = await promptSetupMode(tool, cliArgs);
+  const { mode, tool } = await promptSetupMode(targetDir, cliArgs);
   const selectedBindings = await promptPluginSelection(
     bindings,
     targetDir,
@@ -66,7 +64,7 @@ export async function runSetupWizard(
     selectedBindings,
     async binding => ({
       scope: binding.scope ?? 'project',
-      result: await resolveBinding(binding, cliArgs, { tool, mode }),
+      result: await resolveBinding(binding, cliArgs, { mode, tool }),
     }),
   );