@vexify-org/yaggs 4.0.0 → 5.1.0

package/lib/parser.js

@@ -39,6 +39,8 @@ class ArgumentParser {
             demandOption: config.demandOption || config.required || false,
             normalize: config.normalize,
             hidden: config.hidden || false,
+            conflicts: config.conflicts || [],
+            implies: config.implies || {},
             ...config
         };
 
@@ -89,6 +91,7 @@ class ArgumentParser {
             aliases: config.aliases || [],
             hidden: config.hidden || false,
             strict: config.strict || false,
+            group: config.group || 'Commands',
             ...config
         };
 
@@ -164,7 +167,7 @@ class ArgumentParser {
             const arg = argv[i];
 
             if (inOption) {
-                if (arg.startsWith('-') || this.commands[arg]) {
+                if (arg.startsWith('-') || this.commands[arg] || this._resolveCommandAlias(arg)) {
                     this._assignOption(result, inOption, optionAccumulator);
                     inOption = null;
                     optionAccumulator = [];
@@ -261,9 +264,10 @@ class ArgumentParser {
                     }
                 }
             } else {
-                if (!currentCommand && this.commands[arg]) {
-                    currentCommand = arg;
-                    commandChain.push(arg);
+                if (!currentCommand && (this.commands[arg] || this._resolveCommandAlias(arg))) {
+                    const resolvedCommand = this._resolveCommandAlias(arg) || arg;
+                    currentCommand = resolvedCommand;
+                    commandChain.push(resolvedCommand);
                 } else {
                     result._.push(arg);
                 }
@@ -311,6 +315,8 @@ class ArgumentParser {
         this._applyTypeConversion(result);
         this._validateOptions(result);
         this._validatePositionals(result);
+        this._validateConflicts(result);
+        this._applyImplies(result);
 
         if (currentCommand && this.commands[currentCommand]) {
             result.command = currentCommand;
@@ -451,6 +457,30 @@ class ArgumentParser {
         }
     }
 
+    _validateConflicts(result) {
+        for (const [name, opt] of Object.entries(this.options)) {
+            if (result[name] !== undefined && opt.conflicts.length > 0) {
+                for (const conflict of opt.conflicts) {
+                    if (result[conflict] !== undefined) {
+                        this._handleError(`Option '${name}' conflicts with '${conflict}'`);
+                    }
+                }
+            }
+        }
+    }
+
+    _applyImplies(result) {
+        for (const [name, opt] of Object.entries(this.options)) {
+            if (result[name] !== undefined && Object.keys(opt.implies).length > 0) {
+                for (const [impliedName, impliedValue] of Object.entries(opt.implies)) {
+                    if (result[impliedName] === undefined) {
+                        result[impliedName] = impliedValue;
+                    }
+                }
+            }
+        }
+    }
+
     _handleError(message) {
         if (this.errorHandler) {
             this.errorHandler(message);
@@ -460,6 +490,15 @@ class ArgumentParser {
         }
     }
 
+    _resolveCommandAlias(arg) {
+        for (const [name, cmd] of Object.entries(this.commands)) {
+            if (cmd.aliases && cmd.aliases.includes(arg)) {
+                return name;
+            }
+        }
+        return null;
+    }
+
     getHelp() {
         let help = `\u001b[36m${this.scriptName}\u001b[0m`;
         
@@ -497,21 +536,32 @@ class ArgumentParser {
 
         const visibleCommands = Object.entries(this.commands).filter(([, cmd]) => !cmd.hidden);
         if (visibleCommands.length > 0) {
-            help += '\n\n\u001b[33mCommands:\u001b[0m';
-            
-            const maxLen = Math.max(...visibleCommands.map(([name]) => name.length)) + 4;
-            
+            const groupedCommands = {};
             for (const [name, cmd] of visibleCommands) {
-                let line = `  ${name}`;
-                
-                if (cmd.aliases && cmd.aliases.length > 0) {
-                    line += ` (${cmd.aliases.join(', ')})`;
+                const group = cmd.group || 'Commands';
+                if (!groupedCommands[group]) {
+                    groupedCommands[group] = [];
                 }
+                groupedCommands[group].push({ name, cmd });
+            }
+            
+            for (const [groupName, commands] of Object.entries(groupedCommands)) {
+                help += `\n\n\u001b[33m${groupName}:\u001b[0m`;
                 
-                line = line.padEnd(maxLen);
-                line += cmd.description;
+                const maxLen = Math.max(...commands.map(({ name }) => name.length)) + 4;
                 
-                help += `\n${line}`;
+                for (const { name, cmd } of commands) {
+                    let line = `  ${name}`;
+                    
+                    if (cmd.aliases && cmd.aliases.length > 0) {
+                        line += ` (${cmd.aliases.join(', ')})`;
+                    }
+                    
+                    line = line.padEnd(maxLen);
+                    line += cmd.description;
+                    
+                    help += `\n${line}`;
+                }
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vexify-org/yaggs",
-    "version": "4.0.0",
+    "version": "5.1.0",
     "description": "A powerful CLI argument parser, better than yargs",
     "main": "index.js",
     "scripts": {