@vexify-org/yaggs 3.2.0 → 5.0.0

package/index.js

@@ -133,6 +133,18 @@ class Yaggs {
         return this;
     }
 
+    env(name, envVar) {
+        if (this.parser.options[name]) {
+            this.parser.options[name].env = envVar;
+        }
+        return this;
+    }
+
+    config(filePath) {
+        this.parser.loadConfig(filePath);
+        return this;
+    }
+
     parse(argv = process.argv.slice(2)) {
         const result = this.parser.parse(argv);
         

package/lib/parser.js

@@ -12,6 +12,8 @@ class ArgumentParser {
         this.scriptName = options.scriptName || process.argv[1] || 'yaggs';
         this.helpFunction = options.helpFunction || null;
         this.errorHandler = options.errorHandler || null;
+        this.configFile = options.configFile || null;
+        this.config = {};
     }
 
     option(name, config) {
@@ -87,12 +89,37 @@ class ArgumentParser {
             aliases: config.aliases || [],
             hidden: config.hidden || false,
             strict: config.strict || false,
+            group: config.group || 'Commands',
             ...config
         };
 
         return this;
     }
 
+    loadConfig(filePath) {
+        const fs = require('fs');
+        const path = require('path');
+        
+        try {
+            const fullPath = path.resolve(filePath);
+            if (!fs.existsSync(fullPath)) {
+                return this;
+            }
+            
+            const ext = path.extname(filePath).toLowerCase();
+            if (ext === '.json') {
+                this.config = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+            } else if (ext === '.js') {
+                this.config = require(fullPath);
+            }
+            
+            return this;
+        } catch (error) {
+            this._handleError(`Failed to load config file: ${error.message}`);
+            return this;
+        }
+    }
+
     parse(argv = process.argv.slice(2)) {
         const result = {
             _: [],
@@ -138,7 +165,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 = [];
@@ -235,9 +262,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);
                 }
@@ -276,6 +304,12 @@ class ArgumentParser {
             }
         }
 
+        for (const [key, value] of Object.entries(this.config)) {
+            if (result[key] === undefined) {
+                result[key] = value;
+            }
+        }
+
         this._applyTypeConversion(result);
         this._validateOptions(result);
         this._validatePositionals(result);
@@ -296,6 +330,13 @@ class ArgumentParser {
             return;
         }
         
+        if (opt.env && !result[name]) {
+            const envValue = process.env[opt.env];
+            if (envValue !== undefined) {
+                result[name] = envValue;
+            }
+        }
+        
         if (opt.array) {
             if (!result[name]) result[name] = [];
             result[name].push(...values);
@@ -421,6 +462,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`;
         
@@ -458,21 +508,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": "3.2.0",
+    "version": "5.0.0",
     "description": "A powerful CLI argument parser, better than yargs",
     "main": "index.js",
     "scripts": {