feat: offer to rerun with correct spelling of commands/args

Author: danielroe

packages/nuxt-cli/src/main.ts

@@ -11,13 +11,13 @@ import { provider } from 'std-env'
 import{description,name,version}from'../package.json'
 import{commands}from'./commands'
 import{cwdArgs,globalCwdArgs}from'./commands/_shared'
-import{runCommand,setCurrentCommand}from'./run'
+import{LONG_RUNNING_COMMANDS,runCommand,setCurrentCommand}from'./run'
 import{setupGlobalConsole}from'./utils/console'
 import{debug,logger}from'./utils/logger'
 import{setupProxySupport}from'./utils/network'
 import{findInPath,withLocalBinPath}from'./utils/path-env'
 import{templateNames}from'./utils/templates/names'
-import{findUnknownFlags,suggestFlags}from'./utils/unknown-args'
+import{findUnknownFlags,replaceFlag,suggestFlags}from'./utils/unknown-args'
 import{scheduleUpdateNudge}from'./utils/update-lazy'
 
 // Node.js only reads `NODE_USE_ENV_PROXY` during bootstrap, so this cannot make
@@ -78,7 +78,7 @@ const _main = defineCommand({
 // so a missing binary would otherwise look like one that ran and failed.
 constbinary=findInPath(`nuxt-${ctx.args.command}`,env)
 if(!binary){
-returnreportUnknownCommand(ctx.args.command)
+returnreportUnknownCommand(ctx.args.command,ctx.rawArgs)
 }
 const{ x }=awaitimport('tinyexec')
 // The resolved path is spawned rather than the bare name: `tinyexec` would
@@ -120,8 +120,33 @@ async function warnUnknownFlags(command: string, rawArgs: string[]): Promise<voi
 return
 }
 
-for(const{ flag, suggestion }ofawaitsuggestFlags(unknown)){
-logger.warn(`Unknown option ${styleText('cyan',flag)}.${suggestion ? ` Did you mean ${styleText('cyan',suggestion)}?` : ''}`)
+constsuggestions=awaitsuggestFlags(unknown)
+const{ isInteractive }=awaitimport('./utils/stdout')
+if(!isInteractive()){
+for(const{ flag, suggestion }ofsuggestions){
+logger.warn(`Unknown option ${styleText('cyan',flag)}.${suggestion ? ` Did you mean ${styleText('cyan',suggestion)}?` : ''}`)
+}
+return
+}
+
+const{ confirm, isCancel }=awaitimport('@clack/prompts')
+const{ restoreRawMode }=awaitimport('./utils/console')
+for(const{ flag, suggestion }ofsuggestions){
+if(!suggestion){
+logger.warn(`Unknown option ${styleText('cyan',flag)}.`)
+continue
+}
+// A negated unknown flag is matched against its bare name, so the offered
+// replacement has to restore the negation the user asked for.
+constreplacement=flag.startsWith('--no-')&&!suggestion.startsWith('--no-')
+ ? `--no-${suggestion.slice(2)}`
+ : suggestion
+logger.warn(`Unknown option ${styleText('cyan',flag)}.`)
+constanswer=awaitconfirm({message: `Use ${styleText('cyan',replacement)} instead?`,initialValue: true})
+restoreRawMode()
+if(!isCancel(answer)&&answer){
+replaceFlag(rawArgs,flag,replacement)
+}
 }
 }
 
@@ -133,17 +158,43 @@ function resolveLazy<T>(value: T | (() => T | Promise<T>) | undefined): Promise<
  * Report a command that neither the CLI nor a local `nuxt-` binary provides.
  *
  * With a confident suggestion this is the whole error, since a full help dump
- * buries the one line the user needs. Otherwise nothing is printed and citty
- * falls back to showing usage.
+ * buries the one line the user needs; interactively, the suggestion is offered
+ * to run directly. Otherwise nothing is printed and citty falls back to
+ * showing usage.
  */
-asyncfunctionreportUnknownCommand(command: string): Promise<void>{
+asyncfunctionreportUnknownCommand(command: string,rawArgs: string[]): Promise<void>{
 const{ suggestCommand }=awaitimport('./utils/suggest-command')
 constnames=Object.keys(commands).filter(name=>!name.startsWith('_'))
 constsuggestion=awaitsuggestCommand(command,names)
 if(!suggestion){
 return
 }
 
+const{ isInteractive }=awaitimport('./utils/stdout')
+if(isInteractive()){
+logger.warn(`Unknown command ${styleText('cyan',command)}.`)
+const{ confirm, isCancel }=awaitimport('@clack/prompts')
+constanswer=awaitconfirm({message: `Run ${styleText('cyan',`nuxt ${suggestion}`)} instead?`,initialValue: true})
+const{ restoreRawMode }=awaitimport('./utils/console')
+restoreRawMode()
+
+if(!isCancel(answer)&&answer){
+constindex=rawArgs.indexOf(command)
+constargv=index===-1 ? rawArgs : rawArgs.toSpliced(index,1)
+setCurrentCommand(suggestion)
+awaitrunCommand(suggestion,argv).catch((err)=>{
+console.error(err.message)
+process.exit(1)
+})
+if(LONG_RUNNING_COMMANDS.has(suggestion)){
+// Keep the process serving; exiting here, or returning to citty (which
+// would fail to resolve the unknown subcommand), would tear it down.
+awaitnewPromise(()=>{})
+}
+process.exit(0)
+}
+}
+
 logger.error(`Unknown command ${styleText('cyan',command)}. Did you mean ${styleText('cyan',`nuxt ${suggestion}`)}?`)
 logger.info(`Run ${styleText('cyan','nuxt --help')} to see all commands.`)
 process.exit(1)

packages/nuxt-cli/src/run.ts

@@ -20,7 +20,7 @@ globalThis.__nuxt_cli__ = globalThis.__nuxt_cli__ || {
 }
 
 // Commands that keep serving after their `run` resolves, so an alive process is expected.
-constLONG_RUNNING_COMMANDS=newSet(['dev','_dev','analyze','test'])
+exportconstLONG_RUNNING_COMMANDS: Set<string>=newSet(['dev','_dev','analyze','test'])
 
 letcurrentCommand: string|undefined
 

packages/nuxt-cli/src/utils/unknown-args.ts

@@ -58,6 +58,24 @@ export async function suggestFlags({ flags, known }: UnknownFlags): Promise<Arra
 }))
 }
 
+/**
+ * Rewrite every use of `--flag` (bare or `=value`) to `replacement`, in place:
+ * citty re-reads the same array when it resolves the subcommand, so an in-place
+ * edit is what makes the correction reach the command that runs.
+ */
+exportfunctionreplaceFlag(rawArgs: string[],flag: string,replacement: string): void{
+constseparator=rawArgs.indexOf('--')
+constend=separator===-1 ? rawArgs.length : separator
+for(leti=0;i<end;i++){
+if(rawArgs[i]===flag){
+rawArgs[i]=replacement
+}
+elseif(rawArgs[i]!.startsWith(`${flag}=`)){
+rawArgs[i]=`${replacement}${rawArgs[i]!.slice(flag.length)}`
+}
+}
+}
+
 /**
  * Dotted flags are declared either whole (`https.cert`) or as the object that
  * holds them (`https`), and a boolean may be negated with a `no-` prefix.

packages/nuxt-cli/test/unit/unknown-args.spec.ts

@@ -4,7 +4,7 @@ import { describe, expect, it } from 'vitest'
 
 import{commands}from'../../src/commands'
 import{cwdArgs}from'../../src/commands/_shared'
-import{findUnknownFlags,suggestFlags}from'../../src/utils/unknown-args'
+import{findUnknownFlags,replaceFlag,suggestFlags}from'../../src/utils/unknown-args'
 
 constargsDef={
 'cwd': {type: 'string'},
@@ -65,6 +65,26 @@ describe('suggestFlags', () => {
 })
 })
 
+describe('replaceFlag',()=>{
+it('should replace bare and `=value` forms in place',()=>{
+constrawArgs=['info','--cdw','.','--cdw=app','--json']
+replaceFlag(rawArgs,'--cdw','--cwd')
+expect(rawArgs).toEqual(['info','--cwd','.','--cwd=app','--json'])
+})
+
+it('should leave everything after `--` alone',()=>{
+constrawArgs=['dev','--prot=3000','--','--prot=4000']
+replaceFlag(rawArgs,'--prot','--port')
+expect(rawArgs).toEqual(['dev','--port=3000','--','--prot=4000'])
+})
+
+it('should not touch flags that merely share a prefix',()=>{
+constrawArgs=['dev','--ports=3000']
+replaceFlag(rawArgs,'--port','--p')
+expect(rawArgs).toEqual(['dev','--ports=3000'])
+})
+})
+
 describe('declared command arguments',()=>{
 it('should never be reported as unknown',async()=>{
 constreported: Record<string,string[]>={}