@untestutils/cli 0.5.4 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@untestutils/cli",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "description": "CLI for untestutils: init, convert, ai, doctor, and monorepo commands",
   "homepage": "https://s00d.github.io/untestutils/",
   "license": "MIT",
@@ -40,9 +40,9 @@
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.17",
     "tsx": "^4.23.13",
-    "@untestutils/ai": "0.5.4",
-    "@untestutils/perf": "0.5.4",
-    "@untestutils/core": "0.5.4"
+    "@untestutils/perf": "0.6.1",
+    "@untestutils/ai": "0.6.1",
+    "@untestutils/core": "0.6.1"
   },
   "devDependencies": {
     "@types/node": "^26.6.1",

package/src/commands/doctor.ts

@@ -1,8 +1,9 @@
 import { defineCommand, type CommandDef } from 'citty';
 import { consola } from 'consola';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve, join } from 'pathe';
 import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { findMonorepoRoot } from '../utils/workspace';
 
 type Check = { ok: boolean; label: string; hint?: string; optional?: boolean };
@@ -17,89 +18,222 @@ function canResolve(id: string, cwd: string): boolean {
   }
 }
 
+function readPkgVersion(id: string, cwd: string): string | undefined {
+  try {
+    const req = createRequire(join(cwd, 'package.json'));
+    const pkgJson = req.resolve(`${id}/package.json`);
+    const ver = (JSON.parse(readFileSync(pkgJson, 'utf8')) as { version?: string }).version;
+    return ver;
+  } catch {
+    return undefined;
+  }
+}
+
+function findRecipesFile(cwd: string): string | undefined {
+  for (const rel of ['recipes.ts', 'tests/recipes.ts', 'e2e/recipes.ts', 'recipes.mts']) {
+    const p = join(cwd, rel);
+    if (existsSync(p)) return p;
+  }
+  return undefined;
+}
+
+function hasPlaywrightConfig(cwd: string): boolean {
+  return ['playwright.config.ts', 'playwright.config.mts', 'playwright.config.js'].some((f) =>
+    existsSync(join(cwd, f)),
+  );
+}
+
+function fileMentions(cwd: string, needle: string): boolean {
+  const candidates = [
+    'recipes.ts',
+    'vitest.config.ts',
+    'vitest.config.mts',
+    'playwright.config.ts',
+    'package.json',
+  ];
+  for (const rel of candidates) {
+    const p = join(cwd, rel);
+    if (!existsSync(p)) continue;
+    try {
+      if (readFileSync(p, 'utf8').includes(needle)) return true;
+    } catch {
+      /* skip */
+    }
+  }
+  return false;
+}
+
+async function runDoctorChecks(cwd: string): Promise<number> {
+  const checks: Check[] = [];
+  const mono = findMonorepoRoot(cwd);
+  const inMono = Boolean(mono && (cwd === mono || cwd.startsWith(`${mono}/`)));
+
+  const major = Number(process.versions.node.split('.')[0]);
+  checks.push({
+    ok: major >= 20,
+    label: `Node.js ${process.version}`,
+    hint: 'Requires Node >= 20',
+  });
+
+  for (const id of ['untestutils', 'vitest'] as const) {
+    checks.push({
+      ok: canResolve(id, cwd) || inMono,
+      label: `package ${id}`,
+      hint: `pnpm add -D ${id}`,
+    });
+  }
+
+  const vitestVer = readPkgVersion('vitest', cwd);
+  if (vitestVer) {
+    const vitestMajor = Number(vitestVer.split('.')[0]);
+    checks.push({
+      ok: vitestMajor === 4 || vitestMajor === 5,
+      label: `vitest major ${vitestMajor} (${vitestVer})`,
+      hint: 'Supported majors: 4 or 5 (peer ^4 || ^5)',
+    });
+  } else if (!inMono) {
+    checks.push({
+      ok: false,
+      label: 'vitest version',
+      hint: 'pnpm add -D vitest@^4 || vitest@^5',
+    });
+  }
+
+  const needsPw = hasPlaywrightConfig(cwd);
+  const hasPw = canResolve('@playwright/test', cwd) || inMono;
+  checks.push({
+    ok: !needsPw || hasPw,
+    optional: !needsPw,
+    label: needsPw ? '@playwright/test (playwright.config present)' : 'optional: @playwright/test',
+    hint: 'pnpm add -D @playwright/test playwright-core',
+  });
+
+  for (const id of ['playwright-core', 'nuxt', '@untestutils/nuxt'] as const) {
+    const ok = canResolve(id, cwd) || (inMono && id !== 'nuxt' && id !== '@untestutils/nuxt');
+    checks.push({
+      ok,
+      optional: true,
+      label: `optional: ${id}`,
+      hint: ok ? undefined : `needed for the matching preset (pnpm add -D ${id})`,
+    });
+  }
+
+  if (fileMentions(cwd, 'untestutils/perf') || fileMentions(cwd, '@untestutils/perf')) {
+    const ok = canResolve('@untestutils/perf', cwd) || inMono;
+    checks.push({
+      ok,
+      optional: true,
+      label: 'optional: @untestutils/perf (imported)',
+      hint: ok ? undefined : 'pnpm add -D @untestutils/perf',
+    });
+  }
+
+  if (fileMentions(cwd, 'untestutils/ai') || fileMentions(cwd, '@untestutils/ai')) {
+    const ok = canResolve('@untestutils/ai', cwd) || inMono;
+    checks.push({
+      ok,
+      optional: true,
+      label: 'optional: @untestutils/ai (imported)',
+      hint: ok ? undefined : 'pnpm add -D @untestutils/ai',
+    });
+  }
+
+  const configCandidates = [
+    'vitest.config.ts',
+    'vitest.config.mts',
+    'vitest.config.js',
+    'playwright.config.ts',
+    'playwright.config.mts',
+    'vitest.unit.config.ts',
+  ];
+  const hasConfig = inMono || configCandidates.some((f) => existsSync(join(cwd, f)));
+  checks.push({
+    ok: hasConfig,
+    label: 'vitest/playwright config',
+    hint: 'untestutils init --preset vitest',
+  });
+
+  const recipesFile = findRecipesFile(cwd);
+  checks.push({
+    ok: inMono || Boolean(recipesFile),
+    label: 'recipes.ts',
+    hint: 'create defineRecipes(...) or run init',
+  });
+
+  let failed = 0;
+  for (const c of checks) {
+    if (c.ok) {
+      consola.success(c.label);
+    } else if (c.optional) {
+      consola.info(`${c.label}${c.hint ? ` — ${c.hint}` : ''}`);
+    } else {
+      failed++;
+      consola.error(`${c.label}${c.hint ? ` — ${c.hint}` : ''}`);
+    }
+  }
+  return failed;
+}
+
+async function listRecipes(cwd: string): Promise<void> {
+  const recipesFile = findRecipesFile(cwd);
+  if (!recipesFile) {
+    consola.error('No recipes.ts found (looked for recipes.ts, tests/recipes.ts, e2e/recipes.ts)');
+    process.exitCode = 1;
+    return;
+  }
+  consola.start(`Loading ${recipesFile}`);
+  try {
+    const mod = (await import(pathToFileURL(recipesFile).href)) as {
+      recipes?: Record<string, { id?: string }>;
+    };
+    const map = mod.recipes;
+    if (!map || typeof map !== 'object') {
+      consola.error('recipes module must export `recipes` from defineRecipes(...)');
+      process.exitCode = 1;
+      return;
+    }
+    const ids = Object.entries(map).map(([key, recipe]) => recipe?.id ?? key);
+    if (ids.length === 0) {
+      consola.warn('No recipes registered');
+      return;
+    }
+    consola.success(`Recipes (${ids.length}):`);
+    for (const id of ids.sort()) {
+      consola.log(`  - ${id}`);
+    }
+  } catch (e) {
+    consola.error(`Failed to load recipes: ${e}`);
+    consola.info('Ensure dependencies are installed and the recipes module can be imported.');
+    process.exitCode = 1;
+  }
+}
+
 const doctorArgs = {
   cwd: {
     type: 'string',
     description: 'Project directory',
     default: '.',
   },
+  recipes: {
+    type: 'boolean',
+    description: 'List recipe ids from defineRecipes export',
+    default: false,
+  },
 } as const;
 
 export const doctorCommand: CommandDef<typeof doctorArgs> = defineCommand({
   meta: {
     name: 'doctor',
-    description: 'Check untestutils environment and configs',
+    description: 'Check untestutils environment and configs (use --recipes to list ids)',
   },
   args: doctorArgs,
   async run({ args }) {
     const cwd = resolve(String(args.cwd));
-    const checks: Check[] = [];
-    const mono = findMonorepoRoot(cwd);
-    const inMono = Boolean(mono && (cwd === mono || cwd.startsWith(`${mono}/`)));
-
-    const major = Number(process.versions.node.split('.')[0]);
-    checks.push({
-      ok: major >= 20,
-      label: `Node.js ${process.version}`,
-      hint: 'Requires Node >= 20',
-    });
-
-    for (const id of ['untestutils', 'vitest'] as const) {
-      checks.push({
-        ok: canResolve(id, cwd) || inMono,
-        label: `package ${id}`,
-        hint: `pnpm add -D ${id}`,
-      });
-    }
-
-    for (const id of ['@playwright/test', 'playwright-core', 'nuxt'] as const) {
-      const ok = canResolve(id, cwd) || (inMono && id !== 'nuxt');
-      checks.push({
-        ok,
-        optional: true,
-        label: `optional: ${id}`,
-        hint: ok ? undefined : `needed for the matching preset (pnpm add -D ${id})`,
-      });
+    if (args.recipes) {
+      await listRecipes(cwd);
+      return;
     }
-
-    const configCandidates = [
-      'vitest.config.ts',
-      'vitest.config.mts',
-      'vitest.config.js',
-      'playwright.config.ts',
-      'playwright.config.mts',
-      'vitest.unit.config.ts',
-    ];
-    const hasConfig = inMono || configCandidates.some((f) => existsSync(join(cwd, f)));
-    checks.push({
-      ok: hasConfig,
-      label: 'vitest/playwright config',
-      hint: 'untestutils init --preset vitest',
-    });
-
-    const hasRecipes =
-      inMono ||
-      existsSync(join(cwd, 'recipes.ts')) ||
-      existsSync(join(cwd, 'tests/recipes.ts')) ||
-      existsSync(join(cwd, 'e2e/recipes.ts'));
-    checks.push({
-      ok: hasRecipes,
-      label: 'recipes.ts',
-      hint: 'create defineRecipes(...) or run init',
-    });
-
-    let failed = 0;
-    for (const c of checks) {
-      if (c.ok) {
-        consola.success(c.label);
-      } else if (c.optional) {
-        consola.info(`${c.label}${c.hint ? ` — ${c.hint}` : ''}`);
-      } else {
-        failed++;
-        consola.error(`${c.label}${c.hint ? ` — ${c.hint}` : ''}`);
-      }
-    }
-
+    const failed = await runDoctorChecks(cwd);
     if (failed > 0) {
       consola.warn(`Issues: ${failed}`);
       process.exitCode = 1;

package/src/commands/init.ts

@@ -2,9 +2,15 @@ import { defineCommand, type CommandDef } from 'citty';
 import { consola } from 'consola';
 import { addDependency } from 'nypm';
 import { resolve } from 'pathe';
-import { applyPreset, peersForPreset, type InitPreset } from '../utils/templates';
+import {
+  applyPreset,
+  peersForPreset,
+  type InitPreset,
+  type PackageManagerName,
+} from '../utils/templates';
 
 const PRESETS: InitPreset[] = ['vitest', 'playwright', 'nuxt', 'full'];
+const PMS: PackageManagerName[] = ['npm', 'pnpm', 'yarn', 'bun'];
 
 const initArgs = {
   preset: {
@@ -25,9 +31,13 @@ const initArgs = {
   },
   install: {
     type: 'boolean',
-    description: 'Install peer dependencies via nypm',
+    description: 'Install peer dependencies via nypm (use --no-install to skip)',
     default: true,
   },
+  pm: {
+    type: 'string',
+    description: 'Package manager: pnpm | npm | yarn | bun (default: auto-detect, else pnpm)',
+  },
 } as const;
 
 export const initCommand: CommandDef<typeof initArgs> = defineCommand({
@@ -57,20 +67,32 @@ export const initCommand: CommandDef<typeof initArgs> = defineCommand({
       consola.start(`Installing dependencies: ${deps.join(', ')}`);
       try {
         // Fresh projects often have no lockfile — nypm cannot auto-detect. Prefer
-        // detected PM, else pnpm (matches engines/docs), always as -D.
+        // --pm, else detected PM, else pnpm (matches engines/docs), always as -D.
+        const pmArg = args.pm ? String(args.pm) : undefined;
+        if (pmArg && !PMS.includes(pmArg as PackageManagerName)) {
+          consola.error(`Unknown --pm "${pmArg}". Available: ${PMS.join(', ')}`);
+          process.exitCode = 1;
+          return;
+        }
         const { detectPackageManager } = await import('nypm');
-        const detected = await detectPackageManager(cwd, { includeParentDirs: false });
+        const detected = pmArg
+          ? undefined
+          : await detectPackageManager(cwd, { includeParentDirs: false });
+        const packageManager =
+          (pmArg as PackageManagerName | undefined) ?? detected?.name ?? 'pnpm';
         await addDependency(deps, {
           cwd,
           silent: false,
-          packageManager: detected?.name ?? 'pnpm',
+          packageManager,
           dev: true,
         });
-        consola.success('Dependencies installed');
+        consola.success(`Dependencies installed (${packageManager})`);
       } catch (e) {
         consola.warn(`Could not install automatically: ${e}`);
         consola.info(`Install manually: ${deps.join(' ')}`);
       }
+    } else {
+      consola.info('Skipped install (--no-install). Install peers manually when ready.');
     }
 
     consola.box(
@@ -79,6 +101,7 @@ export const initCommand: CommandDef<typeof initArgs> = defineCommand({
         '  1. Review recipes.ts and fixture app paths',
         '  2. pnpm test / npx vitest run',
         '  3. untestutils doctor — environment check',
+        '  4. untestutils doctor --recipes — list recipe ids',
       ].join('\n'),
     );
   },

package/src/utils/templates.ts

@@ -5,7 +5,9 @@ import { writeIfMissing } from './fs';
 
 export type InitPreset = 'vitest' | 'playwright' | 'nuxt' | 'full';
 
-/** Relative template paths under src/templates */
+export type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun';
+
+/** Relative template paths under templates/ */
 const PRESET_FILES: Record<InitPreset, string[]> = {
   vitest: [
     'vitest/vitest.config.ts',
@@ -19,7 +21,14 @@ const PRESET_FILES: Record<InitPreset, string[]> = {
     'playwright/tests/e2e/smoke.spec.ts',
     'vitest/fixtures/basic/index.html',
   ],
-  nuxt: ['nuxt/vitest.config.ts', 'nuxt/recipes.ts', 'nuxt/tests/e2e/smoke.test.ts'],
+  nuxt: [
+    'nuxt/vitest.config.ts',
+    'nuxt/recipes.ts',
+    'nuxt/tests/e2e/smoke.test.ts',
+    'nuxt/fixtures/nuxt/package.json',
+    'nuxt/fixtures/nuxt/nuxt.config.ts',
+    'nuxt/fixtures/nuxt/app.vue',
+  ],
   full: [
     'vitest/vitest.config.ts',
     'playwright/playwright.config.ts',
@@ -64,7 +73,7 @@ export function peersForPreset(preset: InitPreset): string[] {
     base.push('@playwright/test', 'playwright-core');
   }
   if (preset === 'nuxt' || preset === 'full') {
-    base.push('nuxt');
+    base.push('nuxt', '@untestutils/nuxt', 'vitest-environment-untestutils');
   }
   return [...new Set(base)];
 }

package/templates/nuxt/fixtures/nuxt/app.vue

@@ -0,0 +1,5 @@
+<template>
+  <div>
+    <h1>nuxt fixture ok</h1>
+  </div>
+</template>

package/templates/nuxt/fixtures/nuxt/nuxt.config.ts

@@ -0,0 +1,4 @@
+export default defineNuxtConfig({
+  ssr: true,
+  compatibilityDate: '2024-11-01',
+});

package/templates/nuxt/fixtures/nuxt/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "untestutils-nuxt-fixture",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "nuxt dev",
+    "build": "nuxt build",
+    "preview": "nuxt preview"
+  }
+}