recker 1.0.39-next.ae39611 → 1.0.39

package/dist/cli/index.js

@@ -128,7 +128,6 @@ async function main() {
         .name('rek')
         .description('The HTTP Client for Humans (and Robots)')
         .version(version)
-        .showHelpAfterError(true)
         .argument('[args...]', 'URL, Method, Headers (Key:Value), Data (key=value)')
         .option('-v, --verbose', 'Show full request/response details')
         .option('-q, --quiet', 'Output only response body (no colors, perfect for piping)')
@@ -277,27 +276,7 @@ Error: ${error.message}`));
     });
     program
         .command('completion')
-        .description('Generate shell auto-completion script')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Generates a shell completion script for bash/zsh that enables tab-completion
-  for rek commands, options, HTTP methods, and API presets (@github, @openai, etc).
-
-  Once installed, pressing TAB will auto-complete commands and show suggestions,
-  making the CLI much faster to use.
-
-${colors.bold(colors.yellow('Installation:'))}
-  ${colors.cyan('# Bash (add to ~/.bashrc)')}
-  ${colors.green('$ rek completion >> ~/.bashrc')}
-  ${colors.green('$ source ~/.bashrc')}
-
-  ${colors.cyan('# Zsh (add to ~/.zshrc)')}
-  ${colors.green('$ rek completion >> ~/.zshrc')}
-  ${colors.green('$ source ~/.zshrc')}
-
-  ${colors.cyan('# One-time use (current session only)')}
-  ${colors.green('$ source <(rek completion)')}
-`)
+        .description('Generate shell completion script')
         .action(() => {
         const script = `
 ###-begin-rek-completion-###
@@ -345,32 +324,15 @@ complete -F _rek_completions rek
     program
         .command('version')
         .alias('info')
-        .description('Show version and environment information')
-        .argument('[args...]', 'Options: short format=json')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Displays the installed Recker version along with your Node.js version,
-  operating system, and architecture. Useful for debugging, reporting issues,
-  or verifying which version is running in production environments.
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek version')}                    Show full version info
-  ${colors.green('$ rek version short')}              Just the version number (for scripts)
-  ${colors.green('$ rek version format=json')}        Machine-readable JSON output
-  ${colors.green('$ rek info')}                       Alias for version
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('short')}             Show only version number
-  ${colors.cyan('format=json')}       Output as JSON
-`)
-        .action(async (args) => {
-        const isShort = args.includes('short');
-        const formatJson = args.some(a => a === 'format=json' || a === 'json');
-        if (isShort) {
+        .description('Show detailed version information')
+        .option('-s, --short', 'Show only version number')
+        .option('--format <type>', 'Output format: text or json', 'text')
+        .action(async (options) => {
+        if (options.short) {
             console.log(version);
             return;
         }
-        if (formatJson) {
+        if (options.format === 'json') {
             const { getVersionInfo } = await import('../version.js');
             const info = await getVersionInfo();
             console.log(JSON.stringify(info, null, 2));
@@ -386,27 +348,6 @@ ${colors.bold(colors.yellow('Options:'))}
         .alias('repl')
         .description('Start the interactive Rek Shell')
         .option('-e, --env [path]', 'Load .env file (auto-loads from cwd by default)')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Launches an interactive REPL (Read-Eval-Print Loop) for exploring APIs.
-  The shell provides auto-completion, command history, and a rich set of
-  built-in commands for HTTP requests, DNS lookups, WHOIS queries, and more.
-
-  Perfect for API exploration, debugging, and quick prototyping without
-  writing scripts. Environment variables from .env are loaded automatically.
-
-${colors.bold(colors.yellow('Shell Commands:'))}
-  get/post/put/delete <url>    Make HTTP requests
-  whois <domain>               WHOIS lookup
-  dns <domain>                 DNS resolution
-  tls <domain>                 TLS certificate inspection
-  help                         Show all available commands
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek shell')}                      Start interactive shell
-  ${colors.green('$ rek shell -e .env.local')}       Load custom env file
-  ${colors.green('$ rek repl')}                       Alias for shell
-`)
         .action(async (options) => {
         if (options.env !== false) {
             try {
@@ -424,22 +365,7 @@ ${colors.bold(colors.yellow('Examples:'))}
     program
         .command('docs [query...]')
         .alias('?')
-        .description('Search Recker documentation')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Opens a fullscreen interactive panel to search Recker's documentation.
-  Uses fuzzy search to find relevant docs about HTTP clients, plugins,
-  authentication, caching, and all other features.
-
-  The search is powered by semantic embeddings for accurate results.
-  Navigate with arrow keys, press Enter to view, Esc to close.
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek docs')}                       Open documentation browser
-  ${colors.green('$ rek docs retry')}                 Search for retry-related docs
-  ${colors.green('$ rek docs "rate limit"')}          Search for rate limiting
-  ${colors.green('$ rek ? oauth')}                    Quick search with ? alias
-`)
+        .description('Search Recker documentation (opens fullscreen panel)')
         .action(async (queryParts) => {
         const query = queryParts.join(' ').trim();
         const { openSearchPanel } = await import('./tui/search-panel.js');
@@ -448,39 +374,8 @@ ${colors.bold(colors.yellow('Examples:'))}
     program
         .command('security')
         .alias('headers')
-        .alias('grade')
-        .description('Grade a website\'s security headers (A+ to F)')
+        .description('Analyze HTTP response headers for security best practices')
         .argument('<url>', 'URL to analyze')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Fetches a URL and analyzes its HTTP response headers for security best
-  practices. Assigns a grade from A+ to F based on the presence and correct
-  configuration of security headers.
-
-  Checks for HSTS, CSP, X-Frame-Options, X-Content-Type-Options, and other
-  important security headers. Great for security audits, DevSecOps pipelines,
-  or verifying your site's security configuration.
-
-${colors.bold(colors.yellow('Headers Analyzed:'))}
-  - Strict-Transport-Security (HSTS)
-  - Content-Security-Policy (CSP)
-  - X-Frame-Options (clickjacking protection)
-  - X-Content-Type-Options (MIME sniffing)
-  - Referrer-Policy
-  - Permissions-Policy
-  - X-XSS-Protection (legacy)
-
-${colors.bold(colors.yellow('Grade Scale:'))}
-  ${colors.green('A+/A/A-')}  Excellent - all critical headers present
-  ${colors.blue('B+/B/B-')}  Good - most headers present
-  ${colors.yellow('C+/C/C-')}  Fair - some headers missing
-  ${colors.red('D/F')}      Poor - critical headers missing
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek security github.com')}         Grade GitHub's headers
-  ${colors.green('$ rek headers api.stripe.com')}      Using headers alias
-  ${colors.green('$ rek grade mysite.com')}            Using grade alias
-`)
         .action(async (url) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
@@ -522,30 +417,16 @@ ${colors.bold('Details:')}`);
     });
     program
         .command('seo')
-        .alias('audit')
-        .description('Analyze a page\'s SEO health (80+ checks)')
+        .description('Analyze page SEO (title, meta, headings, links, images, structured data)')
         .argument('<url>', 'URL to analyze')
-        .argument('[args...]', 'Options: all format=json')
+        .option('-a, --all', 'Show all checks including passed ones')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Performs a comprehensive SEO audit on a single page. Analyzes title, meta
-  description, headings hierarchy, images, links, structured data, OpenGraph
-  tags, Twitter cards, and technical SEO factors.
-
-  Returns a score with detailed recommendations. Use format=json for
-  integration with CI/CD pipelines or automated monitoring.
-
-  For full site audits, use ${colors.cyan('rek spider <url> seo')} instead.
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek seo example.com')}                    ${colors.gray('Basic SEO analysis')}
-  ${colors.green('$ rek seo example.com all')}                ${colors.gray('Show all checks')}
-  ${colors.green('$ rek seo example.com format=json')}        ${colors.gray('Output as JSON')}
-  ${colors.green('$ rek seo example.com format=json | jq')}   ${colors.gray('Pipe to jq for processing')}
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('all')}               Show all checks including passed ones
-  ${colors.cyan('format=json')}       Output as JSON
+  ${colors.green('$ rek seo example.com -a')}                 ${colors.gray('Show all checks')}
+  ${colors.green('$ rek seo example.com --format json')}      ${colors.gray('Output as JSON')}
+  ${colors.green('$ rek seo example.com --format json | jq')} ${colors.gray('Pipe to jq for processing')}
 
 ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Title Tag')}          Length and presence
@@ -558,11 +439,10 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Structured Data')}    JSON-LD presence
   ${colors.cyan('Technical')}          Canonical, viewport, lang
 `)
-        .action(async (url, args) => {
+        .action(async (url, options) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        const showAll = args.includes('all');
-        const isJson = args.some(a => a === 'format=json' || a === 'json');
+        const isJson = options.format === 'json';
         const { createClient } = await import('../core/client.js');
         const { analyzeSeo } = await import('../seo/analyzer.js');
         if (!isJson) {
@@ -639,11 +519,11 @@ ${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray
             console.log(`  ${colors.gray('Images:')} ${report.images.total} (${report.images.withAlt} with alt, ${report.images.withoutAlt} without)`);
             console.log('');
             console.log(`${colors.bold('Checks:')}`);
-            const checksToShow = showAll
+            const checksToShow = options.all
                 ? report.checks
                 : report.checks.filter(c => c.status !== 'pass' && c.status !== 'info');
-            if (checksToShow.length === 0 && !showAll) {
-                console.log(colors.green('  All checks passed! Use "all" to see details.'));
+            if (checksToShow.length === 0 && !options.all) {
+                console.log(colors.green('  All checks passed! Use -a to see details.'));
             }
             else {
                 for (const check of checksToShow) {
@@ -679,15 +559,12 @@ ${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray
         .command('robots')
         .description('Validate and analyze robots.txt file')
         .argument('<url>', 'Website URL or direct robots.txt URL')
-        .argument('[args...]', 'Options: format=json')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
         .addHelpText('after', `
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek robots example.com')}                ${colors.gray('Validate robots.txt')}
   ${colors.green('$ rek robots example.com/robots.txt')}     ${colors.gray('Direct URL')}
-  ${colors.green('$ rek robots example.com format=json')}    ${colors.gray('JSON output')}
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('format=json')}         Output as JSON
+  ${colors.green('$ rek robots example.com --format json')}  ${colors.gray('JSON output')}
 
 ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Syntax')}              Valid robots.txt syntax
@@ -696,14 +573,14 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Crawl-delay')}         Aggressive crawl delay
   ${colors.cyan('AI Bots')}             GPTBot, ClaudeBot, Anthropic blocks
 `)
-        .action(async (url, args) => {
+        .action(async (url, options) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
         if (!url.includes('robots.txt')) {
             const urlObj = new URL(url);
             url = `${urlObj.origin}/robots.txt`;
         }
-        const isJson = args.some(a => a === 'format=json' || a === 'json');
+        const isJson = options.format === 'json';
         if (!isJson) {
             console.log(colors.gray(`Fetching robots.txt from ${url}...`));
         }
@@ -793,17 +670,14 @@ ${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')
         .command('sitemap')
         .description('Validate and analyze sitemap.xml file')
         .argument('<url>', 'Website URL or direct sitemap URL')
-        .argument('[args...]', 'Options: discover format=json')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .option('--discover', 'Discover all sitemaps via robots.txt')
         .addHelpText('after', `
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek sitemap example.com')}                  ${colors.gray('Validate sitemap')}
   ${colors.green('$ rek sitemap example.com/sitemap.xml')}      ${colors.gray('Direct URL')}
-  ${colors.green('$ rek sitemap example.com discover')}         ${colors.gray('Find all sitemaps')}
-  ${colors.green('$ rek sitemap example.com format=json')}      ${colors.gray('JSON output')}
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('discover')}        Discover all sitemaps via robots.txt
-  ${colors.cyan('format=json')}     Output as JSON
+  ${colors.green('$ rek sitemap example.com --discover')}       ${colors.gray('Find all sitemaps')}
+  ${colors.green('$ rek sitemap example.com --format json')}    ${colors.gray('JSON output')}
 
 ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Structure')}      Valid XML sitemap format
@@ -812,13 +686,12 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('URLs')}           Valid, no duplicates, same domain
   ${colors.cyan('Lastmod')}        Valid dates, not in future
 `)
-        .action(async (url, args) => {
+        .action(async (url, options) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        const isJson = args.some(a => a === 'format=json' || a === 'json');
-        const doDiscover = args.includes('discover');
+        const isJson = options.format === 'json';
         try {
-            if (doDiscover) {
+            if (options.discover) {
                 const { discoverSitemaps } = await import('../seo/validators/sitemap.js');
                 if (!isJson) {
                     console.log(colors.gray(`Discovering sitemaps for ${new URL(url).origin}...`));
@@ -928,17 +801,14 @@ ${colors.gray('Type:')} ${result.parseResult?.type === 'sitemapindex' ? 'Sitemap
         .command('llms')
         .description('Validate and analyze llms.txt file (AI/LLM optimization)')
         .argument('[url]', 'Website URL or direct llms.txt URL')
-        .argument('[args...]', 'Options: template format=json')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .option('--template', 'Generate a template llms.txt file')
         .addHelpText('after', `
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek llms example.com')}                ${colors.gray('Validate llms.txt')}
   ${colors.green('$ rek llms example.com/llms.txt')}       ${colors.gray('Direct URL')}
-  ${colors.green('$ rek llms example.com format=json')}    ${colors.gray('JSON output')}
-  ${colors.green('$ rek llms template > llms.txt')}        ${colors.gray('Generate template')}
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('template')}        Generate a template llms.txt file
-  ${colors.cyan('format=json')}     Output as JSON
+  ${colors.green('$ rek llms example.com --format json')}  ${colors.gray('JSON output')}
+  ${colors.green('$ rek llms --template > llms.txt')}      ${colors.gray('Generate template')}
 
 ${colors.bold(colors.yellow('About llms.txt:'))}
   A proposed standard for providing LLM-friendly content.
@@ -951,10 +821,9 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Description')} Site description block
   ${colors.cyan('Sections')}     Content sections with links
 `)
-        .action(async (url, args) => {
-        const isJson = args.some(a => a === 'format=json' || a === 'json');
-        const isTemplate = args.includes('template') || url === 'template';
-        if (isTemplate) {
+        .action(async (url, options) => {
+        const isJson = options.format === 'json';
+        if (options.template) {
             const { generateLlmsTxtTemplate } = await import('../seo/validators/llms-txt.js');
             const template = generateLlmsTxtTemplate({
                 siteName: 'Your Site Name',
@@ -1076,20 +945,10 @@ ${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')
     });
     program
         .command('spider')
-        .alias('crawl')
-        .description('Crawl a website and analyze all pages')
+        .description('Crawl a website following internal links')
         .argument('<url>', 'Starting URL to crawl')
         .argument('[args...]', 'Options: depth=N limit=N concurrency=N seo focus=MODE output=file.json')
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Crawls a website starting from the given URL, following internal links up to
-  a specified depth. Discovers all pages, collects metadata, and optionally
-  performs comprehensive SEO analysis.
-
-  The crawler respects robots.txt, handles JavaScript-rendered content, and
-  provides detailed reports on site structure, broken links, and SEO issues.
-  Perfect for site audits, migration planning, or competitive analysis.
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek spider example.com')}                           ${colors.gray('Crawl with defaults')}
   ${colors.green('$ rek spider example.com depth=3 limit=50')}          ${colors.gray('Depth 3, max 50 pages')}
@@ -1098,7 +957,6 @@ ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek spider example.com seo focus=links')}           ${colors.gray('Focus on link issues')}
   ${colors.green('$ rek spider example.com seo focus=security')}        ${colors.gray('Focus on security issues')}
   ${colors.green('$ rek spider example.com seo focus=duplicates')}      ${colors.gray('Focus on duplicate content')}
-  ${colors.green('$ rek spider example.com seo format=json')}           ${colors.gray('JSON output to stdout')}
 
 ${colors.bold(colors.yellow('Options:'))}
   ${colors.cyan('depth=N')}           Max link depth to follow (default: 5)
@@ -1106,7 +964,6 @@ ${colors.bold(colors.yellow('Options:'))}
   ${colors.cyan('concurrency=N')}     Parallel requests (default: 5)
   ${colors.cyan('seo')}               Enable SEO analysis mode
   ${colors.cyan('focus=MODE')}        Focus analysis on specific area (requires seo)
-  ${colors.cyan('format=json')}       Output JSON to stdout (for piping)
   ${colors.cyan('output=file.json')}  Save JSON report to file
 
 ${colors.bold(colors.yellow('Focus Modes:'))}
@@ -1123,7 +980,6 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
         let concurrency = 5;
         let seoEnabled = false;
         let outputFile = '';
-        let formatJson = false;
         let focusMode = 'all';
         const focusCategories = {
             links: ['links'],
@@ -1149,9 +1005,6 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
             else if (arg.startsWith('output=')) {
                 outputFile = arg.split('=')[1] || '';
             }
-            else if (arg === 'format=json' || arg === '--format=json') {
-                formatJson = true;
-            }
             else if (arg.startsWith('focus=')) {
                 const mode = arg.split('=')[1] || 'all';
                 if (mode in focusCategories) {
@@ -1166,16 +1019,14 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
         }
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        if (!formatJson) {
-            const modeLabel = seoEnabled ? colors.magenta(' + SEO') : '';
-            const focusLabel = focusMode !== 'all' ? colors.cyan(` [focus: ${focusMode}]`) : '';
-            console.log(colors.cyan(`\nSpider starting: ${url}`));
-            console.log(colors.gray(`  Depth: ${maxDepth} | Limit: ${maxPages} | Concurrency: ${concurrency}${modeLabel}${focusLabel}`));
-            if (outputFile) {
-                console.log(colors.gray(`  Output: ${outputFile}`));
-            }
-            console.log('');
+        const modeLabel = seoEnabled ? colors.magenta(' + SEO') : '';
+        const focusLabel = focusMode !== 'all' ? colors.cyan(` [focus: ${focusMode}]`) : '';
+        console.log(colors.cyan(`\nSpider starting: ${url}`));
+        console.log(colors.gray(`  Depth: ${maxDepth} | Limit: ${maxPages} | Concurrency: ${concurrency}${modeLabel}${focusLabel}`));
+        if (outputFile) {
+            console.log(colors.gray(`  Output: ${outputFile}`));
         }
+        console.log('');
         try {
             if (seoEnabled) {
                 const { SeoSpider } = await import('../seo/index.js');
@@ -1189,91 +1040,11 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                     output: outputFile || undefined,
                     focusCategories: focusCategories[focusMode],
                     focusMode,
-                    onProgress: formatJson ? undefined : (progress) => {
+                    onProgress: (progress) => {
                         process.stdout.write(`\r${colors.gray('  Crawling:')} ${colors.cyan(progress.crawled.toString())} pages | ${colors.gray('Queue:')} ${progress.queued} | ${colors.gray('Depth:')} ${progress.depth}   `);
                     },
                 });
                 const result = await seoSpider.crawl(url);
-                if (formatJson) {
-                    const responseTimes = result.pages.filter(p => p.duration > 0).map(p => p.duration);
-                    const avgResponseTime = responseTimes.length > 0
-                        ? Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length)
-                        : 0;
-                    const statusCounts = {};
-                    for (const page of result.pages) {
-                        const key = page.status?.toString() || 'error';
-                        statusCounts[key] = (statusCounts[key] || 0) + 1;
-                    }
-                    let totalInternalLinks = 0;
-                    let totalExternalLinks = 0;
-                    let totalImages = 0;
-                    let imagesWithoutAlt = 0;
-                    for (const page of result.pages) {
-                        if (page.seoReport) {
-                            totalInternalLinks += page.seoReport.links?.internal || 0;
-                            totalExternalLinks += page.seoReport.links?.external || 0;
-                            totalImages += page.seoReport.images?.total || 0;
-                            imagesWithoutAlt += page.seoReport.images?.withoutAlt || 0;
-                        }
-                    }
-                    const jsonOutput = {
-                        startUrl: url,
-                        crawledAt: new Date().toISOString(),
-                        duration: result.duration,
-                        config: {
-                            maxDepth,
-                            maxPages,
-                            concurrency,
-                            focusMode,
-                        },
-                        summary: {
-                            totalPages: result.pages.length,
-                            uniqueUrls: result.visited.size,
-                            avgSeoScore: result.summary.avgScore,
-                            avgResponseTime,
-                            pagesWithErrors: result.summary.pagesWithErrors,
-                            pagesWithWarnings: result.summary.pagesWithWarnings,
-                            duplicateTitles: result.summary.duplicateTitles,
-                            duplicateDescriptions: result.summary.duplicateDescriptions,
-                            duplicateH1s: result.summary.duplicateH1s,
-                            orphanPages: result.summary.orphanPages,
-                        },
-                        content: {
-                            totalInternalLinks,
-                            totalExternalLinks,
-                            totalImages,
-                            imagesWithoutAlt,
-                        },
-                        httpStatus: statusCounts,
-                        siteWideIssues: result.siteWideIssues.map(issue => ({
-                            type: issue.type,
-                            severity: issue.severity,
-                            message: issue.message,
-                            value: issue.value,
-                            affectedUrls: issue.affectedUrls,
-                        })),
-                        pages: result.pages.map(page => ({
-                            url: page.url,
-                            status: page.status,
-                            depth: page.depth,
-                            duration: page.duration,
-                            title: page.title,
-                            error: page.error,
-                            seo: page.seoReport ? {
-                                score: page.seoReport.score,
-                                grade: page.seoReport.grade,
-                                title: page.seoReport.title,
-                                metaDescription: page.seoReport.metaDescription,
-                                headings: page.seoReport.headings,
-                                links: page.seoReport.links,
-                                images: page.seoReport.images,
-                                checks: page.seoReport.checks,
-                            } : null,
-                        })),
-                    };
-                    console.log(JSON.stringify(jsonOutput, null, 2));
-                    return;
-                }
                 process.stdout.write('\r' + ' '.repeat(80) + '\r');
                 console.log(colors.green(`\n✔ SEO Spider complete`) + colors.gray(` (${(result.duration / 1000).toFixed(1)}s)`));
                 console.log(`  ${colors.cyan('Pages crawled')}: ${result.pages.length}`);
@@ -1453,41 +1224,11 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                     concurrency,
                     sameDomain: true,
                     delay: 100,
-                    onProgress: formatJson ? undefined : (progress) => {
+                    onProgress: (progress) => {
                         process.stdout.write(`\r${colors.gray('  Crawling:')} ${colors.cyan(progress.crawled.toString())} pages | ${colors.gray('Queue:')} ${progress.queued} | ${colors.gray('Depth:')} ${progress.depth}   `);
                     },
                 });
                 const result = await spider.crawl(url);
-                if (formatJson) {
-                    const jsonOutput = {
-                        startUrl: result.startUrl,
-                        crawledAt: new Date().toISOString(),
-                        duration: result.duration,
-                        config: {
-                            maxDepth,
-                            maxPages,
-                            concurrency,
-                        },
-                        summary: {
-                            totalPages: result.pages.length,
-                            successCount: result.pages.filter(p => !p.error).length,
-                            errorCount: result.errors.length,
-                            uniqueUrls: result.visited.size,
-                        },
-                        pages: result.pages.map(p => ({
-                            url: p.url,
-                            status: p.status,
-                            title: p.title,
-                            depth: p.depth,
-                            linksCount: p.links.length,
-                            duration: p.duration,
-                            error: p.error,
-                        })),
-                        errors: result.errors,
-                    };
-                    console.log(JSON.stringify(jsonOutput, null, 2));
-                    return;
-                }
                 process.stdout.write('\r' + ' '.repeat(80) + '\r');
                 console.log(colors.green(`\n✔ Spider complete`) + colors.gray(` (${(result.duration / 1000).toFixed(1)}s)`));
                 console.log(`  ${colors.cyan('Pages crawled')}: ${result.pages.length}`);
@@ -1552,19 +1293,10 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
     });
     program
         .command('scrape')
-        .alias('extract')
-        .description('Extract data from web pages with CSS selectors')
+        .description('Scrape data from a web page using CSS selectors')
         .argument('<url>', 'URL to scrape')
         .argument('[args...]', 'Options: select=SELECTOR, attr=NAME, links, images, meta, tables, scripts, jsonld')
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Fetches a web page and extracts data using CSS selectors. Can extract
-  text content, specific attributes, links, images, meta tags, tables,
-  scripts, and JSON-LD structured data.
-
-  Perfect for quick data extraction, competitive research, price monitoring,
-  or building datasets. Outputs clean, structured data ready for processing.
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek scrape example.com')}                      ${colors.gray('# Basic page info')}
   ${colors.green('$ rek scrape example.com select="h1"')}          ${colors.gray('# Extract h1 text')}
@@ -1762,32 +1494,20 @@ ${colors.bold('Images:')}      ${imageCount}
     });
     program
         .command('ai')
-        .alias('chat')
-        .alias('ask')
-        .description('Chat with AI models (OpenAI, Claude, Groq, etc)')
+        .description('Send a single AI prompt (no memory/context)')
         .argument('<preset>', 'AI preset to use (e.g., @openai, @anthropic, @groq)')
-        .argument('<prompt...>', 'The prompt and options: "prompt text" model=<model> temperature=<temp> max-tokens=<tokens> wait json env=<path>')
+        .argument('<prompt...>', 'The prompt to send')
+        .option('-m, --model <model>', 'Override default model')
+        .option('-t, --temperature <temp>', 'Temperature (0-1)', '0.7')
+        .option('--max-tokens <tokens>', 'Max tokens in response', '2048')
+        .option('-w, --wait', 'Wait for full response (disable streaming)')
+        .option('-j, --json', 'Output raw JSON response')
+        .option('-e, --env [path]', 'Load .env file (auto-loads from cwd if exists)')
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Sends a prompt to an AI language model and streams the response back.
-  Supports all major AI providers including OpenAI, Anthropic, Google, Groq,
-  Mistral, and more. API keys are loaded from environment variables.
-
-  Each provider uses sensible defaults but you can override the model,
-  temperature, and max tokens. Responses stream in real-time by default.
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('model=<model>')}        Override default model
-  ${colors.cyan('temperature=<temp>')}   Temperature (0-1, default: 0.7)
-  ${colors.cyan('max-tokens=<tokens>')}  Max tokens in response (default: 2048)
-  ${colors.cyan('wait')}                 Wait for full response (disable streaming)
-  ${colors.cyan('json')}                 Output raw JSON response
-  ${colors.cyan('env=<path>')}           Load .env file (auto-loads from cwd if exists)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek ai @openai "What is the capital of France?"')}
-  ${colors.green('$ rek ai @anthropic "Explain quantum computing" model=claude-sonnet-4-20250514')}
-  ${colors.green('$ rek ai @groq "Write a haiku" wait')}
+  ${colors.green('$ rek ai @anthropic "Explain quantum computing" -m claude-sonnet-4-20250514')}
+  ${colors.green('$ rek ai @groq "Write a haiku" --wait')}
   ${colors.green('$ rek ai @openai "Translate to Spanish: Hello world"')}
 
 ${colors.bold(colors.yellow('Available AI Presets:'))}
@@ -1809,39 +1529,14 @@ ${colors.bold(colors.yellow('Note:'))}
   This command sends a single prompt without conversation memory.
   For chat with memory, use: ${colors.cyan('rek shell')} then ${colors.cyan('@openai Your message')}
 `)
-        .action(async (preset, promptParts) => {
-        let model;
-        let temperature = '0.7';
-        let maxTokens = '2048';
-        let wait = false;
-        let jsonOutput = false;
-        let envPath;
-        const actualPromptParts = [];
-        for (const part of promptParts) {
-            if (part.startsWith('model='))
-                model = part.split('=')[1];
-            else if (part.startsWith('temperature='))
-                temperature = part.split('=')[1];
-            else if (part.startsWith('max-tokens='))
-                maxTokens = part.split('=')[1];
-            else if (part === 'wait')
-                wait = true;
-            else if (part === 'json')
-                jsonOutput = true;
-            else if (part.startsWith('env='))
-                envPath = part.split('=')[1];
-            else if (part === 'env')
-                envPath = true;
-            else
-                actualPromptParts.push(part);
-        }
-        if (envPath !== undefined) {
-            await loadEnvFile(envPath);
+        .action(async (preset, promptParts, options) => {
+        if (options.env !== undefined) {
+            await loadEnvFile(options.env);
         }
         else {
             try {
-                const envFilePath = join(process.cwd(), '.env');
-                await fs.access(envFilePath);
+                const envPath = join(process.cwd(), '.env');
+                await fs.access(envPath);
                 await loadEnvFile(true);
             }
             catch {
@@ -1862,7 +1557,7 @@ ${colors.bold(colors.yellow('Note:'))}
             console.log(colors.gray('Use an AI preset like @openai, @anthropic, @groq, etc.'));
             process.exit(1);
         }
-        const prompt = actualPromptParts.join(' ');
+        const prompt = promptParts.join(' ');
         if (!prompt.trim()) {
             console.error(colors.red('Error: Prompt is required'));
             process.exit(1);
@@ -1870,16 +1565,16 @@ ${colors.bold(colors.yellow('Note:'))}
         try {
             const { createClient } = await import('../core/client.js');
             const client = createClient(presetConfig);
-            if (model) {
+            if (options.model) {
                 client.ai.setMemoryConfig({ systemPrompt: undefined });
-                client._aiConfig.model = model;
+                client._aiConfig.model = options.model;
             }
-            if (!jsonOutput) {
+            if (!options.json) {
                 console.log(colors.gray(`Using @${presetName} (${client._aiConfig.model})...\n`));
             }
-            if (wait || jsonOutput) {
+            if (options.wait || options.json) {
                 const response = await client.ai.prompt(prompt);
-                if (jsonOutput) {
+                if (options.json) {
                     console.log(JSON.stringify({
                         content: response.content,
                         model: response.model,
@@ -1915,36 +1610,8 @@ ${colors.bold(colors.yellow('Note:'))}
     });
     program
         .command('ip')
-        .alias('geo')
-        .alias('geoip')
-        .description('Look up geolocation and ISP info for an IP address')
+        .description('Get IP address intelligence using local GeoLite2 database')
         .argument('<address>', 'IP address to lookup')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Looks up geographic location and network information for an IP address
-  using the MaxMind GeoLite2 database (downloaded automatically on first use).
-
-  Shows city, region, country, coordinates, timezone, ISP/organization, and
-  whether it's a bogon (private/reserved) address. Works offline after the
-  initial database download.
-
-${colors.bold(colors.yellow('Information Displayed:'))}
-  - City, region, country
-  - Geographic coordinates (lat/long)
-  - Timezone
-  - ISP/Organization name
-  - ASN (Autonomous System Number)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ip 8.8.8.8')}                  Google DNS
-  ${colors.green('$ rek geo 1.1.1.1')}                 Cloudflare DNS
-  ${colors.green('$ rek geoip 151.101.1.140')}         GitHub's IP
-  ${colors.green('$ rek ip 192.168.1.1')}              Shows "Bogon/Private IP"
-
-${colors.bold(colors.yellow('Note:'))}
-  The GeoLite2 database (~70MB) is downloaded on first use and cached
-  in ~/.cache/recker/. Updates automatically when stale.
-`)
         .action(async (address) => {
         const { getIpInfo, isGeoIPAvailable } = await import('../mcp/ip-intel.js');
         if (!isGeoIPAvailable()) {
@@ -1983,34 +1650,9 @@ ${colors.bold('Network:')}
     program
         .command('tls')
         .alias('ssl')
-        .alias('cert')
         .description('Inspect TLS/SSL certificate of a host')
         .argument('<host>', 'Hostname or IP address')
         .argument('[port]', 'Port number (default: 443)', '443')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Connects to a server and inspects its TLS/SSL certificate. Shows the
-  certificate issuer, validity dates, days until expiration, subject
-  alternative names (SANs), and whether the certificate is trusted.
-
-  Useful for debugging SSL issues, checking certificate expiration before
-  it causes outages, or verifying a site's security configuration.
-
-${colors.bold(colors.yellow('Information Displayed:'))}
-  - Certificate validity status (valid/expired)
-  - Trust status (CA-signed or self-signed)
-  - Days remaining until expiration
-  - Issuer (Certificate Authority)
-  - Subject (domain name)
-  - Serial number and fingerprints
-  - Subject Alternative Names (SANs)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek tls google.com')}              Inspect Google's cert
-  ${colors.green('$ rek ssl api.stripe.com')}          Using ssl alias
-  ${colors.green('$ rek cert example.com 8443')}       Custom port
-  ${colors.green('$ rek tls 192.168.1.1 443')}         Check IP directly
-`)
         .action(async (host, port) => {
         const { inspectTLS } = await import('../utils/tls-inspector.js');
         console.log(colors.gray(`Inspecting TLS certificate for ${host}:${port}...`));
@@ -2078,43 +1720,15 @@ ${colors.bold('Fingerprints:')}
     });
     program
         .command('whois')
-        .description('Look up domain registration and ownership info')
+        .description('WHOIS lookup for domains and IP addresses')
         .argument('<query>', 'Domain name or IP address')
-        .argument('[args...]', 'Options: raw')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Queries WHOIS servers to retrieve domain registration information.
-  Shows registrar, creation/expiration dates, nameservers, and registrant
-  contact information (when available, many use privacy protection).
-
-  Also works with IP addresses to find network ownership information.
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('raw')}                    Show raw WHOIS response
-
-${colors.bold(colors.yellow('Information Displayed:'))}
-  - Domain status (active, expired, pending delete)
-  - Registrar name
-  - Creation/update/expiration dates
-  - Name servers
-  - Registrant, admin, tech contacts (if public)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek whois github.com')}           Domain registration info
-  ${colors.green('$ rek whois google.com raw')}       Raw WHOIS response
-  ${colors.green('$ rek whois 8.8.8.8')}              IP address ownership
-  ${colors.green('$ rek whois example.co.uk')}        ccTLD domains work too
-
-${colors.bold(colors.yellow('See also:'))}
-  ${colors.cyan('rek rdap <domain>')}                RDAP (modern WHOIS replacement)
-`)
-        .action(async (query, args) => {
+        .option('-r, --raw', 'Show raw WHOIS response')
+        .action(async (query, options) => {
         const { whois } = await import('../utils/whois.js');
-        const raw = args.includes('raw');
         console.log(colors.gray(`Looking up WHOIS for ${query}...`));
         try {
             const result = await whois(query);
-            if (raw) {
+            if (options.raw) {
                 console.log(result.raw);
                 return;
             }
@@ -2149,33 +1763,8 @@ ${colors.bold('Server:')} ${result.server}
     });
     program
         .command('rdap')
-        .description('RDAP lookup (modern WHOIS with JSON)')
+        .description('RDAP lookup (modern WHOIS replacement)')
         .argument('<domain>', 'Domain name to lookup')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Performs an RDAP (Registration Data Access Protocol) lookup for a domain.
-  RDAP is the modern, standardized replacement for WHOIS that returns
-  structured JSON data instead of unstructured text.
-
-  RDAP provides better data consistency, supports internationalized domain
-  names (IDN), and follows HTTP redirects to find authoritative servers.
-  All major TLDs now support RDAP.
-
-${colors.bold(colors.yellow('Advantages over WHOIS:'))}
-  - Structured JSON output (machine-readable)
-  - Better internationalization support
-  - Standardized by IETF (RFC 7480-7484)
-  - Bootstrap mechanism for TLD discovery
-  - Rate limiting with proper error codes
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek rdap github.com')}             Domain registration info
-  ${colors.green('$ rek rdap google.co.uk')}           ccTLD domains
-  ${colors.green('$ rek rdap cloudflare.com')}         Check registrar info
-
-${colors.bold(colors.yellow('See also:'))}
-  ${colors.cyan('rek whois <domain>')}               Traditional WHOIS lookup
-`)
         .action(async (domain) => {
         const { rdap } = await import('../utils/rdap.js');
         const { Client } = await import('../core/client.js');
@@ -2227,46 +1816,14 @@ ${colors.bold('Status:')} ${result.status?.join(', ') || 'N/A'}
     });
     program
         .command('ping')
-        .description('Test TCP connectivity to host:port')
+        .description('TCP connectivity check to a host')
         .argument('<host>', 'Hostname or IP address')
-        .argument('[args...]', 'Port and options: [port] count=4')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Tests TCP connectivity to a host and port, measuring connection latency.
-  Unlike ICMP ping, this actually establishes TCP connections, so it works
-  through most firewalls and accurately tests if a service is reachable.
-
-  Shows individual response times and calculates min/avg/max/stddev stats.
-  Perfect for testing if a server is up, measuring network latency, or
-  debugging connectivity issues.
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('[port]')}             Port number (default: 443)
-  ${colors.cyan('count=<n>')}          Number of pings (default: 4)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ping google.com')}              Test HTTPS (port 443)
-  ${colors.green('$ rek ping google.com 80')}           Test HTTP (port 80)
-  ${colors.green('$ rek ping db.server.com 5432')}      Test PostgreSQL port
-  ${colors.green('$ rek ping redis.local 6379 count=10')}  10 pings to Redis
-
-${colors.bold(colors.yellow('Output:'))}
-  Shows response time for each attempt, then summary statistics:
-  - min/avg/max response times
-  - standard deviation
-  - packet loss percentage
-`)
-        .action(async (host, args) => {
+        .argument('[port]', 'Port number (default: 80 for HTTP, 443 for HTTPS)', '443')
+        .option('-c, --count <n>', 'Number of pings', '4')
+        .action(async (host, port, options) => {
         const net = await import('node:net');
-        let port = 443;
-        let count = 4;
-        for (const arg of args) {
-            if (arg.startsWith('count='))
-                count = parseInt(arg.split('=')[1]);
-            else if (!arg.includes('=') && /^\d+$/.test(arg))
-                port = parseInt(arg);
-        }
-        const portNum = port;
+        const count = parseInt(options.count);
+        const portNum = parseInt(port);
         const results = [];
         console.log(colors.gray(`Pinging ${host}:${portNum}...`));
         console.log('');
@@ -2316,48 +1873,20 @@ ${colors.bold('Statistics:')}
         .command('ls')
         .description('List files in a remote directory')
         .argument('<host>', 'FTP server hostname')
-        .argument('[args...]', 'Path and options: [path] user=anonymous pass=anonymous@ port=21 secure implicit')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('user=<username>')}    Username (default: anonymous)
-  ${colors.cyan('pass=<password>')}    Password (default: anonymous@)
-  ${colors.cyan('port=<port>')}        Port number (default: 21)
-  ${colors.cyan('secure')}             Use FTPS (explicit TLS)
-  ${colors.cyan('implicit')}           Use implicit FTPS (port 990)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ftp ls ftp.example.com')}                          ${colors.gray('List root')}
-  ${colors.green('$ rek ftp ls ftp.example.com /pub')}                     ${colors.gray('List /pub directory')}
-  ${colors.green('$ rek ftp ls ftp.example.com user=admin pass=secret')}   ${colors.gray('With credentials')}
-`)
-        .action(async (host, args) => {
+        .argument('[path]', 'Remote path to list', '/')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, path, options) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        let path = '/';
-        let user = 'anonymous';
-        let pass = 'anonymous@';
-        let port = 21;
-        let secureOption = false;
-        let implicitOption = false;
-        for (const arg of args) {
-            if (arg.startsWith('user='))
-                user = arg.split('=')[1];
-            else if (arg.startsWith('pass='))
-                pass = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg === 'secure')
-                secureOption = true;
-            else if (arg === 'implicit')
-                implicitOption = true;
-            else if (!arg.includes('='))
-                path = arg;
-        }
-        const secure = implicitOption ? 'implicit' : secureOption ? true : false;
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
         const client = createFTP({
             host,
-            port,
-            user,
-            password: pass,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2400,50 +1929,22 @@ ${colors.bold(colors.yellow('Examples:'))}
         .description('Download a file from FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<remote>', 'Remote file path')
-        .argument('[args...]', 'Local path and options: [local] user=anonymous pass=anonymous@ port=21 secure implicit')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('user=<username>')}    Username (default: anonymous)
-  ${colors.cyan('pass=<password>')}    Password (default: anonymous@)
-  ${colors.cyan('port=<port>')}        Port number (default: 21)
-  ${colors.cyan('secure')}             Use FTPS (explicit TLS)
-  ${colors.cyan('implicit')}           Use implicit FTPS (port 990)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ftp get ftp.example.com /pub/file.zip')}                    ${colors.gray('Download file')}
-  ${colors.green('$ rek ftp get ftp.example.com /pub/file.zip myfile.zip')}         ${colors.gray('Save as different name')}
-  ${colors.green('$ rek ftp get ftp.example.com /data.csv user=admin pass=secret')} ${colors.gray('With credentials')}
-`)
-        .action(async (host, remote, args) => {
+        .argument('[local]', 'Local file path (default: same filename)')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remote, local, options) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const pathMod = await import('node:path');
-        let local;
-        let user = 'anonymous';
-        let pass = 'anonymous@';
-        let port = 21;
-        let secureOption = false;
-        let implicitOption = false;
-        for (const arg of args) {
-            if (arg.startsWith('user='))
-                user = arg.split('=')[1];
-            else if (arg.startsWith('pass='))
-                pass = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg === 'secure')
-                secureOption = true;
-            else if (arg === 'implicit')
-                implicitOption = true;
-            else if (!arg.includes('='))
-                local = arg;
-        }
-        const localPath = local || pathMod.basename(remote);
-        const secure = implicitOption ? 'implicit' : secureOption ? true : false;
+        const path = await import('node:path');
+        const localPath = local || path.basename(remote);
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
         const client = createFTP({
             host,
-            port,
-            user,
-            password: pass,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2483,50 +1984,22 @@ ${colors.bold(colors.yellow('Examples:'))}
         .description('Upload a file to FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<local>', 'Local file path')
-        .argument('[args...]', 'Remote path and options: [remote] user=anonymous pass=anonymous@ port=21 secure implicit')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('user=<username>')}    Username (default: anonymous)
-  ${colors.cyan('pass=<password>')}    Password (default: anonymous@)
-  ${colors.cyan('port=<port>')}        Port number (default: 21)
-  ${colors.cyan('secure')}             Use FTPS (explicit TLS)
-  ${colors.cyan('implicit')}           Use implicit FTPS (port 990)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ftp put ftp.example.com myfile.zip')}                         ${colors.gray('Upload file')}
-  ${colors.green('$ rek ftp put ftp.example.com myfile.zip /uploads/data.zip')}       ${colors.gray('Upload with path')}
-  ${colors.green('$ rek ftp put ftp.example.com data.csv user=admin pass=secret')}    ${colors.gray('With credentials')}
-`)
-        .action(async (host, local, args) => {
+        .argument('[remote]', 'Remote file path (default: same filename)')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, local, remote, options) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const pathMod = await import('node:path');
-        let remote;
-        let user = 'anonymous';
-        let pass = 'anonymous@';
-        let port = 21;
-        let secureOption = false;
-        let implicitOption = false;
-        for (const arg of args) {
-            if (arg.startsWith('user='))
-                user = arg.split('=')[1];
-            else if (arg.startsWith('pass='))
-                pass = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg === 'secure')
-                secureOption = true;
-            else if (arg === 'implicit')
-                implicitOption = true;
-            else if (!arg.includes('='))
-                remote = arg;
-        }
-        const remotePath = remote || '/' + pathMod.basename(local);
-        const secure = implicitOption ? 'implicit' : secureOption ? true : false;
+        const path = await import('node:path');
+        const remotePath = remote || '/' + path.basename(local);
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
         const client = createFTP({
             host,
-            port,
-            user,
-            password: pass,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2566,44 +2039,19 @@ ${colors.bold(colors.yellow('Examples:'))}
         .description('Delete a file from FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<path>', 'Remote file path to delete')
-        .argument('[args...]', 'Options: user=anonymous pass=anonymous@ port=21 secure implicit')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('user=<username>')}    Username (default: anonymous)
-  ${colors.cyan('pass=<password>')}    Password (default: anonymous@)
-  ${colors.cyan('port=<port>')}        Port number (default: 21)
-  ${colors.cyan('secure')}             Use FTPS (explicit TLS)
-  ${colors.cyan('implicit')}           Use implicit FTPS (port 990)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ftp rm ftp.example.com /uploads/old.zip')}                   ${colors.gray('Delete file')}
-  ${colors.green('$ rek ftp rm ftp.example.com /data.txt user=admin pass=secret')}   ${colors.gray('With credentials')}
-`)
-        .action(async (host, remotePath, args) => {
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remotePath, options) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        let user = 'anonymous';
-        let pass = 'anonymous@';
-        let port = 21;
-        let secureOption = false;
-        let implicitOption = false;
-        for (const arg of args) {
-            if (arg.startsWith('user='))
-                user = arg.split('=')[1];
-            else if (arg.startsWith('pass='))
-                pass = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg === 'secure')
-                secureOption = true;
-            else if (arg === 'implicit')
-                implicitOption = true;
-        }
-        const secure = implicitOption ? 'implicit' : secureOption ? true : false;
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
         const client = createFTP({
             host,
-            port,
-            user,
-            password: pass,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2634,44 +2082,19 @@ ${colors.bold(colors.yellow('Examples:'))}
         .description('Create a directory on FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<path>', 'Remote directory path to create')
-        .argument('[args...]', 'Options: user=anonymous pass=anonymous@ port=21 secure implicit')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('user=<username>')}    Username (default: anonymous)
-  ${colors.cyan('pass=<password>')}    Password (default: anonymous@)
-  ${colors.cyan('port=<port>')}        Port number (default: 21)
-  ${colors.cyan('secure')}             Use FTPS (explicit TLS)
-  ${colors.cyan('implicit')}           Use implicit FTPS (port 990)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek ftp mkdir ftp.example.com /uploads/new-folder')}               ${colors.gray('Create directory')}
-  ${colors.green('$ rek ftp mkdir ftp.example.com /data user=admin pass=secret')}      ${colors.gray('With credentials')}
-`)
-        .action(async (host, remotePath, args) => {
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remotePath, options) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        let user = 'anonymous';
-        let pass = 'anonymous@';
-        let port = 21;
-        let secureOption = false;
-        let implicitOption = false;
-        for (const arg of args) {
-            if (arg.startsWith('user='))
-                user = arg.split('=')[1];
-            else if (arg.startsWith('pass='))
-                pass = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg === 'secure')
-                secureOption = true;
-            else if (arg === 'implicit')
-                implicitOption = true;
-        }
-        const secure = implicitOption ? 'implicit' : secureOption ? true : false;
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
         const client = createFTP({
             host,
-            port,
-            user,
-            password: pass,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2701,31 +2124,15 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('telnet')
         .description('Connect to a Telnet server')
         .argument('<host>', 'Hostname or IP address')
-        .argument('[args...]', 'Port and options: [port] timeout=30000')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('[port]')}             Port number (default: 23)
-  ${colors.cyan('timeout=<ms>')}       Connection timeout in ms (default: 30000)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek telnet mail.example.com 25')}              ${colors.gray('Connect to SMTP server')}
-  ${colors.green('$ rek telnet host.example.com timeout=60000')}   ${colors.gray('With custom timeout')}
-`)
-        .action(async (host, args) => {
+        .argument('[port]', 'Port number', '23')
+        .option('-t, --timeout <ms>', 'Connection timeout in ms', '30000')
+        .action(async (host, port, options) => {
         const { createTelnet } = await import('../protocols/telnet.js');
-        let port = 23;
-        let timeout = 30000;
-        for (const arg of args) {
-            if (arg.startsWith('timeout='))
-                timeout = parseInt(arg.split('=')[1]);
-            else if (!arg.includes('=') && /^\d+$/.test(arg))
-                port = parseInt(arg);
-        }
         console.log(colors.gray(`Connecting to ${host}:${port}...`));
         const client = createTelnet({
             host,
-            port,
-            timeout,
+            port: parseInt(port),
+            timeout: parseInt(options.timeout),
         });
         try {
             await client.connect();
@@ -2775,37 +2182,9 @@ ${colors.bold(colors.yellow('Examples:'))}
     });
     dns
         .command('lookup')
-        .alias('resolve')
-        .description('Look up DNS records (A, MX, TXT, etc)')
+        .description('Perform DNS lookup for any record type')
         .argument('<domain>', 'Domain name to lookup')
         .argument('[type]', 'Record type (A, AAAA, CNAME, MX, NS, TXT, SOA, CAA, SRV, ANY)', 'A')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Queries DNS servers to resolve domain records. Returns IP addresses (A/AAAA),
-  mail servers (MX), name servers (NS), text records (TXT), and more.
-
-  Uses your system's configured DNS resolvers. For advanced queries with
-  custom nameservers, use ${colors.cyan('rek dns dig')} instead.
-
-${colors.bold(colors.yellow('Record Types:'))}
-  A         IPv4 address
-  AAAA      IPv6 address
-  CNAME     Canonical name (alias)
-  MX        Mail exchange servers
-  NS        Name servers
-  TXT       Text records (SPF, DKIM, etc)
-  SOA       Start of Authority
-  CAA       Certificate Authority Authorization
-  SRV       Service location
-  ANY       All available records
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek dns lookup google.com')}         A records (default)
-  ${colors.green('$ rek dns lookup google.com MX')}      Mail servers
-  ${colors.green('$ rek dns lookup google.com TXT')}     Text records
-  ${colors.green('$ rek dns lookup google.com ANY')}     All records
-  ${colors.green('$ rek dns resolve github.com AAAA')}   IPv6 addresses
-`)
         .action(async (domain, type) => {
         const { dnsLookup } = await import('../utils/dns-toolkit.js');
         console.log(colors.gray(`Looking up ${type.toUpperCase()} records for ${domain}...`));
@@ -3080,54 +2459,27 @@ ${colors.gray('Status:')} ${statusIcon}
     dns
         .command('generate-dmarc')
         .description('Generate a DMARC record interactively')
-        .argument('[args...]', 'Options: policy=none subdomain-policy=<policy> pct=100 rua=<emails> ruf=<emails>')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('policy=<policy>')}            Policy: none, quarantine, reject (default: none)
-  ${colors.cyan('subdomain-policy=<policy>')}  Subdomain policy
-  ${colors.cyan('pct=<percent>')}              Percentage of emails to apply policy (default: 100)
-  ${colors.cyan('rua=<emails>')}               Aggregate report email(s), comma-separated
-  ${colors.cyan('ruf=<emails>')}               Forensic report email(s), comma-separated
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek dns generate-dmarc')}                         ${colors.gray('Generate with defaults')}
-  ${colors.green('$ rek dns generate-dmarc policy=quarantine')}       ${colors.gray('Set quarantine policy')}
-  ${colors.green('$ rek dns generate-dmarc policy=reject pct=50')}    ${colors.gray('Reject 50% of failures')}
-  ${colors.green('$ rek dns generate-dmarc rua=admin@example.com')}   ${colors.gray('Send reports to email')}
-`)
-        .action(async (args) => {
+        .option('-p, --policy <policy>', 'Policy: none, quarantine, reject', 'none')
+        .option('--subdomain-policy <policy>', 'Subdomain policy')
+        .option('--pct <percent>', 'Percentage of emails to apply policy', '100')
+        .option('--rua <emails>', 'Aggregate report email(s), comma-separated')
+        .option('--ruf <emails>', 'Forensic report email(s), comma-separated')
+        .action(async (options) => {
         const { generateDmarc } = await import('../utils/dns-toolkit.js');
-        let policy = 'none';
-        let subdomainPolicy;
-        let pct = '100';
-        let rua;
-        let ruf;
-        for (const arg of args) {
-            if (arg.startsWith('policy='))
-                policy = arg.split('=')[1];
-            else if (arg.startsWith('subdomain-policy='))
-                subdomainPolicy = arg.split('=')[1];
-            else if (arg.startsWith('pct='))
-                pct = arg.split('=')[1];
-            else if (arg.startsWith('rua='))
-                rua = arg.split('=')[1];
-            else if (arg.startsWith('ruf='))
-                ruf = arg.split('=')[1];
-        }
         const dmarcOptions = {
-            policy,
+            policy: options.policy,
         };
-        if (subdomainPolicy) {
-            dmarcOptions.subdomainPolicy = subdomainPolicy;
+        if (options.subdomainPolicy) {
+            dmarcOptions.subdomainPolicy = options.subdomainPolicy;
         }
-        if (pct && pct !== '100') {
-            dmarcOptions.percentage = parseInt(pct);
+        if (options.pct && options.pct !== '100') {
+            dmarcOptions.percentage = parseInt(options.pct);
         }
-        if (rua) {
-            dmarcOptions.aggregateReports = rua.split(',').map((e) => e.trim());
+        if (options.rua) {
+            dmarcOptions.aggregateReports = options.rua.split(',').map((e) => e.trim());
         }
-        if (ruf) {
-            dmarcOptions.forensicReports = ruf.split(',').map((e) => e.trim());
+        if (options.ruf) {
+            dmarcOptions.forensicReports = options.ruf.split(',').map((e) => e.trim());
         }
         const record = generateDmarc(dmarcOptions);
         console.log(`
@@ -3209,68 +2561,22 @@ ${colors.bold(colors.yellow('Record Types:'))}
     });
     program
         .command('graphql')
-        .alias('gql')
-        .description('Execute GraphQL queries and mutations')
+        .description('Execute a GraphQL query')
         .argument('<url>', 'GraphQL endpoint URL')
-        .argument('[args...]', 'Options: query=<query> file=<file> variables=<json> var-file=<file> Header:Value')
-        .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Execute GraphQL queries and mutations against any GraphQL endpoint.
-  Supports inline queries, query files (.graphql), and variables from
-  JSON files or inline. Perfect for testing GraphQL APIs quickly.
-
-  Results are displayed as formatted JSON. Headers can be added for
-  authentication (Bearer tokens, API keys, etc).
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('query=<query>')}        Inline GraphQL query string
-  ${colors.cyan('file=<file>')}          Load query from .graphql file
-  ${colors.cyan('variables=<json>')}     Inline variables as JSON
-  ${colors.cyan('var-file=<file>')}      Load variables from JSON file
-  ${colors.cyan('Header:Value')}         Add header (can use multiple times)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek graphql https://api.github.com/graphql query="{ viewer { login } }"')}
-  ${colors.gray('  Simple query')}
-
-  ${colors.green('$ rek gql https://api.spacex.land/graphql query="{ rockets { name } }"')}
-  ${colors.gray('  Using the gql alias')}
-
-  ${colors.green('$ rek graphql api.example.com/graphql file=query.graphql variables=\'{"id": 123}\'')}
-  ${colors.gray('  Query from file with variables')}
-
-  ${colors.green('$ rek graphql api.com/graphql query="query User($id: ID!) { user(id: $id) { name } }" var-file=vars.json')}
-  ${colors.gray('  Parameterized query with variable file')}
-
-  ${colors.green('$ rek graphql api.com/graphql query="{ me { id } }" Authorization:"Bearer token123"')}
-  ${colors.gray('  With authentication header')}
-`)
-        .action(async (url, args) => {
+        .option('-q, --query <query>', 'GraphQL query string')
+        .option('-f, --file <file>', 'Path to GraphQL query file')
+        .option('-v, --variables <json>', 'Variables as JSON string')
+        .option('--var-file <file>', 'Path to variables JSON file')
+        .option('-H, --header <header>', 'Add header (can be used multiple times)', (val, prev) => [...prev, val], [])
+        .action(async (url, options) => {
         const { graphql } = await import('../plugins/graphql.js');
         const { createClient } = await import('../core/client.js');
         const fs = await import('node:fs/promises');
-        let queryStr;
-        let queryFile;
-        let variablesStr;
-        let varFile;
-        const headerArgs = [];
-        for (const arg of args) {
-            if (arg.startsWith('query='))
-                queryStr = arg.slice(6);
-            else if (arg.startsWith('file='))
-                queryFile = arg.slice(5);
-            else if (arg.startsWith('variables='))
-                variablesStr = arg.slice(10);
-            else if (arg.startsWith('var-file='))
-                varFile = arg.slice(9);
-            else if (arg.includes(':'))
-                headerArgs.push(arg);
-        }
-        let query = queryStr;
+        let query = options.query;
         let variables = {};
-        if (queryFile) {
+        if (options.file) {
             try {
-                query = await fs.readFile(queryFile, 'utf-8');
+                query = await fs.readFile(options.file, 'utf-8');
             }
             catch (err) {
                 console.error(colors.red(`Failed to read query file: ${err.message}`));
@@ -3278,22 +2584,22 @@ ${colors.bold(colors.yellow('Examples:'))}
             }
         }
         if (!query) {
-            console.error(colors.red('Error: Query is required. Use query= or file='));
-            console.log(colors.gray('Example: rek graphql https://api.example.com/graphql query="query { users { id name } }"'));
+            console.error(colors.red('Error: Query is required. Use --query or --file'));
+            console.log(colors.gray('Example: rek graphql https://api.example.com/graphql -q "query { users { id name } }"'));
             process.exit(1);
         }
-        if (variablesStr) {
+        if (options.variables) {
             try {
-                variables = JSON.parse(variablesStr);
+                variables = JSON.parse(options.variables);
             }
             catch {
-                console.error(colors.red('Invalid JSON in variables='));
+                console.error(colors.red('Invalid JSON in --variables'));
                 process.exit(1);
             }
         }
-        else if (varFile) {
+        else if (options.varFile) {
             try {
-                const content = await fs.readFile(varFile, 'utf-8');
+                const content = await fs.readFile(options.varFile, 'utf-8');
                 variables = JSON.parse(content);
             }
             catch (err) {
@@ -3304,7 +2610,7 @@ ${colors.bold(colors.yellow('Examples:'))}
         const headers = {
             'Content-Type': 'application/json',
         };
-        for (const h of headerArgs) {
+        for (const h of options.header) {
             const [key, ...valueParts] = h.split(':');
             headers[key.trim()] = valueParts.join(':').trim();
         }
@@ -3468,48 +2774,21 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('download')
         .description('Download an HLS stream')
         .argument('<url>', 'HLS playlist URL')
-        .argument('[args...]', 'Output and options: [output] quality=highest live duration=<seconds> concurrency=4')
-        .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('[output]')}             Output file path (default: output.ts)
-  ${colors.cyan('quality=<quality>')}    Quality: highest, lowest, or resolution (e.g., 720p)
-  ${colors.cyan('live')}                 Enable live stream mode
-  ${colors.cyan('duration=<seconds>')}   Duration for live recording in seconds
-  ${colors.cyan('concurrency=<n>')}      Concurrent segment downloads (default: 4)
-
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek hls download https://example.com/stream.m3u8')}                     ${colors.gray('Download stream')}
-  ${colors.green('$ rek hls download https://example.com/stream.m3u8 video.ts')}            ${colors.gray('Custom output')}
-  ${colors.green('$ rek hls download https://example.com/stream.m3u8 quality=720p')}        ${colors.gray('Select quality')}
-  ${colors.green('$ rek hls download https://example.com/live.m3u8 live duration=60')}      ${colors.gray('Record live stream')}
-`)
-        .action(async (url, args) => {
+        .argument('[output]', 'Output file path', 'output.ts')
+        .option('-q, --quality <quality>', 'Quality: highest, lowest, or resolution (e.g., 720p)')
+        .option('--live', 'Enable live stream mode')
+        .option('-d, --duration <seconds>', 'Duration for live recording in seconds')
+        .option('-c, --concurrency <n>', 'Concurrent segment downloads', '4')
+        .action(async (url, output, options) => {
         const { hls } = await import('../plugins/hls.js');
         const { Client } = await import('../core/client.js');
-        let output = 'output.ts';
-        let quality;
-        let live = false;
-        let duration;
-        let concurrency = 4;
-        for (const arg of args) {
-            if (arg.startsWith('quality='))
-                quality = arg.split('=')[1];
-            else if (arg === 'live')
-                live = true;
-            else if (arg.startsWith('duration='))
-                duration = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('concurrency='))
-                concurrency = parseInt(arg.split('=')[1]);
-            else if (!arg.includes('='))
-                output = arg;
-        }
         const client = new Client();
         console.log(colors.gray(`Downloading HLS stream from ${url}...`));
         console.log(colors.gray(`Output: ${output}`));
         console.log('');
         try {
             const hlsOptions = {
-                concurrency,
+                concurrency: parseInt(options.concurrency),
                 onProgress: (p) => {
                     const segs = p.totalSegments
                         ? `${p.downloadedSegments}/${p.totalSegments}`
@@ -3518,17 +2797,17 @@ ${colors.bold(colors.yellow('Examples:'))}
                     process.stdout.write(`\r  ${colors.cyan(segs)} segments | ${colors.cyan(mb + ' MB')} downloaded`);
                 },
             };
-            if (quality) {
-                if (quality === 'highest' || quality === 'lowest') {
-                    hlsOptions.quality = quality;
+            if (options.quality) {
+                if (options.quality === 'highest' || options.quality === 'lowest') {
+                    hlsOptions.quality = options.quality;
                 }
-                else if (quality.includes('p')) {
-                    hlsOptions.quality = { resolution: quality };
+                else if (options.quality.includes('p')) {
+                    hlsOptions.quality = { resolution: options.quality };
                 }
             }
-            if (live) {
-                hlsOptions.live = duration
-                    ? { duration: duration * 1000 }
+            if (options.live) {
+                hlsOptions.live = options.duration
+                    ? { duration: parseInt(options.duration) * 1000 }
                     : true;
             }
             await hls(client, url, hlsOptions).download(output);
@@ -3701,23 +2980,19 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('info')
         .description('Show information about a HAR file')
         .argument('<file>', 'HAR file to inspect')
-        .argument('[args...]', 'Options: json')
+        .option('--json', 'Output as JSON')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('json')}               Output as JSON
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek har info api.har')}
-  ${colors.green('$ rek har info api.har json')}
+  ${colors.green('$ rek har info api.har --json')}
 `)
-        .action(async (file, args) => {
+        .action(async (file, options) => {
         const { promises: fsPromises } = await import('node:fs');
-        const jsonOutput = args.includes('json');
         try {
             const content = await fsPromises.readFile(file, 'utf-8');
             const har = JSON.parse(content);
             const entries = har.log?.entries || [];
-            if (jsonOutput) {
+            if (options.json) {
                 const info = {
                     version: har.log?.version,
                     creator: har.log?.creator,
@@ -3844,66 +3119,28 @@ ${colors.bold(colors.yellow('Examples:'))}
     const serve = program.command('serve').description('Start mock servers for testing protocols');
     serve
         .command('http')
-        .description('Start a mock HTTP server for testing')
-        .argument('[args...]', 'Options: port=3000 host=127.0.0.1 echo delay=0 cors')
+        .description('Start a mock HTTP server')
+        .option('-p, --port <number>', 'Port to listen on', '3000')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--echo', 'Echo request body back in response')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
+        .option('--cors', 'Enable CORS', true)
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Starts a local mock HTTP server for testing HTTP clients, webhooks, or APIs.
-  Provides useful built-in endpoints for testing various HTTP scenarios.
-
-  Supports echo mode (returns the request back), configurable delays for
-  testing timeouts, and CORS for browser-based testing. Perfect for
-  integration tests, webhook development, or API prototyping.
-
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 3000)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('echo')}               Echo request body back in response
-  ${colors.cyan('delay=<ms>')}         Add delay to responses in ms (default: 0)
-  ${colors.cyan('cors')}               Enable CORS (default: true)
-
-${colors.bold(colors.yellow('Built-in Endpoints:'))}
-  GET  /                 Health check, returns { ok: true }
-  GET  /json             Sample JSON response
-  GET  /delay/:ms        Delayed response
-  POST /echo             Echo request body back
-  *    /status/:code     Return specific HTTP status code
-  GET  /headers          Return request headers
-
 ${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek serve http')}                    Start on port 3000
-  ${colors.green('$ rek serve http port=8080')}          Start on port 8080
-  ${colors.green('$ rek serve http echo')}               Echo mode (all routes)
-  ${colors.green('$ rek serve http delay=500')}          Add 500ms delay to all responses
+  ${colors.green('$ rek serve http')}                    ${colors.gray('Start on port 3000')}
+  ${colors.green('$ rek serve http -p 8080')}            ${colors.gray('Start on port 8080')}
+  ${colors.green('$ rek serve http --echo')}             ${colors.gray('Echo mode')}
+  ${colors.green('$ rek serve http --delay 500')}        ${colors.gray('Add 500ms delay')}
 `)
-        .action(async (args) => {
-        let port = 3000;
-        let host = '127.0.0.1';
-        let echo = false;
-        let delay = 0;
-        let cors = true;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg === 'echo')
-                echo = true;
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-            else if (arg === 'cors')
-                cors = true;
-            else if (arg === 'nocors')
-                cors = false;
-        }
+        .action(async (options) => {
         const { MockHttpServer } = await import('../testing/mock-http-server.js');
         const server = await MockHttpServer.create({
-            port,
-            host,
-            delay,
-            cors,
+            port: parseInt(options.port),
+            host: options.host,
+            delay: parseInt(options.delay),
+            cors: options.cors,
         });
-        if (echo) {
+        if (options.echo) {
             server.any('/*', (req) => ({
                 status: 200,
                 body: {
@@ -3920,8 +3157,8 @@ ${colors.bold(colors.yellow('Examples:'))}
 │  ${colors.bold('Recker Mock HTTP Server')}                   │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Mode: ${colors.yellow((echo ? 'Echo' : 'Default').padEnd(36))}│
-│  Delay: ${colors.gray((delay + 'ms').padEnd(35))}│
+│  Mode: ${colors.yellow((options.echo ? 'Echo' : 'Default').padEnd(36))}│
+│  Delay: ${colors.gray((options.delay + 'ms').padEnd(35))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -3939,18 +3176,15 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('webhook')
         .alias('wh')
         .description('Start a webhook receiver server')
-        .argument('[args...]', 'Options: port=3000 host=127.0.0.1 status=204 quiet')
+        .option('-p, --port <number>', 'Port to listen on', '3000')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('-s, --status <code>', 'Response status code (200 or 204)', '204')
+        .option('-q, --quiet', 'Disable logging', false)
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 3000)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('status=<code>')}      Response status code 200 or 204 (default: 204)
-  ${colors.cyan('quiet')}              Disable logging
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve webhook')}                 ${colors.gray('Start on port 3000')}
-  ${colors.green('$ rek serve wh port=8080')}            ${colors.gray('Start on port 8080')}
-  ${colors.green('$ rek serve webhook status=200')}      ${colors.gray('Return 200 instead of 204')}
+  ${colors.green('$ rek serve wh -p 8080')}              ${colors.gray('Start on port 8080')}
+  ${colors.green('$ rek serve webhook --status 200')}    ${colors.gray('Return 200 instead of 204')}
 
 ${colors.bold(colors.yellow('Endpoints:'))}
   * /              ${colors.gray('Receive webhook without ID')}
@@ -3959,32 +3193,18 @@ ${colors.bold(colors.yellow('Endpoints:'))}
 ${colors.bold(colors.yellow('Methods:'))}
   ${colors.gray('GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS')}
 `)
-        .action(async (args) => {
-        let port = 3000;
-        let host = '127.0.0.1';
-        let statusCode = 204;
-        let quiet = false;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('status='))
-                statusCode = parseInt(arg.split('=')[1]);
-            else if (arg === 'quiet')
-                quiet = true;
-        }
+        .action(async (options) => {
         const { createWebhookServer } = await import('../testing/mock-http-server.js');
-        const status = statusCode;
+        const status = parseInt(options.status);
         if (status !== 200 && status !== 204) {
             console.error(colors.red('Status must be 200 or 204'));
             process.exit(1);
         }
         const server = await createWebhookServer({
-            port,
-            host,
+            port: parseInt(options.port),
+            host: options.host,
             status,
-            log: !quiet,
+            log: !options.quiet,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
@@ -4010,51 +3230,32 @@ ${colors.bold(colors.yellow('Methods:'))}
         .command('websocket')
         .alias('ws')
         .description('Start a mock WebSocket server')
-        .argument('[args...]', 'Options: port=8080 host=127.0.0.1 echo noecho delay=0')
+        .option('-p, --port <number>', 'Port to listen on', '8080')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--echo', 'Echo messages back (default: true)', true)
+        .option('--no-echo', 'Disable echo mode')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 8080)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('echo')}               Echo messages back (default)
-  ${colors.cyan('noecho')}             Disable echo mode
-  ${colors.cyan('delay=<ms>')}         Add delay to responses in ms (default: 0)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve websocket')}               ${colors.gray('Start on port 8080')}
-  ${colors.green('$ rek serve ws port=9000')}            ${colors.gray('Start on port 9000')}
-  ${colors.green('$ rek serve ws noecho')}               ${colors.gray('Disable echo')}
+  ${colors.green('$ rek serve ws -p 9000')}              ${colors.gray('Start on port 9000')}
+  ${colors.green('$ rek serve ws --no-echo')}            ${colors.gray('Disable echo')}
 `)
-        .action(async (args) => {
-        let port = 8080;
-        let host = '127.0.0.1';
-        let echo = true;
-        let delay = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg === 'echo')
-                echo = true;
-            else if (arg === 'noecho')
-                echo = false;
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-        }
+        .action(async (options) => {
         const { MockWebSocketServer } = await import('../testing/mock-websocket-server.js');
         const server = await MockWebSocketServer.create({
-            port,
-            host,
-            echo,
-            delay,
+            port: parseInt(options.port),
+            host: options.host,
+            echo: options.echo,
+            delay: parseInt(options.delay),
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock WebSocket Server')}              │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
-│  Delay: ${colors.gray((delay + 'ms').padEnd(35))}│
+│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Delay: ${colors.gray((options.delay + 'ms').padEnd(35))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -4078,53 +3279,36 @@ ${colors.bold(colors.yellow('Examples:'))}
     serve
         .command('sse')
         .description('Start a mock SSE (Server-Sent Events) server')
-        .argument('[args...]', 'Options: port=8081 host=127.0.0.1 path=/events heartbeat=0')
+        .option('-p, --port <number>', 'Port to listen on', '8081')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--path <string>', 'SSE endpoint path', '/events')
+        .option('--heartbeat <ms>', 'Send heartbeat every N ms (0 = disabled)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 8081)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('path=<string>')}      SSE endpoint path (default: /events)
-  ${colors.cyan('heartbeat=<ms>')}     Send heartbeat every N ms (0 = disabled)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve sse')}                     ${colors.gray('Start on port 8081')}
-  ${colors.green('$ rek serve sse port=9000')}           ${colors.gray('Start on port 9000')}
-  ${colors.green('$ rek serve sse heartbeat=5000')}      ${colors.gray('Send heartbeat every 5s')}
+  ${colors.green('$ rek serve sse -p 9000')}             ${colors.gray('Start on port 9000')}
+  ${colors.green('$ rek serve sse --heartbeat 5000')}    ${colors.gray('Send heartbeat every 5s')}
 
 ${colors.bold(colors.yellow('Interactive Commands:'))}
   Type a message and press Enter to broadcast it to all clients.
 `)
-        .action(async (args) => {
-        let port = 8081;
-        let host = '127.0.0.1';
-        let path = '/events';
-        let heartbeat = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('path='))
-                path = arg.split('=')[1];
-            else if (arg.startsWith('heartbeat='))
-                heartbeat = parseInt(arg.split('=')[1]);
-        }
+        .action(async (options) => {
         const { MockSSEServer } = await import('../testing/mock-sse-server.js');
         const readline = await import('node:readline');
         const server = await MockSSEServer.create({
-            port,
-            host,
-            path,
+            port: parseInt(options.port),
+            host: options.host,
+            path: options.path,
         });
-        if (heartbeat > 0) {
-            server.startPeriodicEvents('heartbeat', heartbeat);
+        if (parseInt(options.heartbeat) > 0) {
+            server.startPeriodicEvents('heartbeat', parseInt(options.heartbeat));
         }
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock SSE Server')}                    │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Heartbeat: ${colors.yellow((heartbeat === 0 ? 'Disabled' : heartbeat + 'ms').padEnd(31))}│
+│  Heartbeat: ${colors.yellow((options.heartbeat === '0' ? 'Disabled' : options.heartbeat + 'ms').padEnd(31))}│
 ├─────────────────────────────────────────────┤
 │  Type message + Enter to broadcast          │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
@@ -4156,51 +3340,30 @@ ${colors.bold(colors.yellow('Interactive Commands:'))}
     serve
         .command('hls')
         .description('Start a mock HLS streaming server')
-        .argument('[args...]', 'Options: port=8082 host=127.0.0.1 mode=vod segments=10 duration=6 qualities=720p,480p,360p')
+        .option('-p, --port <number>', 'Port to listen on', '8082')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--mode <type>', 'Stream mode: vod, live, event', 'vod')
+        .option('--segments <number>', 'Number of segments (VOD mode)', '10')
+        .option('--duration <seconds>', 'Segment duration in seconds', '6')
+        .option('--qualities <list>', 'Comma-separated quality variants', '720p,480p,360p')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 8082)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('mode=<type>')}        Stream mode: vod, live, event (default: vod)
-  ${colors.cyan('segments=<n>')}       Number of segments for VOD (default: 10)
-  ${colors.cyan('duration=<sec>')}     Segment duration in seconds (default: 6)
-  ${colors.cyan('qualities=<list>')}   Comma-separated quality variants (default: 720p,480p,360p)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve hls')}                     ${colors.gray('Start VOD server')}
-  ${colors.green('$ rek serve hls mode=live')}           ${colors.gray('Start live stream')}
-  ${colors.green('$ rek serve hls segments=20')}         ${colors.gray('VOD with 20 segments')}
-  ${colors.green('$ rek serve hls qualities=1080p,720p,480p')}
+  ${colors.green('$ rek serve hls --mode live')}         ${colors.gray('Start live stream')}
+  ${colors.green('$ rek serve hls --segments 20')}       ${colors.gray('VOD with 20 segments')}
+  ${colors.green('$ rek serve hls --qualities 1080p,720p,480p')}
 
 ${colors.bold(colors.yellow('Endpoints:'))}
   ${colors.cyan('/master.m3u8')}     Master playlist (multi-quality)
   ${colors.cyan('/playlist.m3u8')}   Single quality playlist
   ${colors.cyan('/<quality>/playlist.m3u8')}  Quality-specific playlist
 `)
-        .action(async (args) => {
-        let port = 8082;
-        let host = '127.0.0.1';
-        let mode = 'vod';
-        let segments = 10;
-        let duration = 6;
-        let qualitiesStr = '720p,480p,360p';
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('mode='))
-                mode = arg.split('=')[1];
-            else if (arg.startsWith('segments='))
-                segments = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('duration='))
-                duration = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('qualities='))
-                qualitiesStr = arg.split('=')[1];
-        }
+        .action(async (options) => {
         const { MockHlsServer } = await import('../testing/mock-hls-server.js');
         const http = await import('node:http');
-        const qualities = qualitiesStr.split(',').map(q => q.trim());
+        const port = parseInt(options.port);
+        const host = options.host;
+        const qualities = options.qualities.split(',').map(q => q.trim());
         const resolutions = ['1920x1080', '1280x720', '854x480', '640x360', '426x240'];
         const bandwidths = [5000000, 2500000, 1400000, 800000, 500000];
         const variants = qualities.map((name, i) => ({
@@ -4211,9 +3374,9 @@ ${colors.bold(colors.yellow('Endpoints:'))}
         const baseUrl = `http://${host}:${port}`;
         const hlsServer = await MockHlsServer.create({
             baseUrl,
-            mode: mode,
-            segmentCount: segments,
-            segmentDuration: duration,
+            mode: options.mode,
+            segmentCount: parseInt(options.segments),
+            segmentDuration: parseInt(options.duration),
             multiQuality: variants.length > 1,
             variants: variants.length > 1 ? variants : undefined,
         });
@@ -4239,9 +3402,9 @@ ${colors.bold(colors.yellow('Endpoints:'))}
 │  ${colors.bold('Recker Mock HLS Server')}                    │
 ├─────────────────────────────────────────────┤
 │  Master: ${colors.cyan((hlsServer.manifestUrl).padEnd(34))}│
-│  Mode: ${colors.yellow(mode.padEnd(36))}│
-│  Segments: ${colors.gray(String(segments).padEnd(32))}│
-│  Duration: ${colors.gray((duration + 's').padEnd(32))}│
+│  Mode: ${colors.yellow(options.mode.padEnd(36))}│
+│  Segments: ${colors.gray(options.segments.padEnd(32))}│
+│  Duration: ${colors.gray((options.duration + 's').padEnd(32))}│
 │  Qualities: ${colors.cyan(qualities.join(', ').padEnd(31))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
@@ -4258,46 +3421,30 @@ ${colors.bold(colors.yellow('Endpoints:'))}
     serve
         .command('udp')
         .description('Start a mock UDP server')
-        .argument('[args...]', 'Options: port=9000 host=127.0.0.1 echo noecho')
+        .option('-p, --port <number>', 'Port to listen on', '9000')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--echo', 'Echo messages back (default: true)', true)
+        .option('--no-echo', 'Disable echo mode')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 9000)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('echo')}               Echo messages back (default)
-  ${colors.cyan('noecho')}             Disable echo mode
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve udp')}                     ${colors.gray('Start on port 9000')}
-  ${colors.green('$ rek serve udp port=5353')}           ${colors.gray('Start on port 5353')}
-  ${colors.green('$ rek serve udp noecho')}              ${colors.gray('Disable echo')}
+  ${colors.green('$ rek serve udp -p 5353')}             ${colors.gray('Start on port 5353')}
+  ${colors.green('$ rek serve udp --no-echo')}           ${colors.gray('Disable echo')}
 `)
-        .action(async (args) => {
-        let port = 9000;
-        let host = '127.0.0.1';
-        let echo = true;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg === 'echo')
-                echo = true;
-            else if (arg === 'noecho')
-                echo = false;
-        }
+        .action(async (options) => {
         const { MockUDPServer } = await import('../testing/mock-udp-server.js');
         const server = new MockUDPServer({
-            port,
-            host,
-            echo,
+            port: parseInt(options.port),
+            host: options.host,
+            echo: options.echo,
         });
         await server.start();
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock UDP Server')}                    │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
-│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
+│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -4315,16 +3462,13 @@ ${colors.bold(colors.yellow('Examples:'))}
     serve
         .command('dns')
         .description('Start a mock DNS server')
-        .argument('[args...]', 'Options: port=5353 host=127.0.0.1 delay=0')
+        .option('-p, --port <number>', 'Port to listen on', '5353')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 5353)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('delay=<ms>')}         Add delay to responses in ms (default: 0)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve dns')}                     ${colors.gray('Start on port 5353')}
-  ${colors.green('$ rek serve dns port=53')}             ${colors.gray('Start on standard port (requires root)')}
+  ${colors.green('$ rek serve dns -p 53')}               ${colors.gray('Start on standard port (requires root)')}
   ${colors.green('$ dig @127.0.0.1 -p 5353 example.com')} ${colors.gray('Test with dig')}
 
 ${colors.bold(colors.yellow('Default Records:'))}
@@ -4332,32 +3476,21 @@ ${colors.bold(colors.yellow('Default Records:'))}
   ${colors.cyan('example.com')}    A, AAAA, NS, MX, TXT records
   ${colors.cyan('test.local')}     A: 192.168.1.100
 `)
-        .action(async (args) => {
-        let port = 5353;
-        let host = '127.0.0.1';
-        let delay = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-        }
+        .action(async (options) => {
         const { MockDnsServer } = await import('../testing/mock-dns-server.js');
         const server = await MockDnsServer.create({
-            port,
-            host,
-            delay,
+            port: parseInt(options.port),
+            host: options.host,
+            delay: parseInt(options.delay),
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock DNS Server')}                    │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
+│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
 │  Protocol: ${colors.yellow('UDP'.padEnd(32))}│
 ├─────────────────────────────────────────────┤
-│  Test: dig @${host} -p ${port} example.com        │
+│  Test: dig @${options.host} -p ${options.port} example.com        │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -4373,13 +3506,10 @@ ${colors.bold(colors.yellow('Default Records:'))}
     serve
         .command('whois')
         .description('Start a mock WHOIS server')
-        .argument('[args...]', 'Options: port=4343 host=127.0.0.1 delay=0')
+        .option('-p, --port <number>', 'Port to listen on', '4343')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 4343)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('delay=<ms>')}         Add delay to responses in ms (default: 0)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve whois')}                    ${colors.gray('Start on port 4343')}
   ${colors.green('$ whois -h 127.0.0.1 -p 4343 example.com')} ${colors.gray('Test with whois')}
@@ -4389,32 +3519,21 @@ ${colors.bold(colors.yellow('Default Domains:'))}
   ${colors.cyan('google.com')}     MarkMonitor registrar
   ${colors.cyan('test.local')}     Test domain
 `)
-        .action(async (args) => {
-        let port = 4343;
-        let host = '127.0.0.1';
-        let delay = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-        }
+        .action(async (options) => {
         const { MockWhoisServer } = await import('../testing/mock-whois-server.js');
         const server = await MockWhoisServer.create({
-            port,
-            host,
-            delay,
+            port: parseInt(options.port),
+            host: options.host,
+            delay: parseInt(options.delay),
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock WHOIS Server')}                  │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
+│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
 │  Protocol: ${colors.yellow('TCP'.padEnd(32))}│
 ├─────────────────────────────────────────────┤
-│  Test: whois -h ${host} -p ${port} example.com │
+│  Test: whois -h ${options.host} -p ${options.port} example.com │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -4430,15 +3549,12 @@ ${colors.bold(colors.yellow('Default Domains:'))}
     serve
         .command('telnet')
         .description('Start a mock Telnet server')
-        .argument('[args...]', 'Options: port=2323 host=127.0.0.1 echo noecho delay=0')
+        .option('-p, --port <number>', 'Port to listen on', '2323')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('--echo', 'Echo input back (default: true)', true)
+        .option('--no-echo', 'Disable echo mode')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}      Port to listen on (default: 2323)
-  ${colors.cyan('host=<string>')}      Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('echo')}               Echo input back (default)
-  ${colors.cyan('noecho')}             Disable echo mode
-  ${colors.cyan('delay=<ms>')}         Add delay to responses in ms (default: 0)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve telnet')}                   ${colors.gray('Start on port 2323')}
   ${colors.green('$ telnet localhost 2323')}              ${colors.gray('Connect to server')}
@@ -4451,38 +3567,22 @@ ${colors.bold(colors.yellow('Built-in Commands:'))}
   ${colors.cyan('ping')}        Returns "pong"
   ${colors.cyan('quit')}        Disconnect
 `)
-        .action(async (args) => {
-        let port = 2323;
-        let host = '127.0.0.1';
-        let echo = true;
-        let delay = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg === 'echo')
-                echo = true;
-            else if (arg === 'noecho')
-                echo = false;
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-        }
+        .action(async (options) => {
         const { MockTelnetServer } = await import('../testing/mock-telnet-server.js');
         const server = await MockTelnetServer.create({
-            port,
-            host,
-            echo,
-            delay,
+            port: parseInt(options.port),
+            host: options.host,
+            echo: options.echo,
+            delay: parseInt(options.delay),
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock Telnet Server')}                 │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
-│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
+│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
 ├─────────────────────────────────────────────┤
-│  Connect: telnet ${host} ${port}               │
+│  Connect: telnet ${options.host} ${options.port}               │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -4504,21 +3604,18 @@ ${colors.bold(colors.yellow('Built-in Commands:'))}
     serve
         .command('ftp')
         .description('Start a mock FTP server')
-        .argument('[args...]', 'Options: port=2121 host=127.0.0.1 username=user password=pass anonymous noanonymous delay=0')
+        .option('-p, --port <number>', 'Port to listen on', '2121')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('-u, --username <user>', 'Username for auth', 'user')
+        .option('--password <pass>', 'Password for auth', 'pass')
+        .option('--anonymous', 'Allow anonymous login (default: true)', true)
+        .option('--no-anonymous', 'Disable anonymous login')
+        .option('--delay <ms>', 'Add delay to responses (milliseconds)', '0')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('port=<number>')}       Port to listen on (default: 2121)
-  ${colors.cyan('host=<string>')}       Host to bind to (default: 127.0.0.1)
-  ${colors.cyan('username=<user>')}     Username for auth (default: user)
-  ${colors.cyan('password=<pass>')}     Password for auth (default: pass)
-  ${colors.cyan('anonymous')}           Allow anonymous login (default)
-  ${colors.cyan('noanonymous')}         Disable anonymous login
-  ${colors.cyan('delay=<ms>')}          Add delay to responses (default: 0)
-
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek serve ftp')}                      ${colors.gray('Start on port 2121')}
   ${colors.green('$ ftp localhost 2121')}                 ${colors.gray('Connect to server')}
-  ${colors.green('$ rek serve ftp noanonymous')}          ${colors.gray('Require authentication')}
+  ${colors.green('$ rek serve ftp --no-anonymous')}       ${colors.gray('Require authentication')}
 
 ${colors.bold(colors.yellow('Default Files:'))}
   ${colors.cyan('/welcome.txt')}        Welcome message
@@ -4530,47 +3627,25 @@ ${colors.bold(colors.yellow('Credentials:'))}
   Username: ${colors.cyan('user')}  Password: ${colors.cyan('pass')}
   Or use anonymous login with user: ${colors.cyan('anonymous')}
 `)
-        .action(async (args) => {
+        .action(async (options) => {
         const { MockFtpServer } = await import('../testing/mock-ftp-server.js');
-        let port = 2121;
-        let host = '127.0.0.1';
-        let username = 'user';
-        let password = 'pass';
-        let anonymous = true;
-        let delay = 0;
-        for (const arg of args) {
-            if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('host='))
-                host = arg.split('=')[1];
-            else if (arg.startsWith('username='))
-                username = arg.split('=')[1];
-            else if (arg.startsWith('password='))
-                password = arg.split('=')[1];
-            else if (arg === 'anonymous')
-                anonymous = true;
-            else if (arg === 'noanonymous')
-                anonymous = false;
-            else if (arg.startsWith('delay='))
-                delay = parseInt(arg.split('=')[1]);
-        }
         const server = await MockFtpServer.create({
-            port,
-            host,
-            username,
-            password,
-            anonymous,
-            delay,
+            port: parseInt(options.port),
+            host: options.host,
+            username: options.username,
+            password: options.password,
+            anonymous: options.anonymous,
+            delay: parseInt(options.delay),
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock FTP Server')}                    │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
-│  Anonymous: ${colors.yellow((anonymous ? 'Allowed' : 'Disabled').padEnd(31))}│
-│  User: ${colors.cyan(username.padEnd(36))}│
+│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
+│  Anonymous: ${colors.yellow((options.anonymous ? 'Allowed' : 'Disabled').padEnd(31))}│
+│  User: ${colors.cyan(options.username.padEnd(36))}│
 ├─────────────────────────────────────────────┤
-│  Connect: ftp ${host} ${port}                  │
+│  Connect: ftp ${options.host} ${options.port}                  │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -4592,25 +3667,22 @@ ${colors.bold(colors.yellow('Credentials:'))}
     program
         .command('mcp')
         .description('Start MCP server for AI agents to access Recker documentation')
-        .argument('[args...]', 'Options: transport=stdio port=3100 docs=<path> tools=<paths> debug')
+        .option('-t, --transport <mode>', 'Transport mode: stdio, http, sse', 'stdio')
+        .option('-p, --port <number>', 'Server port (for http/sse modes)', '3100')
+        .option('-d, --docs <path>', 'Path to documentation folder')
+        .option('-T, --tools <paths...>', 'Paths to external tool modules to load')
+        .option('--debug', 'Enable debug logging')
         .addHelpText('after', `
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('transport=<mode>')}    Transport mode: stdio, http, sse (default: stdio)
-  ${colors.cyan('port=<number>')}       Server port for http/sse modes (default: 3100)
-  ${colors.cyan('docs=<path>')}         Path to documentation folder
-  ${colors.cyan('tools=<paths>')}       Paths to external tool modules (comma-separated)
-  ${colors.cyan('debug')}               Enable debug logging
-
 ${colors.bold(colors.yellow('Transport Modes:'))}
   ${colors.cyan('stdio')}  ${colors.gray('(default)')} For Claude Code and other CLI tools
   ${colors.cyan('http')}   Simple HTTP POST endpoint
   ${colors.cyan('sse')}    HTTP + Server-Sent Events for real-time notifications
 
-${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek mcp')}                           ${colors.gray('Start in stdio mode (for Claude Code)')}
-  ${colors.green('$ rek mcp transport=http')}            ${colors.gray('Start HTTP server on port 3100')}
-  ${colors.green('$ rek mcp transport=sse port=8080')}   ${colors.gray('Start SSE server on custom port')}
-  ${colors.green('$ rek mcp debug')}                     ${colors.gray('Enable debug logging')}
+${colors.bold(colors.yellow('Usage:'))}
+  ${colors.green('$ rek mcp')}                    ${colors.gray('Start in stdio mode (for Claude Code)')}
+  ${colors.green('$ rek mcp -t http')}            ${colors.gray('Start HTTP server on port 3100')}
+  ${colors.green('$ rek mcp -t sse -p 8080')}     ${colors.gray('Start SSE server on custom port')}
+  ${colors.green('$ rek mcp --debug')}            ${colors.gray('Enable debug logging')}
 
 ${colors.bold(colors.yellow('Tools provided:'))}
   ${colors.cyan('search_docs')}  Search documentation by keyword
@@ -4626,31 +3698,15 @@ ${colors.bold(colors.yellow('Claude Code config (~/.claude.json):'))}
     }
   }`)}
 `)
-        .action(async (args) => {
+        .action(async (options) => {
         const { MCPServer } = await import('../mcp/server.js');
-        let transport = 'stdio';
-        let port = 3100;
-        let docsPath;
-        let debug = false;
-        let toolPaths;
-        for (const arg of args) {
-            if (arg.startsWith('transport='))
-                transport = arg.split('=')[1];
-            else if (arg.startsWith('port='))
-                port = parseInt(arg.split('=')[1]);
-            else if (arg.startsWith('docs='))
-                docsPath = arg.split('=')[1];
-            else if (arg.startsWith('tools='))
-                toolPaths = arg.split('=')[1].split(',');
-            else if (arg === 'debug')
-                debug = true;
-        }
+        const transport = options.transport;
         const server = new MCPServer({
             transport,
-            port,
-            docsPath,
-            debug,
-            toolPaths,
+            port: parseInt(options.port),
+            docsPath: options.docs,
+            debug: options.debug,
+            toolPaths: options.tools,
         });
         if (transport === 'stdio') {
             await server.start();
@@ -4669,7 +3725,7 @@ ${colors.bold(colors.yellow('Claude Code config (~/.claude.json):'))}
 │  ${colors.bold('Recker MCP Server')}                         │
 ├─────────────────────────────────────────────┤
 │  Transport: ${colors.cyan(transport.padEnd(31))}│
-│  Endpoint: ${colors.cyan(`http://localhost:${port}`.padEnd(32))}│
+│  Endpoint: ${colors.cyan(`http://localhost:${options.port}`.padEnd(32))}│
 │  Docs indexed: ${colors.yellow(String(server.getDocsCount()).padEnd(28))}│
 ├─────────────────────────────────────────────┤${endpoints}
 ├─────────────────────────────────────────────┤
@@ -5345,39 +4401,21 @@ ${colors.bold(colors.yellow('Examples:'))}
     });
     program
         .command('proxy')
-        .description('Route requests through HTTP or SOCKS proxy')
+        .description('Make a request through a proxy')
         .argument('<proxy>', 'Proxy URL (http://host:port or socks5://host:port)')
         .argument('<url>', 'Target URL')
         .argument('[args...]', 'Request arguments: method=x key=value key:=json Header:value')
         .addHelpText('after', `
-${colors.bold(colors.blue('What it does:'))}
-  Routes HTTP requests through a proxy server. Supports HTTP, HTTPS, and SOCKS5
-  proxies. Useful for bypassing geo-restrictions, debugging traffic, accessing
-  internal networks, or anonymizing requests.
-
-  The proxy URL can include authentication (user:pass@host:port).
-  All standard rek request options (headers, body, method) work normally.
-
-${colors.bold(colors.yellow('Supported Proxy Types:'))}
-  http://host:port         HTTP proxy
-  https://host:port        HTTPS proxy
-  socks5://host:port       SOCKS5 proxy (Tor, SSH tunnels)
-
-${colors.bold(colors.yellow('Request Syntax:'))}
-  method=<method>          HTTP method (default: GET)
-  key=value                String data (form/JSON body)
-  key:=json                JSON value (numbers, booleans, objects)
-  Header:value             HTTP headers
+${colors.bold(colors.yellow('Parameters:'))}
+  method=<method>    HTTP method (default: GET)
+  key=value          String data
+  key:=json          JSON data
+  Header:value       HTTP headers (Key:Value format)
 
 ${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek proxy http://proxy.example.com:8080 api.com/data')}
-  ${colors.gray('  Simple GET through HTTP proxy')}
-
-  ${colors.green('$ rek proxy socks5://127.0.0.1:9050 api.com/users')}
-  ${colors.gray('  Route through Tor (SOCKS5 on port 9050)')}
-
-  ${colors.green('$ rek proxy http://user:pass@proxy.com:3128 api.com method=POST name="John"')}
-  ${colors.gray('  POST with authentication')}
+  ${colors.green('$ rek proxy http://proxy.example.com:8080 https://api.com/data')}
+  ${colors.green('$ rek proxy socks5://127.0.0.1:1080 https://api.com/users')}
+  ${colors.green('$ rek proxy http://user:pass@proxy.com:3128 api.com/endpoint method=POST data=test')}
 `)
         .action(async (proxy, url, args) => {
         const { createClient } = await import('../core/client.js');
@@ -5436,13 +4474,6 @@ ${colors.bold(colors.yellow('Examples:'))}
             process.exit(1);
         }
     });
-    function applyHelpAfterError(cmd) {
-        cmd.showHelpAfterError(true);
-        for (const subcmd of cmd.commands) {
-            applyHelpAfterError(subcmd);
-        }
-    }
-    applyHelpAfterError(program);
     program.parse();
 }
 main().catch((error) => {