feat: normalize all package manager execute commands in translateExecuteCommand

Rename translateNpxCommand to translateExecuteCommand and extend it to
recognize all known execute-command formats (npx, bunx, pnpx, pnpm dlx,
yarn dlx, deno run npm:*). This ensures add-on commands specified in any
format are correctly translated to the user's chosen package manager.

Author: Inv1x

packages/create/src/create-app.ts

@@ -6,6 +6,7 @@ import { writeConfigFileToEnvironment } from './config-file.js'
 import {
   getPackageManagerScriptCommand,
   packageManagerInstall,
+  translateExecuteCommand,
 } from './package-manager.js'
 import { createPackageJSON } from './package-json.js'
 import { createTemplateFile } from './template-file.js'
@@ -181,18 +182,19 @@ async function runCommandsAndInstallDependencies(
         addOn.phase === phase && addOn.command && addOn.command.command,
     )) {
       s.start(`Running commands for ${addOn.name}...`)
-      const cmd = formatCommand({
+      const translated = translateExecuteCommand(options.packageManager, {
         command: addOn.command!.command,
         args: addOn.command!.args || [],
       })
+      const cmd = formatCommand(translated)
       environment.startStep({
         id: 'run-commands',
         type: 'command',
         message: cmd,
       })
       await environment.execute(
-        addOn.command!.command,
-        addOn.command!.args || [],
+        translated.command,
+        translated.args,
         options.targetDir,
         { inherit: true },
       )
@@ -208,19 +210,20 @@ async function runCommandsAndInstallDependencies(
     options.starter.command.command
   ) {
     s.start(`Setting up starter ${options.starter.name}...`)
-    const cmd = formatCommand({
+    const starterTranslated = translateExecuteCommand(options.packageManager, {
       command: options.starter.command.command,
       args: options.starter.command.args || [],
     })
+    const cmd = formatCommand(starterTranslated)
     environment.startStep({
       id: 'run-starter-command',
       type: 'command',
       message: cmd,
     })
 
     await environment.execute(
-      options.starter.command.command,
-      options.starter.command.args || [],
+      starterTranslated.command,
+      starterTranslated.args,
       options.targetDir,
       { inherit: true },
     )

packages/create/src/package-manager.ts

@@ -101,6 +101,43 @@ export function packageManagerInstall(
   return environment.execute(command, commandArgs, cwd)
 }
 
+export function translateExecuteCommand(
+  packageManager: PackageManager,
+  command: { command: string; args?: Array<string> },
+): { command: string; args: Array<string> } {
+  const args = command.args || []
+  const parsed = parseExecuteCommand(command.command, args)
+  if (parsed) {
+    return getPackageManagerExecuteCommand(packageManager, parsed.pkg, parsed.args)
+  }
+  return { command: command.command, args }
+}
+
+function parseExecuteCommand(
+  command: string,
+  args: Array<string>,
+): { pkg: string; args: Array<string> } | null {
+  if (command === 'npx') {
+    const filtered = args[0] === '-y' ? args.slice(1) : args
+    const [pkg, ...rest] = filtered
+    return pkg ? { pkg, args: rest } : null
+  }
+  if (command === 'pnpx' || command === 'bunx') {
+    const filtered = command === 'bunx' && args[0] === '--bun' ? args.slice(1) : args
+    const [pkg, ...rest] = filtered
+    return pkg ? { pkg, args: rest } : null
+  }
+  if ((command === 'pnpm' || command === 'yarn') && args[0] === 'dlx') {
+    const [, pkg, ...rest] = args
+    return pkg ? { pkg, args: rest } : null
+  }
+  if (command === 'deno' && args[0] === 'run' && args[1]?.startsWith('npm:')) {
+    const pkg = args[1].slice(4)
+    return pkg ? { pkg, args: args.slice(2) } : null
+  }
+  return null
+}
+
 export function packageManagerExecute(
   environment: Environment,
   cwd: string,

packages/create/tests/package-manager.test.ts

@@ -4,6 +4,7 @@ import {
   getPackageManagerExecuteCommand,
   getPackageManagerInstallCommand,
   getPackageManagerScriptCommand,
+  translateExecuteCommand,
 } from '../src/package-manager.js'
 import { formatCommand } from '../src/utils.js'
 
@@ -152,3 +153,161 @@ describe('getPackageManagerInstallCommand', () => {
     ).toBe('npm install vitest -D')
   })
 })
+
+describe('translateExecuteCommand', () => {
+  it('should translate npx to bunx for bun', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('bun', {
+          command: 'npx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('bunx --bun shadcn add button')
+  })
+  it('should translate npx to pnpm dlx for pnpm', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('pnpm', {
+          command: 'npx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('pnpm dlx shadcn add button')
+  })
+  it('should translate npx to yarn dlx for yarn', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('yarn', {
+          command: 'npx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('yarn dlx shadcn add button')
+  })
+  it('should translate npx to deno run for deno', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('deno', {
+          command: 'npx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('deno run npm:shadcn add button')
+  })
+  it('should keep npx -y for npm', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('npm', {
+          command: 'npx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('npx -y shadcn add button')
+  })
+  it('should pass through non-npx commands unchanged', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('bun', {
+          command: 'node',
+          args: ['script.js'],
+        }),
+      ),
+    ).toBe('node script.js')
+  })
+  it('should handle missing args gracefully', () => {
+    expect(
+      formatCommand(translateExecuteCommand('bun', { command: 'npx' })),
+    ).toBe('npx')
+  })
+  it('should strip -y flag from npx input', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('pnpm', {
+          command: 'npx',
+          args: ['-y', 'shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('pnpm dlx shadcn add button')
+  })
+  it('should translate bunx to target package manager', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('pnpm', {
+          command: 'bunx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('pnpm dlx shadcn add button')
+  })
+  it('should strip --bun flag from bunx input', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('pnpm', {
+          command: 'bunx',
+          args: ['--bun', 'shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('pnpm dlx shadcn add button')
+  })
+  it('should translate pnpx to target package manager', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('yarn', {
+          command: 'pnpx',
+          args: ['shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('yarn dlx shadcn add button')
+  })
+  it('should translate pnpm dlx to target package manager', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('bun', {
+          command: 'pnpm',
+          args: ['dlx', 'shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('bunx --bun shadcn add button')
+  })
+  it('should translate yarn dlx to target package manager', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('npm', {
+          command: 'yarn',
+          args: ['dlx', 'shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('npx -y shadcn add button')
+  })
+  it('should translate deno run npm: to target package manager', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('pnpm', {
+          command: 'deno',
+          args: ['run', 'npm:shadcn', 'add', 'button'],
+        }),
+      ),
+    ).toBe('pnpm dlx shadcn add button')
+  })
+  it('should pass through non-execute pnpm commands unchanged', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('bun', {
+          command: 'pnpm',
+          args: ['install'],
+        }),
+      ),
+    ).toBe('pnpm install')
+  })
+  it('should pass through non-execute deno commands unchanged', () => {
+    expect(
+      formatCommand(
+        translateExecuteCommand('npm', {
+          command: 'deno',
+          args: ['task', 'dev'],
+        }),
+      ),
+    ).toBe('deno task dev')
+  })
+})