@quenty/nevermore-cli 4.43.3 → 4.43.4

package/src/commands/install-package-command.ts

@@ -6,9 +6,17 @@ import { Argv, CommandModule } from 'yargs';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import { NevermoreGlobalArgs } from '../args/global-args.js';
 import { runCommandAsync } from '../utils/nevermore-cli-utils.js';
+import {
+  buildAddPackagesCommand,
+  detectPackageManagerAsync,
+  isPackageManager,
+  PACKAGE_MANAGERS,
+  PackageManager,
+} from '../utils/package-manager-utils.js';
 
 export interface InstallPackageArgs extends NevermoreGlobalArgs {
   packages: string[];
+  packageManager?: string;
 }
 
 /**
@@ -27,19 +35,65 @@ export class InstallPackageCommand<T>
     }
   }
 
+  /**
+   * Lists the published `@quenty/*` package names, without the scope.
+   *
+   * The registry caps search results at 250 per request, well under the number
+   * of published packages, so this pages through until the reported total is
+   * covered.
+   */
   private static async _getPackages(): Promise<string[]> {
+    const pageSize = 250;
+    const names = new Set<string>();
+
+    try {
+      let from = 0;
+      for (;;) {
+        const response = await fetch(
+          `https://registry.npmjs.org/-/v1/search?text=@quenty/&size=${pageSize}&from=${from}`
+        );
+        const data = await response.json();
+        const objects: any[] = data.objects ?? [];
+
+        for (const entry of objects) {
+          const name: string = entry.package?.name ?? '';
+          if (name.startsWith('@quenty/')) {
+            names.add(name.slice('@quenty/'.length));
+          }
+        }
+
+        from += objects.length;
+        if (objects.length < pageSize || from >= (data.total ?? 0)) {
+          break;
+        }
+      }
+    } catch {
+      return [];
+    }
+
+    return [...names].sort();
+  }
+
+  /**
+   * Asks the registry about one package directly. Returns undefined when the
+   * registry can't be reached, so an offline run doesn't look like a typo.
+   */
+  private static async _packageExistsAsync(
+    scopedName: string
+  ): Promise<boolean | undefined> {
     try {
       const response = await fetch(
-        'https://registry.npmjs.org/-/v1/search?text=@quenty/&size=1000'
+        `https://registry.npmjs.org/${scopedName.replace('/', '%2f')}`,
+        { method: 'HEAD' }
       );
-      const data = await response.json();
-      return data.objects
-        .map((obj: any) => obj.package.name)
-        .filter((name: string) => name.startsWith('@quenty/'))
-        .map((name: string) => name.replace('@quenty/', ''))
-        .sort();
+
+      if (response.status === 404) {
+        return false;
+      }
+
+      return response.ok ? true : undefined;
     } catch {
-      return [];
+      return undefined;
     }
   }
 
@@ -53,9 +107,34 @@ export class InstallPackageCommand<T>
         return packages.filter((name) => !current || name.startsWith(current));
       },
     });
+    args.option('package-manager', {
+      describe:
+        'Package manager to install with. Detected from the project by default.',
+      type: 'string',
+      choices: PACKAGE_MANAGERS as unknown as string[],
+    });
     return args as Argv<InstallPackageArgs>;
   }
 
+  private static async _resolvePackageManagerAsync(
+    args: InstallPackageArgs,
+    srcRoot: string
+  ): Promise<PackageManager> {
+    const requested = args.packageManager;
+    if (requested) {
+      if (!isPackageManager(requested)) {
+        throw new Error(
+          `Unsupported package manager '${requested}'. Expected one of: ${PACKAGE_MANAGERS.join(
+            ', '
+          )}`
+        );
+      }
+      return requested;
+    }
+
+    return detectPackageManagerAsync(srcRoot);
+  }
+
   public async handler(args: InstallPackageArgs) {
     const srcRoot = process.cwd();
 
@@ -67,22 +146,36 @@ export class InstallPackageCommand<T>
       InstallPackageCommand._validatePackageName(packageName)
     );
 
-    const availablePackages = await InstallPackageCommand._getPackages();
+    const prefixedPackages = args.packages.map(
+      (packageName) => `@quenty/${packageName}`
+    );
+
+    const existence = await Promise.all(
+      prefixedPackages.map((scopedName) =>
+        InstallPackageCommand._packageExistsAsync(scopedName)
+      )
+    );
     const invalidPackages = args.packages.filter(
-      (packageName) => !availablePackages.includes(packageName)
+      (_, index) => existence[index] === false
     );
 
     if (invalidPackages.length > 0) {
       throw new Error(`Invalid packages: ${invalidPackages.join(', ')}`);
     }
 
-    const prefixedPackages = args.packages.map(
-      (packageName) => `@quenty/${packageName}`
+    const packageManager =
+      await InstallPackageCommand._resolvePackageManagerAsync(args, srcRoot);
+
+    OutputHelper.info(
+      `Installing packages with ${packageManager}: ${args.packages.join(', ')}`
     );
 
-    OutputHelper.info(`Installing packages: ${args.packages.join(', ')}`);
+    const { command, args: commandArgs } = buildAddPackagesCommand(
+      packageManager,
+      prefixedPackages
+    );
 
-    await runCommandAsync(args, 'npm', ['install', ...prefixedPackages], {
+    await runCommandAsync(args, command, commandArgs, {
       cwd: srcRoot,
     });
   }

package/src/utils/package-manager-utils.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  buildAddPackagesCommand,
+  detectPackageManagerAsync,
+  isPackageManager,
+} from './package-manager-utils.js';
+
+describe('package-manager-utils', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'nevermore-pm-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  async function writeFileAsync(relativePath: string, contents: string) {
+    const filePath = path.join(root, relativePath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, contents);
+  }
+
+  describe('detectPackageManagerAsync', () => {
+    it('reads the packageManager field', async () => {
+      await writeFileAsync(
+        'package.json',
+        JSON.stringify({ packageManager: 'pnpm@10.27.0' })
+      );
+
+      expect(await detectPackageManagerAsync(root)).toBe('pnpm');
+    });
+
+    it('prefers the packageManager field over a lockfile', async () => {
+      await writeFileAsync(
+        'package.json',
+        JSON.stringify({ packageManager: 'yarn@4.0.0' })
+      );
+      await writeFileAsync('package-lock.json', '{}');
+
+      expect(await detectPackageManagerAsync(root)).toBe('yarn');
+    });
+
+    it('falls back to lockfiles', async () => {
+      await writeFileAsync('package.json', JSON.stringify({ name: 'game' }));
+      await writeFileAsync('pnpm-lock.yaml', '');
+
+      expect(await detectPackageManagerAsync(root)).toBe('pnpm');
+    });
+
+    it('treats a pnpm workspace file as pnpm', async () => {
+      await writeFileAsync('pnpm-workspace.yaml', 'packages:\n');
+
+      expect(await detectPackageManagerAsync(root)).toBe('pnpm');
+    });
+
+    it('walks up from a subdirectory', async () => {
+      await writeFileAsync(
+        'package.json',
+        JSON.stringify({ packageManager: 'pnpm@10.27.0' })
+      );
+      await fs.mkdir(path.join(root, 'src', 'shared'), { recursive: true });
+
+      expect(
+        await detectPackageManagerAsync(path.join(root, 'src', 'shared'))
+      ).toBe('pnpm');
+    });
+
+    it('lets the nearest project win', async () => {
+      await writeFileAsync(
+        'package.json',
+        JSON.stringify({ packageManager: 'pnpm@10.27.0' })
+      );
+      await writeFileAsync(
+        'nested/package.json',
+        JSON.stringify({ packageManager: 'yarn@4.0.0' })
+      );
+
+      expect(await detectPackageManagerAsync(path.join(root, 'nested'))).toBe(
+        'yarn'
+      );
+    });
+
+    it('ignores an unknown packageManager field', async () => {
+      await writeFileAsync(
+        'package.json',
+        JSON.stringify({ packageManager: 'cnpm@1.0.0' })
+      );
+      await writeFileAsync('yarn.lock', '');
+
+      expect(await detectPackageManagerAsync(root)).toBe('yarn');
+    });
+
+    it('survives malformed package.json', async () => {
+      await writeFileAsync('package.json', '{ not json');
+      await writeFileAsync('pnpm-lock.yaml', '');
+
+      expect(await detectPackageManagerAsync(root)).toBe('pnpm');
+    });
+
+    it('defaults to pnpm', async () => {
+      expect(await detectPackageManagerAsync(root)).toBe('pnpm');
+    });
+
+    it('still honors an npm project', async () => {
+      await writeFileAsync('package.json', JSON.stringify({ name: 'game' }));
+      await writeFileAsync('package-lock.json', '{}');
+
+      expect(await detectPackageManagerAsync(root)).toBe('npm');
+    });
+  });
+
+  describe('buildAddPackagesCommand', () => {
+    it('uses install for npm', () => {
+      expect(buildAddPackagesCommand('npm', ['@quenty/blend'])).toEqual({
+        command: 'npm',
+        args: ['install', '@quenty/blend'],
+      });
+    });
+
+    it('uses add for everything else', () => {
+      expect(buildAddPackagesCommand('pnpm', ['@quenty/blend'])).toEqual({
+        command: 'pnpm',
+        args: ['add', '@quenty/blend'],
+      });
+      expect(buildAddPackagesCommand('yarn', ['@quenty/maid'])).toEqual({
+        command: 'yarn',
+        args: ['add', '@quenty/maid'],
+      });
+      expect(buildAddPackagesCommand('bun', ['@quenty/maid'])).toEqual({
+        command: 'bun',
+        args: ['add', '@quenty/maid'],
+      });
+    });
+  });
+
+  describe('isPackageManager', () => {
+    it('accepts known managers and rejects others', () => {
+      expect(isPackageManager('pnpm')).toBe(true);
+      expect(isPackageManager('deno')).toBe(false);
+    });
+  });
+});

package/src/utils/package-manager-utils.ts

@@ -0,0 +1,115 @@
+/**
+ * Detects which package manager owns a project so commands install with the
+ * same tool the project was set up with.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export const PACKAGE_MANAGERS = ['pnpm', 'npm', 'yarn', 'bun'] as const;
+
+export type PackageManager = typeof PACKAGE_MANAGERS[number];
+
+export const DEFAULT_PACKAGE_MANAGER: PackageManager = 'pnpm';
+
+const LOCKFILES: ReadonlyArray<readonly [string, PackageManager]> = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['pnpm-workspace.yaml', 'pnpm'],
+  ['bun.lock', 'bun'],
+  ['bun.lockb', 'bun'],
+  ['yarn.lock', 'yarn'],
+  ['package-lock.json', 'npm'],
+];
+
+export function isPackageManager(value: string): value is PackageManager {
+  return (PACKAGE_MANAGERS as readonly string[]).includes(value);
+}
+
+function parsePackageManagerField(value: unknown): PackageManager | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const name = value.split('@')[0]?.trim();
+  if (name && isPackageManager(name)) {
+    return name;
+  }
+
+  return undefined;
+}
+
+async function detectInDirectoryAsync(
+  directory: string
+): Promise<PackageManager | undefined> {
+  try {
+    const contents = await fs.readFile(
+      path.join(directory, 'package.json'),
+      'utf-8'
+    );
+    const parsed = JSON.parse(contents) as { packageManager?: unknown };
+    const declared = parsePackageManagerField(parsed.packageManager);
+    if (declared) {
+      return declared;
+    }
+  } catch {
+    // No readable package.json here, fall through to lockfiles
+  }
+
+  for (const [fileName, packageManager] of LOCKFILES) {
+    try {
+      await fs.access(path.join(directory, fileName));
+      return packageManager;
+    } catch {
+      continue;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Detects the package manager for a project, walking up from the given
+ * directory so this works from a subfolder of the project.
+ *
+ * A `packageManager` field wins over a lockfile in the same directory, and the
+ * nearest directory with either wins over anything further up. Falls back to
+ * pnpm: Nevermore projects are pnpm projects — the templates pin it and gate it
+ * behind `only-allow pnpm` — so pnpm is the right guess for a directory that
+ * hasn't declared anything yet.
+ */
+export async function detectPackageManagerAsync(
+  startDirectory: string
+): Promise<PackageManager> {
+  let directory = path.resolve(startDirectory);
+
+  for (;;) {
+    const detected = await detectInDirectoryAsync(directory);
+    if (detected) {
+      return detected;
+    }
+
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+
+  return DEFAULT_PACKAGE_MANAGER;
+}
+
+/**
+ * Builds the command that adds dependencies to a project. Only npm spells this
+ * `install`; the rest treat a bare `install` as "install the lockfile" and need
+ * `add` to record new dependencies.
+ */
+export function buildAddPackagesCommand(
+  packageManager: PackageManager,
+  packages: string[]
+): { command: string; args: string[] } {
+  if (packageManager === 'npm') {
+    return { command: 'npm', args: ['install', ...packages] };
+  }
+
+  return { command: packageManager, args: ['add', ...packages] };
+}