boolean opts

Author: AmirSa12

examples/demo.cac.ts

@@ -13,6 +13,7 @@ cli
   .command('dev', 'Start dev server')
   .option('-H, --host [host]', `Specify hostname`)
   .option('-p, --port <port>', `Specify port`)
+  .option('-v, --verbose', `Enable verbose logging`)
   .action((options) => {});
 
 cli
@@ -23,6 +24,8 @@ cli
 
 cli.command('dev build', 'Build project').action((options) => {});
 
+cli.command('dev start', 'Start development server').action((options) => {});
+
 cli
   .command('copy <source> <destination>', 'Copy files')
   .action((source, destination, options) => {});

examples/demo.citty.ts

@@ -53,6 +53,11 @@ const devCommand = defineCommand({
       description: 'Specify port',
       alias: 'p',
     },
+    verbose: {
+      type: 'boolean',
+      description: 'Enable verbose logging',
+      alias: 'v',
+    },
   },
   run: () => {},
 });
@@ -65,6 +70,14 @@ const buildCommand = defineCommand({
   run: () => {},
 });
 
+const startCommand = defineCommand({
+  meta: {
+    name: 'start',
+    description: 'Start development server',
+  },
+  run: () => {},
+});
+
 const copyCommand = defineCommand({
   meta: {
     name: 'copy',
@@ -100,9 +113,13 @@ const lintCommand = defineCommand({
   run: () => {},
 });
 
+devCommand.subCommands = {
+  build: buildCommand,
+  start: startCommand,
+};
+
 main.subCommands = {
   dev: devCommand,
-  build: buildCommand,
   copy: copyCommand,
   lint: lintCommand,
 } as Record<string, CommandDef<ArgsDef>>;

examples/demo.t.ts

@@ -62,6 +62,8 @@ devCmd.option(
   'p'
 );
 
+devCmd.option('verbose', 'Enable verbose logging', undefined, 'v', true);
+
 // Serve command
 const serveCmd = t.command('serve', 'Start the server');
 serveCmd.option(
@@ -87,6 +89,9 @@ serveCmd.option(
 // Build command
 t.command('dev build', 'Build project');
 
+// Start command
+t.command('dev start', 'Start development server');
+
 // Copy command with multiple arguments
 const copyCmd = t
   .command('copy', 'Copy files')

src/cac.ts

@@ -77,14 +77,19 @@ export default async function tab(
       const shortFlag = option.name.match(/^-([a-zA-Z]), --/)?.[1];
       const argName = option.name.replace(/^-[a-zA-Z], --/, '');
 
+      // Detect if this is a boolean option by checking if it has <value> or [value] in the raw definition
+      const isBoolean =
+        !option.rawName.includes('<') && !option.rawName.includes('[');
+
       // Add option using t.ts API
       const targetCommand = isRootCommand ? t : command;
       if (targetCommand) {
         targetCommand.option(
           argName, // Store just the option name without -- prefix
           option.description || '',
           commandCompletionConfig?.options?.[argName] ?? noopOptionHandler,
-          shortFlag
+          shortFlag,
+          isBoolean
         );
       }
     }

src/citty.ts

@@ -105,7 +105,7 @@ async function handleSubCommands(
 
     // Add command using t.ts API
     const commandName = parentCmd ? `${parentCmd} ${cmd}` : cmd;
-    const command = t.command(cmd, meta.description);
+    const command = t.command(commandName, meta.description);
 
     // Set args for the command if it has positional arguments
     if (isPositional && config.args) {
@@ -138,9 +138,6 @@ async function handleSubCommands(
     if (config.args) {
       for (const [argName, argConfig] of Object.entries(config.args)) {
         const conf = argConfig as ArgDef;
-        if (conf.type === 'positional') {
-          continue;
-        }
         // Extract alias from the config if it exists
         const shortFlag =
           typeof conf === 'object' && 'alias' in conf
@@ -150,11 +147,13 @@ async function handleSubCommands(
             : undefined;
 
         // Add option using t.ts API - store without -- prefix
+        const isBoolean = conf.type === 'boolean';
         command.option(
           argName,
           conf.description ?? '',
           subCompletionConfig?.options?.[argName] ?? noopOptionHandler,
-          shortFlag
+          shortFlag,
+          isBoolean
         );
       }
     }
@@ -206,12 +205,15 @@ export default async function tab<TArgs extends ArgsDef>(
 
   if (instance.args) {
     for (const [argName, argConfig] of Object.entries(instance.args)) {
-      const conf = argConfig as PositionalArgDef;
+      const conf = argConfig as ArgDef;
       // Add option using t.ts API - store without -- prefix
+      const isBoolean = conf.type === 'boolean';
       t.option(
         argName,
         conf.description ?? '',
-        completionConfig?.options?.[argName] ?? noopOptionHandler
+        completionConfig?.options?.[argName] ?? noopOptionHandler,
+        undefined,
+        isBoolean
       );
     }
   }

src/t.ts

@@ -57,20 +57,22 @@ export class Option {
   command: Command;
   handler?: OptionHandler;
   alias?: string;
-  // TODO: handle boolean options
+  isBoolean?: boolean;
 
   constructor(
     command: Command,
     value: string,
     description: string,
     handler?: OptionHandler,
-    alias?: string
+    alias?: string,
+    isBoolean?: boolean
   ) {
     this.command = command;
     this.value = value;
     this.description = description;
     this.handler = handler;
     this.alias = alias;
+    this.isBoolean = isBoolean;
   }
 }
 
@@ -90,9 +92,17 @@ export class Command {
     value: string,
     description: string,
     handler?: OptionHandler,
-    alias?: string
+    alias?: string,
+    isBoolean?: boolean
   ) {
-    const option = new Option(this, value, description, handler, alias);
+    const option = new Option(
+      this,
+      value,
+      description,
+      handler,
+      alias,
+      isBoolean
+    );
     this.options.set(value, option);
     return this;
   }
@@ -135,7 +145,28 @@ export class RootCommand extends Command {
 
       if (arg.startsWith('-')) {
         i++; // Skip the option
-        if (i < args.length && !args[i].startsWith('-')) {
+
+        // Check if this option expects a value (not boolean)
+        // We need to check across all commands since we don't know which command context we're in yet
+        let isBoolean = false;
+
+        // Check root command options
+        const rootOption = this.findOption(this, arg);
+        if (rootOption) {
+          isBoolean = rootOption.isBoolean ?? false;
+        } else {
+          // Check all subcommand options
+          for (const [, command] of this.commands) {
+            const option = this.findOption(command, arg);
+            if (option) {
+              isBoolean = option.isBoolean ?? false;
+              break;
+            }
+          }
+        }
+
+        // Only skip the next argument if this is not a boolean option and the next arg doesn't start with -
+        if (!isBoolean && i < args.length && !args[i].startsWith('-')) {
           i++; // Skip the option value
         }
       } else {
@@ -176,7 +207,33 @@ export class RootCommand extends Command {
     toComplete: string,
     endsWithSpace: boolean
   ): boolean {
-    return lastPrevArg?.startsWith('-') || toComplete.startsWith('-');
+    // Always complete if the current token starts with a dash
+    if (toComplete.startsWith('-')) {
+      return true;
+    }
+
+    // If the previous argument was an option, check if it expects a value
+    if (lastPrevArg?.startsWith('-')) {
+      // Find the option to check if it's boolean
+      let option = this.findOption(this, lastPrevArg);
+      if (!option) {
+        // Check all subcommand options
+        for (const [, command] of this.commands) {
+          option = this.findOption(command, lastPrevArg);
+          if (option) break;
+        }
+      }
+
+      // If it's a boolean option, don't try to complete its value
+      if (option && option.isBoolean) {
+        return false;
+      }
+
+      // Non-boolean options expect values
+      return true;
+    }
+
+    return false;
   }
 
   // Determine if we should complete commands
@@ -276,7 +333,7 @@ export class RootCommand extends Command {
 
   // Handle command completion
   private handleCommandCompletion(previousArgs: string[], toComplete: string) {
-    const commandParts = previousArgs.filter(Boolean);
+    const commandParts = this.stripOptions(previousArgs);
 
     for (const [k, command] of this.commands) {
       if (k === '') continue;
@@ -373,7 +430,9 @@ export class RootCommand extends Command {
     const previousArgs = args.slice(0, -1);
 
     if (endsWithSpace) {
-      previousArgs.push(toComplete);
+      if (toComplete !== '') {
+        previousArgs.push(toComplete);
+      }
       toComplete = '';
     }
 
@@ -390,11 +449,31 @@ export class RootCommand extends Command {
         lastPrevArg
       );
     } else {
+      // Check if we just finished a boolean option with no value expected
+      // In this case, don't complete anything
+      if (lastPrevArg?.startsWith('-') && toComplete === '' && endsWithSpace) {
+        let option = this.findOption(this, lastPrevArg);
+        if (!option) {
+          // Check all subcommand options
+          for (const [, command] of this.commands) {
+            option = this.findOption(command, lastPrevArg);
+            if (option) break;
+          }
+        }
+
+        // If it's a boolean option followed by empty space, don't complete anything
+        if (option && option.isBoolean) {
+          // Don't add any completions, just output the directive
+          this.complete(toComplete);
+          return;
+        }
+      }
+
       // 2. Handle command/subcommand completion
       if (this.shouldCompleteCommands(toComplete, endsWithSpace)) {
         this.handleCommandCompletion(previousArgs, toComplete);
       }
-      // 3. Handle positional arguments
+      // 3. Handle positional arguments - always check for root command arguments
       if (matchedCommand && matchedCommand.arguments.size > 0) {
         this.handlePositionalCompletion(
           matchedCommand,

tests/__snapshots__/cli.test.ts.snap

@@ -188,7 +188,11 @@ lint	Lint project
 `;
 
 exports[`cli completion tests for cac > root command argument tests > should complete root command project argument after options 1`] = `
-":4
+"dev	Start dev server
+serve	Start the server
+copy	Copy files
+lint	Lint project
+:4
 "
 `;
 
@@ -470,7 +474,6 @@ index.ts	Index file
 
 exports[`cli completion tests for citty > root command argument tests > should complete root command project argument 1`] = `
 "dev	Start dev server
-build	Build project
 copy	Copy files
 lint	Lint project
 my-app	My application
@@ -481,7 +484,10 @@ my-tool	My tool
 `;
 
 exports[`cli completion tests for citty > root command argument tests > should complete root command project argument after options 1`] = `
-":4
+"dev	Start dev server
+copy	Copy files
+lint	Lint project
+:4
 "
 `;
 
@@ -579,7 +585,6 @@ exports[`cli completion tests for citty > short flag handling > should not show
 
 exports[`cli completion tests for citty > should complete cli options 1`] = `
 "dev	Start dev server
-build	Build project
 copy	Copy files
 lint	Lint project
 my-app	My application
@@ -811,7 +816,11 @@ my-tool	My tool
 `;
 
 exports[`cli completion tests for t > root command argument tests > should complete root command project argument after options 1`] = `
-":4
+"dev	Start dev server
+serve	Start the server
+copy	Copy files
+lint	Lint project
+:4
 "
 `;
 

tests/cli.test.ts

@@ -89,6 +89,29 @@ describe.each(cliTools)('cli completion tests for %s', (cliTool) => {
     });
   });
 
+  describe.runIf(!shouldSkipTest)('boolean option handling', () => {
+    it('should not provide value completions for boolean options', async () => {
+      const command = `${commandPrefix} dev --verbose ""`;
+      const output = await runCommand(command);
+      // Boolean options should return just the directive, no completions
+      expect(output.trim()).toBe(':4');
+    });
+
+    it('should not provide value completions for short boolean options', async () => {
+      const command = `${commandPrefix} dev -v ""`;
+      const output = await runCommand(command);
+      // Boolean options should return just the directive, no completions
+      expect(output.trim()).toBe(':4');
+    });
+
+    it('should not interfere with command completion after boolean options', async () => {
+      const command = `${commandPrefix} dev --verbose s`;
+      const output = await runCommand(command);
+      // Should complete subcommands that start with 's' even after a boolean option
+      expect(output).toContain('start');
+    });
+  });
+
   describe.runIf(!shouldSkipTest)('--config option tests', () => {
     it('should complete --config option values', async () => {
       const command = `${commandPrefix} --config ""`;