recker 1.0.37 → 1.0.39-next.8bbc11c

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import colors from '../utils/colors.js';
 import { formatColumns } from '../utils/columns.js';
 import { summarizeErrors, formatErrorSummary } from './helpers.js';
+import { getVersion, formatVersionInfo } from '../version.js';
 async function readStdin() {
     if (process.stdin.isTTY) {
         return null;
@@ -69,13 +70,7 @@ async function main() {
     const { handleRequest } = await import('./handler.js');
     const { resolvePreset } = await import('./presets.js');
     const presets = await import('../presets/index.js');
-    let version = '0.0.0';
-    try {
-        const pkg = await import('../../package.json', { with: { type: 'json' } });
-        version = pkg.default?.version || '0.0.0';
-    }
-    catch {
-    }
+    const version = await getVersion();
     function parseMixedArgs(args, hasPreset = false) {
         const headers = {};
         const data = {};
@@ -133,6 +128,7 @@ 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)')
@@ -281,7 +277,27 @@ Error: ${error.message}`));
     });
     program
         .command('completion')
-        .description('Generate shell completion script')
+        .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)')}
+`)
         .action(() => {
         const script = `
 ###-begin-rek-completion-###
@@ -326,12 +342,71 @@ complete -F _rek_completions rek
 `;
         console.log(script);
     });
+    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) {
+            console.log(version);
+            return;
+        }
+        if (formatJson) {
+            const { getVersionInfo } = await import('../version.js');
+            const info = await getVersionInfo();
+            console.log(JSON.stringify(info, null, 2));
+            return;
+        }
+        const versionInfo = await formatVersionInfo(true);
+        console.log(colors.bold(colors.cyan('recker')) + ' ' + colors.green(version));
+        console.log(colors.gray(versionInfo));
+    });
     program
         .command('shell')
         .alias('interactive')
         .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 {
@@ -349,7 +424,22 @@ complete -F _rek_completions rek
     program
         .command('docs [query...]')
         .alias('?')
-        .description('Search Recker documentation (opens fullscreen panel)')
+        .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
+`)
         .action(async (queryParts) => {
         const query = queryParts.join(' ').trim();
         const { openSearchPanel } = await import('./tui/search-panel.js');
@@ -358,8 +448,39 @@ complete -F _rek_completions rek
     program
         .command('security')
         .alias('headers')
-        .description('Analyze HTTP response headers for security best practices')
+        .alias('grade')
+        .description('Grade a website\'s security headers (A+ to F)')
         .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}`;
@@ -401,16 +522,30 @@ ${colors.bold('Details:')}`);
     });
     program
         .command('seo')
-        .description('Analyze page SEO (title, meta, headings, links, images, structured data)')
+        .alias('audit')
+        .description('Analyze a page\'s SEO health (80+ checks)')
         .argument('<url>', 'URL to analyze')
-        .option('-a, --all', 'Show all checks including passed ones')
-        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .argument('[args...]', 'Options: all format=json')
         .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 -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.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.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Title Tag')}          Length and presence
@@ -423,10 +558,11 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Structured Data')}    JSON-LD presence
   ${colors.cyan('Technical')}          Canonical, viewport, lang
 `)
-        .action(async (url, options) => {
+        .action(async (url, args) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        const isJson = options.format === 'json';
+        const showAll = args.includes('all');
+        const isJson = args.some(a => a === 'format=json' || a === 'json');
         const { createClient } = await import('../core/client.js');
         const { analyzeSeo } = await import('../seo/analyzer.js');
         if (!isJson) {
@@ -503,11 +639,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 = options.all
+            const checksToShow = showAll
                 ? report.checks
                 : report.checks.filter(c => c.status !== 'pass' && c.status !== 'info');
-            if (checksToShow.length === 0 && !options.all) {
-                console.log(colors.green('  All checks passed! Use -a to see details.'));
+            if (checksToShow.length === 0 && !showAll) {
+                console.log(colors.green('  All checks passed! Use "all" to see details.'));
             }
             else {
                 for (const check of checksToShow) {
@@ -543,12 +679,15 @@ ${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')
-        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .argument('[args...]', 'Options: format=json')
         .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.green('$ rek robots example.com format=json')}    ${colors.gray('JSON output')}
+
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('format=json')}         Output as JSON
 
 ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Syntax')}              Valid robots.txt syntax
@@ -557,14 +696,14 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Crawl-delay')}         Aggressive crawl delay
   ${colors.cyan('AI Bots')}             GPTBot, ClaudeBot, Anthropic blocks
 `)
-        .action(async (url, options) => {
+        .action(async (url, args) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
         if (!url.includes('robots.txt')) {
             const urlObj = new URL(url);
             url = `${urlObj.origin}/robots.txt`;
         }
-        const isJson = options.format === 'json';
+        const isJson = args.some(a => a === 'format=json' || a === 'json');
         if (!isJson) {
             console.log(colors.gray(`Fetching robots.txt from ${url}...`));
         }
@@ -654,14 +793,17 @@ ${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')
-        .option('--format <format>', 'Output format: text (default) or json', 'text')
-        .option('--discover', 'Discover all sitemaps via robots.txt')
+        .argument('[args...]', 'Options: discover format=json')
         .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.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.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Structure')}      Valid XML sitemap format
@@ -670,12 +812,13 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('URLs')}           Valid, no duplicates, same domain
   ${colors.cyan('Lastmod')}        Valid dates, not in future
 `)
-        .action(async (url, options) => {
+        .action(async (url, args) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        const isJson = options.format === 'json';
+        const isJson = args.some(a => a === 'format=json' || a === 'json');
+        const doDiscover = args.includes('discover');
         try {
-            if (options.discover) {
+            if (doDiscover) {
                 const { discoverSitemaps } = await import('../seo/validators/sitemap.js');
                 if (!isJson) {
                     console.log(colors.gray(`Discovering sitemaps for ${new URL(url).origin}...`));
@@ -785,14 +928,17 @@ ${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')
-        .option('--format <format>', 'Output format: text (default) or json', 'text')
-        .option('--template', 'Generate a template llms.txt file')
+        .argument('[args...]', 'Options: template format=json')
         .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.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.bold(colors.yellow('About llms.txt:'))}
   A proposed standard for providing LLM-friendly content.
@@ -805,9 +951,10 @@ ${colors.bold(colors.yellow('Checks:'))}
   ${colors.cyan('Description')} Site description block
   ${colors.cyan('Sections')}     Content sections with links
 `)
-        .action(async (url, options) => {
-        const isJson = options.format === 'json';
-        if (options.template) {
+        .action(async (url, args) => {
+        const isJson = args.some(a => a === 'format=json' || a === 'json');
+        const isTemplate = args.includes('template') || url === 'template';
+        if (isTemplate) {
             const { generateLlmsTxtTemplate } = await import('../seo/validators/llms-txt.js');
             const template = generateLlmsTxtTemplate({
                 siteName: 'Your Site Name',
@@ -929,10 +1076,20 @@ ${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')
     });
     program
         .command('spider')
-        .description('Crawl a website following internal links')
+        .alias('crawl')
+        .description('Crawl a website and analyze all pages')
         .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')}
@@ -941,6 +1098,7 @@ ${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)
@@ -948,6 +1106,7 @@ ${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:'))}
@@ -964,6 +1123,7 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
         let concurrency = 5;
         let seoEnabled = false;
         let outputFile = '';
+        let formatJson = false;
         let focusMode = 'all';
         const focusCategories = {
             links: ['links'],
@@ -989,6 +1149,9 @@ ${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) {
@@ -1003,14 +1166,16 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
         }
         if (!url.startsWith('http'))
             url = `https://${url}`;
-        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}`));
+        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('');
         }
-        console.log('');
         try {
             if (seoEnabled) {
                 const { SeoSpider } = await import('../seo/index.js');
@@ -1024,11 +1189,91 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                     output: outputFile || undefined,
                     focusCategories: focusCategories[focusMode],
                     focusMode,
-                    onProgress: (progress) => {
+                    onProgress: formatJson ? undefined : (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}`);
@@ -1208,11 +1453,41 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                     concurrency,
                     sameDomain: true,
                     delay: 100,
-                    onProgress: (progress) => {
+                    onProgress: formatJson ? undefined : (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}`);
@@ -1277,10 +1552,19 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
     });
     program
         .command('scrape')
-        .description('Scrape data from a web page using CSS selectors')
+        .alias('extract')
+        .description('Extract data from web pages with 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')}
@@ -1478,20 +1762,32 @@ ${colors.bold('Images:')}      ${imageCount}
     });
     program
         .command('ai')
-        .description('Send a single AI prompt (no memory/context)')
+        .alias('chat')
+        .alias('ask')
+        .description('Chat with AI models (OpenAI, Claude, Groq, etc)')
         .argument('<preset>', 'AI preset to use (e.g., @openai, @anthropic, @groq)')
-        .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)')
+        .argument('<prompt...>', 'The prompt and options: "prompt text" model=<model> temperature=<temp> max-tokens=<tokens> wait json env=<path>')
         .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" -m claude-sonnet-4-20250514')}
-  ${colors.green('$ rek ai @groq "Write a haiku" --wait')}
+  ${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 @openai "Translate to Spanish: Hello world"')}
 
 ${colors.bold(colors.yellow('Available AI Presets:'))}
@@ -1513,14 +1809,39 @@ ${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, options) => {
-        if (options.env !== undefined) {
-            await loadEnvFile(options.env);
+        .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);
         }
         else {
             try {
-                const envPath = join(process.cwd(), '.env');
-                await fs.access(envPath);
+                const envFilePath = join(process.cwd(), '.env');
+                await fs.access(envFilePath);
                 await loadEnvFile(true);
             }
             catch {
@@ -1541,7 +1862,7 @@ ${colors.bold(colors.yellow('Note:'))}
             console.log(colors.gray('Use an AI preset like @openai, @anthropic, @groq, etc.'));
             process.exit(1);
         }
-        const prompt = promptParts.join(' ');
+        const prompt = actualPromptParts.join(' ');
         if (!prompt.trim()) {
             console.error(colors.red('Error: Prompt is required'));
             process.exit(1);
@@ -1549,16 +1870,16 @@ ${colors.bold(colors.yellow('Note:'))}
         try {
             const { createClient } = await import('../core/client.js');
             const client = createClient(presetConfig);
-            if (options.model) {
+            if (model) {
                 client.ai.setMemoryConfig({ systemPrompt: undefined });
-                client._aiConfig.model = options.model;
+                client._aiConfig.model = model;
             }
-            if (!options.json) {
+            if (!jsonOutput) {
                 console.log(colors.gray(`Using @${presetName} (${client._aiConfig.model})...\n`));
             }
-            if (options.wait || options.json) {
+            if (wait || jsonOutput) {
                 const response = await client.ai.prompt(prompt);
-                if (options.json) {
+                if (jsonOutput) {
                     console.log(JSON.stringify({
                         content: response.content,
                         model: response.model,
@@ -1594,8 +1915,36 @@ ${colors.bold(colors.yellow('Note:'))}
     });
     program
         .command('ip')
-        .description('Get IP address intelligence using local GeoLite2 database')
+        .alias('geo')
+        .alias('geoip')
+        .description('Look up geolocation and ISP info for an IP address')
         .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()) {
@@ -1634,9 +1983,34 @@ ${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}...`));
@@ -1704,15 +2078,43 @@ ${colors.bold('Fingerprints:')}
     });
     program
         .command('whois')
-        .description('WHOIS lookup for domains and IP addresses')
+        .description('Look up domain registration and ownership info')
         .argument('<query>', 'Domain name or IP address')
-        .option('-r, --raw', 'Show raw WHOIS response')
-        .action(async (query, options) => {
+        .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) => {
         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 (options.raw) {
+            if (raw) {
                 console.log(result.raw);
                 return;
             }
@@ -1747,8 +2149,33 @@ ${colors.bold('Server:')} ${result.server}
     });
     program
         .command('rdap')
-        .description('RDAP lookup (modern WHOIS replacement)')
+        .description('RDAP lookup (modern WHOIS with JSON)')
         .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');
@@ -1800,14 +2227,46 @@ ${colors.bold('Status:')} ${result.status?.join(', ') || 'N/A'}
     });
     program
         .command('ping')
-        .description('TCP connectivity check to a host')
+        .description('Test TCP connectivity to host:port')
         .argument('<host>', 'Hostname or IP address')
-        .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) => {
+        .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) => {
         const net = await import('node:net');
-        const count = parseInt(options.count);
-        const portNum = parseInt(port);
+        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 results = [];
         console.log(colors.gray(`Pinging ${host}:${portNum}...`));
         console.log('');
@@ -1857,20 +2316,48 @@ ${colors.bold('Statistics:')}
         .command('ls')
         .description('List files in a remote directory')
         .argument('<host>', 'FTP server hostname')
-        .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) => {
+        .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) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        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 client = createFTP({
             host,
-            port: parseInt(options.port),
-            user: options.user,
-            password: options.pass,
+            port,
+            user,
+            password: pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -1913,22 +2400,50 @@ ${colors.bold('Statistics:')}
         .description('Download a file from FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<remote>', 'Remote file path')
-        .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) => {
+        .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) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const path = await import('node:path');
-        const localPath = local || path.basename(remote);
-        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        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 client = createFTP({
             host,
-            port: parseInt(options.port),
-            user: options.user,
-            password: options.pass,
+            port,
+            user,
+            password: pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -1968,22 +2483,50 @@ ${colors.bold('Statistics:')}
         .description('Upload a file to FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<local>', 'Local file path')
-        .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) => {
+        .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) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const path = await import('node:path');
-        const remotePath = remote || '/' + path.basename(local);
-        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        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 client = createFTP({
             host,
-            port: parseInt(options.port),
-            user: options.user,
-            password: options.pass,
+            port,
+            user,
+            password: pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2023,19 +2566,44 @@ ${colors.bold('Statistics:')}
         .description('Delete a file from FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<path>', 'Remote file path to delete')
-        .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) => {
+        .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) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        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 client = createFTP({
             host,
-            port: parseInt(options.port),
-            user: options.user,
-            password: options.pass,
+            port,
+            user,
+            password: pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2066,19 +2634,44 @@ ${colors.bold('Statistics:')}
         .description('Create a directory on FTP server')
         .argument('<host>', 'FTP server hostname')
         .argument('<path>', 'Remote directory path to create')
-        .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) => {
+        .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) => {
         const { createFTP } = await import('../protocols/ftp.js');
-        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        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 client = createFTP({
             host,
-            port: parseInt(options.port),
-            user: options.user,
-            password: options.pass,
+            port,
+            user,
+            password: pass,
             secure,
         });
         console.log(colors.gray(`Connecting to ${host}...`));
@@ -2108,15 +2701,31 @@ ${colors.bold('Statistics:')}
         .command('telnet')
         .description('Connect to a Telnet server')
         .argument('<host>', 'Hostname or IP address')
-        .argument('[port]', 'Port number', '23')
-        .option('-t, --timeout <ms>', 'Connection timeout in ms', '30000')
-        .action(async (host, port, options) => {
+        .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) => {
         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: parseInt(port),
-            timeout: parseInt(options.timeout),
+            port,
+            timeout,
         });
         try {
             await client.connect();
@@ -2166,9 +2775,37 @@ ${colors.bold('Statistics:')}
     });
     dns
         .command('lookup')
-        .description('Perform DNS lookup for any record type')
+        .alias('resolve')
+        .description('Look up DNS records (A, MX, TXT, etc)')
         .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}...`));
@@ -2443,27 +3080,54 @@ ${colors.gray('Status:')} ${statusIcon}
     dns
         .command('generate-dmarc')
         .description('Generate a DMARC record interactively')
-        .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) => {
+        .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) => {
         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: options.policy,
+            policy,
         };
-        if (options.subdomainPolicy) {
-            dmarcOptions.subdomainPolicy = options.subdomainPolicy;
+        if (subdomainPolicy) {
+            dmarcOptions.subdomainPolicy = subdomainPolicy;
         }
-        if (options.pct && options.pct !== '100') {
-            dmarcOptions.percentage = parseInt(options.pct);
+        if (pct && pct !== '100') {
+            dmarcOptions.percentage = parseInt(pct);
         }
-        if (options.rua) {
-            dmarcOptions.aggregateReports = options.rua.split(',').map((e) => e.trim());
+        if (rua) {
+            dmarcOptions.aggregateReports = rua.split(',').map((e) => e.trim());
         }
-        if (options.ruf) {
-            dmarcOptions.forensicReports = options.ruf.split(',').map((e) => e.trim());
+        if (ruf) {
+            dmarcOptions.forensicReports = ruf.split(',').map((e) => e.trim());
         }
         const record = generateDmarc(dmarcOptions);
         console.log(`
@@ -2545,22 +3209,68 @@ ${colors.bold(colors.yellow('Record Types:'))}
     });
     program
         .command('graphql')
-        .description('Execute a GraphQL query')
+        .alias('gql')
+        .description('Execute GraphQL queries and mutations')
         .argument('<url>', 'GraphQL endpoint URL')
-        .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) => {
+        .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) => {
         const { graphql } = await import('../plugins/graphql.js');
         const { createClient } = await import('../core/client.js');
         const fs = await import('node:fs/promises');
-        let query = options.query;
+        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 variables = {};
-        if (options.file) {
+        if (queryFile) {
             try {
-                query = await fs.readFile(options.file, 'utf-8');
+                query = await fs.readFile(queryFile, 'utf-8');
             }
             catch (err) {
                 console.error(colors.red(`Failed to read query file: ${err.message}`));
@@ -2568,22 +3278,22 @@ ${colors.bold(colors.yellow('Record Types:'))}
             }
         }
         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 -q "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 query="query { users { id name } }"'));
             process.exit(1);
         }
-        if (options.variables) {
+        if (variablesStr) {
             try {
-                variables = JSON.parse(options.variables);
+                variables = JSON.parse(variablesStr);
             }
             catch {
-                console.error(colors.red('Invalid JSON in --variables'));
+                console.error(colors.red('Invalid JSON in variables='));
                 process.exit(1);
             }
         }
-        else if (options.varFile) {
+        else if (varFile) {
             try {
-                const content = await fs.readFile(options.varFile, 'utf-8');
+                const content = await fs.readFile(varFile, 'utf-8');
                 variables = JSON.parse(content);
             }
             catch (err) {
@@ -2594,7 +3304,7 @@ ${colors.bold(colors.yellow('Record Types:'))}
         const headers = {
             'Content-Type': 'application/json',
         };
-        for (const h of options.header) {
+        for (const h of headerArgs) {
             const [key, ...valueParts] = h.split(':');
             headers[key.trim()] = valueParts.join(':').trim();
         }
@@ -2758,21 +3468,48 @@ ${colors.bold(colors.yellow('Record Types:'))}
         .command('download')
         .description('Download an HLS stream')
         .argument('<url>', 'HLS playlist URL')
-        .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) => {
+        .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) => {
         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: parseInt(options.concurrency),
+                concurrency,
                 onProgress: (p) => {
                     const segs = p.totalSegments
                         ? `${p.downloadedSegments}/${p.totalSegments}`
@@ -2781,17 +3518,17 @@ ${colors.bold(colors.yellow('Record Types:'))}
                     process.stdout.write(`\r  ${colors.cyan(segs)} segments | ${colors.cyan(mb + ' MB')} downloaded`);
                 },
             };
-            if (options.quality) {
-                if (options.quality === 'highest' || options.quality === 'lowest') {
-                    hlsOptions.quality = options.quality;
+            if (quality) {
+                if (quality === 'highest' || quality === 'lowest') {
+                    hlsOptions.quality = quality;
                 }
-                else if (options.quality.includes('p')) {
-                    hlsOptions.quality = { resolution: options.quality };
+                else if (quality.includes('p')) {
+                    hlsOptions.quality = { resolution: quality };
                 }
             }
-            if (options.live) {
-                hlsOptions.live = options.duration
-                    ? { duration: parseInt(options.duration) * 1000 }
+            if (live) {
+                hlsOptions.live = duration
+                    ? { duration: duration * 1000 }
                     : true;
             }
             await hls(client, url, hlsOptions).download(output);
@@ -2964,19 +3701,23 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('info')
         .description('Show information about a HAR file')
         .argument('<file>', 'HAR file to inspect')
-        .option('--json', 'Output as JSON')
+        .argument('[args...]', 'Options: 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, options) => {
+        .action(async (file, args) => {
         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 (options.json) {
+            if (jsonOutput) {
                 const info = {
                     version: har.log?.version,
                     creator: har.log?.creator,
@@ -3103,28 +3844,66 @@ ${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')
-        .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)
+        .description('Start a mock HTTP server for testing')
+        .argument('[args...]', 'Options: port=3000 host=127.0.0.1 echo delay=0 cors')
         .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')}                    ${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')}
+  ${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
 `)
-        .action(async (options) => {
+        .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;
+        }
         const { MockHttpServer } = await import('../testing/mock-http-server.js');
         const server = await MockHttpServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            delay: parseInt(options.delay),
-            cors: options.cors,
+            port,
+            host,
+            delay,
+            cors,
         });
-        if (options.echo) {
+        if (echo) {
             server.any('/*', (req) => ({
                 status: 200,
                 body: {
@@ -3141,8 +3920,8 @@ ${colors.bold(colors.yellow('Examples:'))}
 │  ${colors.bold('Recker Mock HTTP Server')}                   │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Mode: ${colors.yellow((options.echo ? 'Echo' : 'Default').padEnd(36))}│
-│  Delay: ${colors.gray((options.delay + 'ms').padEnd(35))}│
+│  Mode: ${colors.yellow((echo ? 'Echo' : 'Default').padEnd(36))}│
+│  Delay: ${colors.gray((delay + 'ms').padEnd(35))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -3160,15 +3939,18 @@ ${colors.bold(colors.yellow('Examples:'))}
         .command('webhook')
         .alias('wh')
         .description('Start a webhook receiver server')
-        .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)
+        .argument('[args...]', 'Options: port=3000 host=127.0.0.1 status=204 quiet')
         .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 -p 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 port=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')}
@@ -3177,18 +3959,32 @@ ${colors.bold(colors.yellow('Endpoints:'))}
 ${colors.bold(colors.yellow('Methods:'))}
   ${colors.gray('GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS')}
 `)
-        .action(async (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;
+        }
         const { createWebhookServer } = await import('../testing/mock-http-server.js');
-        const status = parseInt(options.status);
+        const status = statusCode;
         if (status !== 200 && status !== 204) {
             console.error(colors.red('Status must be 200 or 204'));
             process.exit(1);
         }
         const server = await createWebhookServer({
-            port: parseInt(options.port),
-            host: options.host,
+            port,
+            host,
             status,
-            log: !options.quiet,
+            log: !quiet,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
@@ -3214,32 +4010,51 @@ ${colors.bold(colors.yellow('Methods:'))}
         .command('websocket')
         .alias('ws')
         .description('Start a mock WebSocket server')
-        .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')
+        .argument('[args...]', 'Options: port=8080 host=127.0.0.1 echo noecho delay=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 -p 9000')}              ${colors.gray('Start on port 9000')}
-  ${colors.green('$ rek serve ws --no-echo')}            ${colors.gray('Disable echo')}
+  ${colors.green('$ rek serve ws port=9000')}            ${colors.gray('Start on port 9000')}
+  ${colors.green('$ rek serve ws noecho')}               ${colors.gray('Disable echo')}
 `)
-        .action(async (options) => {
+        .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]);
+        }
         const { MockWebSocketServer } = await import('../testing/mock-websocket-server.js');
         const server = await MockWebSocketServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            echo: options.echo,
-            delay: parseInt(options.delay),
+            port,
+            host,
+            echo,
+            delay,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock WebSocket Server')}              │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
-│  Delay: ${colors.gray((options.delay + 'ms').padEnd(35))}│
+│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Delay: ${colors.gray((delay + 'ms').padEnd(35))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -3263,36 +4078,53 @@ ${colors.bold(colors.yellow('Examples:'))}
     serve
         .command('sse')
         .description('Start a mock SSE (Server-Sent Events) server')
-        .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')
+        .argument('[args...]', 'Options: port=8081 host=127.0.0.1 path=/events heartbeat=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 -p 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 port=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 (options) => {
+        .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]);
+        }
         const { MockSSEServer } = await import('../testing/mock-sse-server.js');
         const readline = await import('node:readline');
         const server = await MockSSEServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            path: options.path,
+            port,
+            host,
+            path,
         });
-        if (parseInt(options.heartbeat) > 0) {
-            server.startPeriodicEvents('heartbeat', parseInt(options.heartbeat));
+        if (heartbeat > 0) {
+            server.startPeriodicEvents('heartbeat', heartbeat);
         }
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock SSE Server')}                    │
 ├─────────────────────────────────────────────┤
 │  URL: ${colors.cyan(server.url.padEnd(37))}│
-│  Heartbeat: ${colors.yellow((options.heartbeat === '0' ? 'Disabled' : options.heartbeat + 'ms').padEnd(31))}│
+│  Heartbeat: ${colors.yellow((heartbeat === 0 ? 'Disabled' : heartbeat + 'ms').padEnd(31))}│
 ├─────────────────────────────────────────────┤
 │  Type message + Enter to broadcast          │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
@@ -3324,30 +4156,51 @@ ${colors.bold(colors.yellow('Interactive Commands:'))}
     serve
         .command('hls')
         .description('Start a mock HLS streaming server')
-        .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')
+        .argument('[args...]', 'Options: port=8082 host=127.0.0.1 mode=vod segments=10 duration=6 qualities=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 (options) => {
+        .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];
+        }
         const { MockHlsServer } = await import('../testing/mock-hls-server.js');
         const http = await import('node:http');
-        const port = parseInt(options.port);
-        const host = options.host;
-        const qualities = options.qualities.split(',').map(q => q.trim());
+        const qualities = qualitiesStr.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) => ({
@@ -3358,9 +4211,9 @@ ${colors.bold(colors.yellow('Endpoints:'))}
         const baseUrl = `http://${host}:${port}`;
         const hlsServer = await MockHlsServer.create({
             baseUrl,
-            mode: options.mode,
-            segmentCount: parseInt(options.segments),
-            segmentDuration: parseInt(options.duration),
+            mode: mode,
+            segmentCount: segments,
+            segmentDuration: duration,
             multiQuality: variants.length > 1,
             variants: variants.length > 1 ? variants : undefined,
         });
@@ -3386,9 +4239,9 @@ ${colors.bold(colors.yellow('Endpoints:'))}
 │  ${colors.bold('Recker Mock HLS Server')}                    │
 ├─────────────────────────────────────────────┤
 │  Master: ${colors.cyan((hlsServer.manifestUrl).padEnd(34))}│
-│  Mode: ${colors.yellow(options.mode.padEnd(36))}│
-│  Segments: ${colors.gray(options.segments.padEnd(32))}│
-│  Duration: ${colors.gray((options.duration + 's').padEnd(32))}│
+│  Mode: ${colors.yellow(mode.padEnd(36))}│
+│  Segments: ${colors.gray(String(segments).padEnd(32))}│
+│  Duration: ${colors.gray((duration + 's').padEnd(32))}│
 │  Qualities: ${colors.cyan(qualities.join(', ').padEnd(31))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
@@ -3405,30 +4258,46 @@ ${colors.bold(colors.yellow('Endpoints:'))}
     serve
         .command('udp')
         .description('Start a mock UDP server')
-        .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')
+        .argument('[args...]', 'Options: port=9000 host=127.0.0.1 echo noecho')
         .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 -p 5353')}             ${colors.gray('Start on port 5353')}
-  ${colors.green('$ rek serve udp --no-echo')}           ${colors.gray('Disable echo')}
+  ${colors.green('$ rek serve udp port=5353')}           ${colors.gray('Start on port 5353')}
+  ${colors.green('$ rek serve udp noecho')}              ${colors.gray('Disable echo')}
 `)
-        .action(async (options) => {
+        .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;
+        }
         const { MockUDPServer } = await import('../testing/mock-udp-server.js');
         const server = new MockUDPServer({
-            port: parseInt(options.port),
-            host: options.host,
-            echo: options.echo,
+            port,
+            host,
+            echo,
         });
         await server.start();
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock UDP Server')}                    │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
-│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
+│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
 ├─────────────────────────────────────────────┤
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
@@ -3446,13 +4315,16 @@ ${colors.bold(colors.yellow('Examples:'))}
     serve
         .command('dns')
         .description('Start a mock DNS server')
-        .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')
+        .argument('[args...]', 'Options: port=5353 host=127.0.0.1 delay=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 -p 53')}               ${colors.gray('Start on standard port (requires root)')}
+  ${colors.green('$ rek serve dns port=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:'))}
@@ -3460,21 +4332,32 @@ ${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 (options) => {
+        .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]);
+        }
         const { MockDnsServer } = await import('../testing/mock-dns-server.js');
         const server = await MockDnsServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            delay: parseInt(options.delay),
+            port,
+            host,
+            delay,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock DNS Server')}                    │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
+│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
 │  Protocol: ${colors.yellow('UDP'.padEnd(32))}│
 ├─────────────────────────────────────────────┤
-│  Test: dig @${options.host} -p ${options.port} example.com        │
+│  Test: dig @${host} -p ${port} example.com        │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -3490,10 +4373,13 @@ ${colors.bold(colors.yellow('Default Records:'))}
     serve
         .command('whois')
         .description('Start a mock WHOIS server')
-        .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')
+        .argument('[args...]', 'Options: port=4343 host=127.0.0.1 delay=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')}
@@ -3503,21 +4389,32 @@ ${colors.bold(colors.yellow('Default Domains:'))}
   ${colors.cyan('google.com')}     MarkMonitor registrar
   ${colors.cyan('test.local')}     Test domain
 `)
-        .action(async (options) => {
+        .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]);
+        }
         const { MockWhoisServer } = await import('../testing/mock-whois-server.js');
         const server = await MockWhoisServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            delay: parseInt(options.delay),
+            port,
+            host,
+            delay,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock WHOIS Server')}                  │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
+│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
 │  Protocol: ${colors.yellow('TCP'.padEnd(32))}│
 ├─────────────────────────────────────────────┤
-│  Test: whois -h ${options.host} -p ${options.port} example.com │
+│  Test: whois -h ${host} -p ${port} example.com │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -3533,12 +4430,15 @@ ${colors.bold(colors.yellow('Default Domains:'))}
     serve
         .command('telnet')
         .description('Start a mock Telnet server')
-        .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')
+        .argument('[args...]', 'Options: port=2323 host=127.0.0.1 echo noecho delay=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')}
@@ -3551,22 +4451,38 @@ ${colors.bold(colors.yellow('Built-in Commands:'))}
   ${colors.cyan('ping')}        Returns "pong"
   ${colors.cyan('quit')}        Disconnect
 `)
-        .action(async (options) => {
+        .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]);
+        }
         const { MockTelnetServer } = await import('../testing/mock-telnet-server.js');
         const server = await MockTelnetServer.create({
-            port: parseInt(options.port),
-            host: options.host,
-            echo: options.echo,
-            delay: parseInt(options.delay),
+            port,
+            host,
+            echo,
+            delay,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock Telnet Server')}                 │
 ├─────────────────────────────────────────────┤
-│  Address: ${colors.cyan(`${options.host}:${options.port}`.padEnd(33))}│
-│  Echo: ${colors.yellow((options.echo ? 'Enabled' : 'Disabled').padEnd(36))}│
+│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
+│  Echo: ${colors.yellow((echo ? 'Enabled' : 'Disabled').padEnd(36))}│
 ├─────────────────────────────────────────────┤
-│  Connect: telnet ${options.host} ${options.port}               │
+│  Connect: telnet ${host} ${port}               │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -3588,18 +4504,21 @@ ${colors.bold(colors.yellow('Built-in Commands:'))}
     serve
         .command('ftp')
         .description('Start a mock FTP server')
-        .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')
+        .argument('[args...]', 'Options: port=2121 host=127.0.0.1 username=user password=pass anonymous noanonymous delay=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 --no-anonymous')}       ${colors.gray('Require authentication')}
+  ${colors.green('$ rek serve ftp noanonymous')}          ${colors.gray('Require authentication')}
 
 ${colors.bold(colors.yellow('Default Files:'))}
   ${colors.cyan('/welcome.txt')}        Welcome message
@@ -3611,25 +4530,47 @@ ${colors.bold(colors.yellow('Credentials:'))}
   Username: ${colors.cyan('user')}  Password: ${colors.cyan('pass')}
   Or use anonymous login with user: ${colors.cyan('anonymous')}
 `)
-        .action(async (options) => {
+        .action(async (args) => {
         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: parseInt(options.port),
-            host: options.host,
-            username: options.username,
-            password: options.password,
-            anonymous: options.anonymous,
-            delay: parseInt(options.delay),
+            port,
+            host,
+            username,
+            password,
+            anonymous,
+            delay,
         });
         console.log(colors.green(`
 ┌─────────────────────────────────────────────┐
 │  ${colors.bold('Recker Mock FTP Server')}                    │
 ├─────────────────────────────────────────────┤
-│  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))}│
+│  Address: ${colors.cyan(`${host}:${port}`.padEnd(33))}│
+│  Anonymous: ${colors.yellow((anonymous ? 'Allowed' : 'Disabled').padEnd(31))}│
+│  User: ${colors.cyan(username.padEnd(36))}│
 ├─────────────────────────────────────────────┤
-│  Connect: ftp ${options.host} ${options.port}                  │
+│  Connect: ftp ${host} ${port}                  │
 │  Press ${colors.bold('Ctrl+C')} to stop                       │
 └─────────────────────────────────────────────┘
 `));
@@ -3651,22 +4592,25 @@ ${colors.bold(colors.yellow('Credentials:'))}
     program
         .command('mcp')
         .description('Start MCP server for AI agents to access Recker documentation')
-        .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')
+        .argument('[args...]', 'Options: transport=stdio port=3100 docs=<path> tools=<paths> debug')
         .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('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('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('Tools provided:'))}
   ${colors.cyan('search_docs')}  Search documentation by keyword
@@ -3682,15 +4626,31 @@ ${colors.bold(colors.yellow('Claude Code config (~/.claude.json):'))}
     }
   }`)}
 `)
-        .action(async (options) => {
+        .action(async (args) => {
         const { MCPServer } = await import('../mcp/server.js');
-        const transport = options.transport;
+        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 server = new MCPServer({
             transport,
-            port: parseInt(options.port),
-            docsPath: options.docs,
-            debug: options.debug,
-            toolPaths: options.tools,
+            port,
+            docsPath,
+            debug,
+            toolPaths,
         });
         if (transport === 'stdio') {
             await server.start();
@@ -3709,7 +4669,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:${options.port}`.padEnd(32))}│
+│  Endpoint: ${colors.cyan(`http://localhost:${port}`.padEnd(32))}│
 │  Docs indexed: ${colors.yellow(String(server.getDocsCount()).padEnd(28))}│
 ├─────────────────────────────────────────────┤${endpoints}
 ├─────────────────────────────────────────────┤
@@ -4385,21 +5345,39 @@ ${colors.bold(colors.yellow('Examples:'))}
     });
     program
         .command('proxy')
-        .description('Make a request through a proxy')
+        .description('Route requests through HTTP or SOCKS 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.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.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('Examples:'))}
-  ${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')}
+  ${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')}
 `)
         .action(async (proxy, url, args) => {
         const { createClient } = await import('../core/client.js');
@@ -4458,6 +5436,13 @@ ${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) => {