recker 1.0.29 → 1.0.30

package/dist/browser/types/ai-client.d.ts

@@ -0,0 +1,32 @@
+import type { AIResponse, AIStream, ChatMessage, AIProvider } from './ai.js';
+export interface AIMemoryConfig {
+    maxPairs?: number;
+    systemPrompt?: string;
+}
+export interface PresetAIConfig {
+    provider: AIProvider;
+    apiKey?: string;
+    model: string;
+    baseUrl?: string;
+    memory?: AIMemoryConfig;
+    organization?: string;
+    headers?: Record<string, string>;
+    resourceName?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+}
+export interface ClientAI {
+    chat(prompt: string): Promise<AIResponse>;
+    chatStream(prompt: string): Promise<AIStream>;
+    prompt(prompt: string): Promise<AIResponse>;
+    promptStream(prompt: string): Promise<AIStream>;
+    clearMemory(): void;
+    getMemory(): readonly ChatMessage[];
+    setMemoryConfig(config: Partial<AIMemoryConfig>): void;
+    getMemoryConfig(): AIMemoryConfig;
+    readonly provider: AIProvider;
+    readonly model: string;
+}
+export interface ClientOptionsWithAI {
+    _aiConfig?: PresetAIConfig;
+}

package/dist/browser/types/ai-client.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/types/ai.d.ts

@@ -1,4 +1,4 @@
-export type AIProvider = 'openai' | 'anthropic' | 'google' | 'replicate' | 'huggingface' | 'ollama' | 'custom';
+export type AIProvider = 'openai' | 'anthropic' | 'google' | 'replicate' | 'huggingface' | 'ollama' | 'groq' | 'mistral' | 'cohere' | 'together' | 'perplexity' | 'deepseek' | 'fireworks' | 'xai' | 'azure-openai' | 'cloudflare-workers-ai' | 'custom';
 export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
 export interface ChatMessage {
     role: MessageRole;

package/dist/cli/index.js

@@ -330,7 +330,17 @@ complete -F _rek_completions rek
         .alias('interactive')
         .alias('repl')
         .description('Start the interactive Rek Shell')
-        .action(async () => {
+        .option('-e, --env [path]', 'Load .env file (auto-loads from cwd by default)')
+        .action(async (options) => {
+        if (options.env !== false) {
+            try {
+                const envPath = typeof options.env === 'string' ? options.env : join(process.cwd(), '.env');
+                await fs.access(envPath);
+                await loadEnvFile(options.env);
+            }
+            catch {
+            }
+        }
         const { RekShell } = await import('./tui/shell.js');
         const shell = new RekShell();
         shell.start();
@@ -520,6 +530,256 @@ ${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray
             process.exit(1);
         }
     });
+    program
+        .command('spider')
+        .description('Crawl a website following internal links')
+        .argument('<url>', 'Starting URL to crawl')
+        .option('-d, --depth <n>', 'Maximum depth to crawl', '5')
+        .option('-l, --limit <n>', 'Maximum pages to crawl', '100')
+        .option('-c, --concurrency <n>', 'Concurrent requests', '5')
+        .option('--delay <ms>', 'Delay between requests in ms', '100')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .option('-o, --output <file>', 'Write JSON results to file')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek spider example.com')}                    ${colors.gray('Crawl with defaults')}
+  ${colors.green('$ rek spider example.com -d 3 -l 50')}         ${colors.gray('Depth 3, max 50 pages')}
+  ${colors.green('$ rek spider example.com --format json')}      ${colors.gray('Output as JSON')}
+  ${colors.green('$ rek spider example.com -o results.json')}    ${colors.gray('Save to file')}
+
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('--depth, -d')}       Max link depth to follow (default: 5)
+  ${colors.cyan('--limit, -l')}       Max pages to crawl (default: 100)
+  ${colors.cyan('--concurrency, -c')} Parallel requests (default: 5)
+  ${colors.cyan('--delay')}           Ms between requests (default: 100)
+`)
+        .action(async (url, options) => {
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const isJson = options.format === 'json';
+        const maxDepth = parseInt(options.depth || '5', 10);
+        const maxPages = parseInt(options.limit || '100', 10);
+        const concurrency = parseInt(options.concurrency || '5', 10);
+        const delay = parseInt(options.delay || '100', 10);
+        const { Spider } = await import('../scrape/spider.js');
+        if (!isJson) {
+            console.log(colors.gray(`\nCrawling ${url}...`));
+            console.log(colors.gray(`  Depth: ${maxDepth}, Limit: ${maxPages}, Concurrency: ${concurrency}\n`));
+        }
+        try {
+            const startTime = performance.now();
+            const spider = new Spider({
+                maxDepth,
+                maxPages,
+                concurrency,
+                delay,
+                onProgress: (progress) => {
+                    if (!isJson) {
+                        process.stdout.write(`\r${colors.cyan('⟳')} Crawled: ${colors.bold(String(progress.crawled))} | Queued: ${progress.queued} | Current: ${colors.gray(progress.currentUrl.slice(0, 50))}...`);
+                    }
+                },
+            });
+            const result = await spider.crawl(url);
+            const duration = Math.round(performance.now() - startTime);
+            if (!isJson) {
+                process.stdout.write('\r' + ' '.repeat(100) + '\r');
+            }
+            if (isJson || options.output) {
+                const jsonOutput = {
+                    startUrl: result.startUrl,
+                    crawledAt: new Date().toISOString(),
+                    duration,
+                    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,
+                };
+                if (options.output) {
+                    await fs.writeFile(options.output, JSON.stringify(jsonOutput, null, 2));
+                    console.log(colors.green(`✓ Results saved to ${options.output}`));
+                }
+                if (isJson) {
+                    console.log(JSON.stringify(jsonOutput, null, 2));
+                    return;
+                }
+            }
+            console.log(`${colors.bold(colors.cyan('🕷️ Spider Crawl Complete'))}`);
+            console.log(`${colors.gray('URL:')} ${url}`);
+            console.log(`${colors.gray('Duration:')} ${(duration / 1000).toFixed(1)}s`);
+            console.log('');
+            const successCount = result.pages.filter(p => !p.error).length;
+            console.log(`${colors.bold('Summary:')}`);
+            console.log(`  ${colors.green('✓')} Pages crawled: ${colors.bold(String(successCount))}`);
+            console.log(`  ${colors.red('✗')} Errors: ${colors.bold(String(result.errors.length))}`);
+            console.log(`  ${colors.gray('○')} Unique URLs: ${result.visited.size}`);
+            console.log('');
+            const byDepth = new Map();
+            for (const page of result.pages) {
+                byDepth.set(page.depth, (byDepth.get(page.depth) || 0) + 1);
+            }
+            console.log(`${colors.bold('Pages by Depth:')}`);
+            for (const [depth, count] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
+                console.log(`  ${colors.gray(`Depth ${depth}:`)} ${count} pages`);
+            }
+            console.log('');
+            if (result.errors.length > 0) {
+                console.log(`${colors.bold(colors.red('Errors:'))}`);
+                for (const err of result.errors.slice(0, 10)) {
+                    const shortUrl = err.url.replace(url, '');
+                    const statusMatch = err.error.match(/status code (\d+)/);
+                    const errorMsg = statusMatch ? `HTTP ${statusMatch[1]}` : err.error.slice(0, 50);
+                    console.log(`  ${colors.red('✗')} ${colors.gray(shortUrl || '/')} → ${errorMsg}`);
+                }
+                if (result.errors.length > 10) {
+                    console.log(`  ${colors.gray(`  ... and ${result.errors.length - 10} more`)}`);
+                }
+                console.log('');
+            }
+            const successPages = result.pages.filter(p => !p.error).slice(0, 10);
+            if (successPages.length > 0) {
+                console.log(`${colors.bold('Sample Pages:')}`);
+                for (const page of successPages) {
+                    const shortUrl = page.url.replace(url, '');
+                    console.log(`  ${colors.green('✓')} ${colors.gray((shortUrl || '/').padEnd(40))} ${page.title.slice(0, 40)}`);
+                }
+                if (result.pages.length > 10) {
+                    console.log(`  ${colors.gray(`  ... and ${result.pages.length - 10} more`)}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`\nSpider failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('ai')
+        .description('Send a single AI prompt (no memory/context)')
+        .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)')
+        .addHelpText('after', `
+${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 @openai "Translate to Spanish: Hello world"')}
+
+${colors.bold(colors.yellow('Available AI Presets:'))}
+  ${colors.cyan('@openai')}       OpenAI (GPT-4o, GPT-5.1)
+  ${colors.cyan('@anthropic')}    Anthropic (Claude)
+  ${colors.cyan('@groq')}         Groq (fast inference)
+  ${colors.cyan('@google')}       Google (Gemini)
+  ${colors.cyan('@xai')}          xAI (Grok)
+  ${colors.cyan('@mistral')}      Mistral AI
+  ${colors.cyan('@cohere')}       Cohere
+  ${colors.cyan('@deepseek')}     DeepSeek
+  ${colors.cyan('@perplexity')}   Perplexity
+  ${colors.cyan('@together')}     Together AI
+  ${colors.cyan('@fireworks')}    Fireworks AI
+  ${colors.cyan('@replicate')}    Replicate
+  ${colors.cyan('@huggingface')}  Hugging Face
+
+${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);
+        }
+        else {
+            try {
+                const envPath = join(process.cwd(), '.env');
+                await fs.access(envPath);
+                await loadEnvFile(true);
+            }
+            catch {
+            }
+        }
+        let presetName = preset;
+        if (presetName.startsWith('@')) {
+            presetName = presetName.slice(1);
+        }
+        const presetConfig = resolvePreset(presetName);
+        if (!presetConfig) {
+            console.error(colors.red(`Unknown AI preset: @${presetName}`));
+            console.log(colors.gray('Available AI presets: @openai, @anthropic, @groq, @google, @xai, @mistral, @cohere'));
+            process.exit(1);
+        }
+        if (!presetConfig._aiConfig) {
+            console.error(colors.red(`Preset @${presetName} does not support AI features.`));
+            console.log(colors.gray('Use an AI preset like @openai, @anthropic, @groq, etc.'));
+            process.exit(1);
+        }
+        const prompt = promptParts.join(' ');
+        if (!prompt.trim()) {
+            console.error(colors.red('Error: Prompt is required'));
+            process.exit(1);
+        }
+        try {
+            const { createClient } = await import('../core/client.js');
+            const client = createClient(presetConfig);
+            if (options.model) {
+                client.ai.setMemoryConfig({ systemPrompt: undefined });
+                client._aiConfig.model = options.model;
+            }
+            if (!options.json) {
+                console.log(colors.gray(`Using @${presetName} (${client._aiConfig.model})...\n`));
+            }
+            if (options.wait || options.json) {
+                const response = await client.ai.prompt(prompt);
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        content: response.content,
+                        model: response.model,
+                        usage: response.usage,
+                        finishReason: response.finishReason,
+                    }, null, 2));
+                }
+                else {
+                    console.log(response.content);
+                    if (response.usage) {
+                        console.log(colors.gray(`\n─────────────────────────────────────────`));
+                        console.log(colors.gray(`Tokens: ${response.usage.inputTokens} in / ${response.usage.outputTokens} out`));
+                    }
+                }
+            }
+            else {
+                const stream = await client.ai.promptStream(prompt);
+                for await (const event of stream) {
+                    if (event.type === 'text') {
+                        process.stdout.write(event.content);
+                    }
+                }
+                console.log('');
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`AI request failed: ${error.message}`));
+            if (error.cause) {
+                console.error(colors.gray(error.cause.message || error.cause));
+            }
+            process.exit(1);
+        }
+    });
     program
         .command('ip')
         .description('Get IP address intelligence using local GeoLite2 database')

package/dist/cli/tui/scroll-buffer.js

@@ -119,17 +119,17 @@ export class ScrollBuffer extends EventEmitter {
 }
 export function parseScrollKey(data) {
     const str = data.toString();
-    if (str === '\x1b[5~' || str === '\x1bOy')
+    if (str === '\x1b[5~' || str === '\x1bOy' || str === '\x1b[5;5~' || str === '\x1b[5;2~')
         return 'pageUp';
-    if (str === '\x1b[6~' || str === '\x1bOs')
+    if (str === '\x1b[6~' || str === '\x1bOs' || str === '\x1b[6;5~' || str === '\x1b[6;2~')
         return 'pageDown';
     if (str === '\x1b[1;2A')
         return 'scrollUp';
     if (str === '\x1b[1;2B')
         return 'scrollDown';
-    if (str === '\x1b[H' || str === '\x1b[1~' || str === '\x1bOH')
+    if (str === '\x1b[H' || str === '\x1b[1~' || str === '\x1bOH' || str === '\x1b[7~')
         return 'home';
-    if (str === '\x1b[F' || str === '\x1b[4~' || str === '\x1bOF')
+    if (str === '\x1b[F' || str === '\x1b[4~' || str === '\x1bOF' || str === '\x1b[8~')
         return 'end';
     if (str === 'q' || str === 'Q')
         return 'quit';

package/dist/cli/tui/shell.d.ts

@@ -13,6 +13,7 @@ export declare class RekShell {
     private scrollBuffer;
     private originalStdoutWrite;
     private inScrollMode;
+    private aiClients;
     constructor();
     private ensureInitialized;
     private getPrompt;
@@ -31,6 +32,8 @@ export declare class RekShell {
     private handleCommand;
     private runInteractiveMode;
     private runAIChat;
+    private runAIPresetChat;
+    private clearAIMemory;
     private runLoadTest;
     private parseLine;
     private setBaseUrl;

package/dist/cli/tui/shell.js

@@ -16,6 +16,7 @@ import { getShellSearch } from './shell-search.js';
 import { openSearchPanel } from './search-panel.js';
 import { ScrollBuffer, parseScrollKey, parseMouseScroll, disableMouseReporting } from './scroll-buffer.js';
 import { analyzeSeo, SeoSpider } from '../../seo/index.js';
+import { resolvePreset } from '../presets.js';
 let highlight;
 async function initDependencies() {
     if (!highlight) {
@@ -43,6 +44,7 @@ export class RekShell {
     scrollBuffer;
     originalStdoutWrite = null;
     inScrollMode = false;
+    aiClients = new Map();
     constructor() {
         this.client = createClient({
             baseUrl: 'http://localhost',
@@ -94,8 +96,10 @@ export class RekShell {
         const commands = [
             'get', 'post', 'put', 'delete', 'patch', 'head', 'options',
             'ws', 'udp', 'load', 'chat', 'ai',
+            '@openai', '@anthropic', '@groq', '@google', '@xai', '@mistral', '@cohere', '@deepseek', '@fireworks', '@together', '@perplexity',
+            'ai:clear',
             'whois', 'tls', 'ssl', 'security', 'ip', 'dns', 'dns:propagate', 'dns:email', 'rdap', 'ping',
-            'scrap', 'spider', '$', '$text', '$attr', '$html', '$links', '$images', '$scripts', '$css', '$sourcemaps', '$unmap', '$unmap:view', '$unmap:save', '$beautify', '$beautify:save', '$table',
+            'scrap', 'spider', 'seo', '$', '$text', '$attr', '$html', '$links', '$images', '$scripts', '$css', '$sourcemaps', '$unmap', '$unmap:view', '$unmap:save', '$beautify', '$beautify:save', '$table',
             '?', 'search', 'suggest', 'example',
             'help', 'clear', 'exit', 'set', 'url', 'vars', 'env'
         ];
@@ -173,20 +177,36 @@ export class RekShell {
                         }
                         return true;
                     }
-                    const scrollKey = parseScrollKey(data);
-                    if (scrollKey) {
-                        if (scrollKey === 'quit') {
-                            if (self.inScrollMode) {
+                    try {
+                        const scrollKey = parseScrollKey(data);
+                        if (scrollKey) {
+                            if (scrollKey === 'quit') {
+                                if (self.inScrollMode) {
+                                    self.exitScrollMode();
+                                    return true;
+                                }
+                                return originalEmit(event, ...args);
+                            }
+                            self.handleScrollKey(scrollKey);
+                            return true;
+                        }
+                        if (self.inScrollMode) {
+                            if (str === '\x1b[A') {
+                                self.handleScrollKey('scrollUp');
+                                return true;
+                            }
+                            if (str === '\x1b[B') {
+                                self.handleScrollKey('scrollDown');
+                                return true;
+                            }
+                            if (str === '\x1b' || str === '\x1b\x1b') {
                                 self.exitScrollMode();
                                 return true;
                             }
-                            return originalEmit(event, ...args);
+                            return true;
                         }
-                        self.handleScrollKey(scrollKey);
-                        return true;
                     }
-                    if (self.inScrollMode) {
-                        return true;
+                    catch {
                     }
                 }
                 return originalEmit(event, ...args);
@@ -194,6 +214,9 @@ export class RekShell {
         }
     }
     handleScrollKey(key) {
+        if (!this.originalStdoutWrite) {
+            return;
+        }
         let needsRedraw = false;
         switch (key) {
             case 'pageUp':
@@ -250,11 +273,15 @@ export class RekShell {
     enterScrollMode() {
         if (this.inScrollMode)
             return;
+        if (!this.originalStdoutWrite)
+            return;
         this.inScrollMode = true;
-        this.rl.pause();
-        if (this.originalStdoutWrite) {
-            this.originalStdoutWrite('\x1b[?25l');
+        try {
+            this.rl.pause();
+        }
+        catch {
         }
+        this.originalStdoutWrite('\x1b[?25l');
         this.renderScrollView();
     }
     exitScrollMode() {
@@ -288,7 +315,7 @@ export class RekShell {
         const scrollInfo = this.scrollBuffer.isScrolledUp
             ? colors.yellow(`↑ ${this.scrollBuffer.position} lines | ${info.percent}% | `)
             : '';
-        const helpText = colors.gray('Page Up/Down • Home/End • Q to exit');
+        const helpText = colors.gray('↑↓/PgUp/PgDn • Home/End • Esc/Q to exit');
         const statusBar = `\x1b[${rows};1H\x1b[7m ${scrollInfo}${helpText} \x1b[0m`;
         this.originalStdoutWrite(statusBar);
     }
@@ -297,6 +324,21 @@ export class RekShell {
         this.rl.prompt();
     }
     async handleCommand(input) {
+        if (input.startsWith('@')) {
+            const spaceIdx = input.indexOf(' ');
+            if (spaceIdx > 1) {
+                const presetName = input.slice(1, spaceIdx).toLowerCase();
+                const message = input.slice(spaceIdx + 1).trim();
+                if (message) {
+                    await this.runAIPresetChat(presetName, message);
+                    return;
+                }
+            }
+            console.log(colors.yellow('Usage: @<preset> <message>'));
+            console.log(colors.gray('Example: @openai Hello, how are you?'));
+            console.log(colors.gray('Available AI presets: openai, anthropic, groq, google, xai, mistral, cohere'));
+            return;
+        }
         if (input.endsWith('?') && !input.startsWith('?') && input.length > 1) {
             await this.runSearch(input.slice(0, -1).trim());
             return;
@@ -312,6 +354,9 @@ export class RekShell {
             case 'clear':
                 console.clear();
                 return;
+            case 'ai:clear':
+                this.clearAIMemory(parts[1]);
+                return;
             case 'exit':
             case 'quit':
                 this.rl.close();
@@ -507,6 +552,96 @@ export class RekShell {
             await startAIChat(rl, provider, apiKey, model);
         });
     }
+    async runAIPresetChat(presetName, message) {
+        try {
+            let client = this.aiClients.get(presetName);
+            if (!client) {
+                const presetConfig = resolvePreset(presetName);
+                if (!presetConfig) {
+                    console.log(colors.red(`Unknown AI preset: @${presetName}`));
+                    console.log(colors.gray('Available AI presets: openai, anthropic, groq, google, xai, mistral, cohere, deepseek, fireworks, together, perplexity'));
+                    return;
+                }
+                if (!presetConfig._aiConfig) {
+                    console.log(colors.red(`Preset @${presetName} does not support AI features.`));
+                    console.log(colors.gray('Use an AI preset like @openai, @anthropic, @groq, etc.'));
+                    return;
+                }
+                client = createClient(presetConfig);
+                this.aiClients.set(presetName, client);
+            }
+            if (!client.hasAI) {
+                console.log(colors.red(`Preset @${presetName} does not have AI capabilities.`));
+                return;
+            }
+            const model = client._aiConfig?.model || presetName;
+            console.log(colors.gray(`\n${presetName} (${model}) is thinking...`));
+            const stream = await client.ai.chatStream(message);
+            process.stdout.write('\n');
+            for await (const event of stream) {
+                if (event.type === 'text') {
+                    process.stdout.write(colors.orange(event.content));
+                }
+                else if (event.type === 'error') {
+                    console.log(colors.red(`\nError: ${event.error}`));
+                }
+            }
+            const memory = client.ai.getMemory();
+            const pairs = Math.floor(memory.length / 2);
+            console.log(colors.reset(''));
+            console.log(colors.gray(`Memory: ${pairs}/12 pairs (${memory.length} messages)`));
+        }
+        catch (error) {
+            if (error.message?.includes('API key')) {
+                console.log(colors.red(`\nMissing API key for @${presetName}`));
+                const envVarMap = {
+                    openai: 'OPENAI_API_KEY',
+                    anthropic: 'ANTHROPIC_API_KEY',
+                    google: 'GOOGLE_API_KEY',
+                    groq: 'GROQ_API_KEY',
+                    xai: 'XAI_API_KEY',
+                    mistral: 'MISTRAL_API_KEY',
+                    cohere: 'COHERE_API_KEY',
+                    deepseek: 'DEEPSEEK_API_KEY',
+                    fireworks: 'FIREWORKS_API_KEY',
+                    together: 'TOGETHER_API_KEY',
+                    perplexity: 'PERPLEXITY_API_KEY',
+                };
+                const envVar = envVarMap[presetName] || `${presetName.toUpperCase()}_API_KEY`;
+                console.log(colors.gray(`Set ${envVar} environment variable to use this preset.`));
+            }
+            else {
+                console.log(colors.red(`\nError: ${error.message || error}`));
+            }
+        }
+    }
+    clearAIMemory(presetName) {
+        if (presetName) {
+            const client = this.aiClients.get(presetName);
+            if (client && client.hasAI) {
+                client.ai.clearMemory();
+                console.log(colors.green(`Cleared AI memory for @${presetName}`));
+            }
+            else {
+                console.log(colors.yellow(`No active AI session for @${presetName}`));
+            }
+        }
+        else {
+            let cleared = 0;
+            for (const [name, client] of this.aiClients) {
+                if (client.hasAI) {
+                    client.ai.clearMemory();
+                    cleared++;
+                }
+            }
+            if (cleared > 0) {
+                console.log(colors.green(`Cleared AI memory for ${cleared} preset(s)`));
+            }
+            else {
+                console.log(colors.yellow('No active AI sessions to clear'));
+            }
+        }
+    }
     async runLoadTest(args) {
         let targetUrl = '';
         let users = 50;
@@ -1494,7 +1629,7 @@ ${colors.bold('Network:')}
     }
     async runSpider(args) {
         let url = '';
-        let maxDepth = 3;
+        let maxDepth = 5;
         let maxPages = 100;
         let concurrency = 5;
         let seoEnabled = false;
@@ -1502,7 +1637,7 @@ ${colors.bold('Network:')}
         for (let i = 0; i < args.length; i++) {
             const arg = args[i];
             if (arg.startsWith('depth=')) {
-                maxDepth = parseInt(arg.split('=')[1]) || 4;
+                maxDepth = parseInt(arg.split('=')[1]) || 5;
             }
             else if (arg.startsWith('limit=')) {
                 maxPages = parseInt(arg.split('=')[1]) || 100;
@@ -1524,7 +1659,7 @@ ${colors.bold('Network:')}
             if (!this.baseUrl) {
                 console.log(colors.yellow('Usage: spider <url> [options]'));
                 console.log(colors.gray('  Options:'));
-                console.log(colors.gray('    depth=4           Max crawl depth'));
+                console.log(colors.gray('    depth=5           Max crawl depth'));
                 console.log(colors.gray('    limit=100         Max pages to crawl'));
                 console.log(colors.gray('    concurrency=5     Concurrent requests'));
                 console.log(colors.gray('    seo               Enable SEO analysis'));
@@ -2656,6 +2791,17 @@ ${colors.bold('Network:')}
     ${colors.green('ws <url>')}            Start interactive WebSocket session.
     ${colors.green('udp <url>')}           Send UDP packet.
 
+  ${colors.bold('AI Chat:')}
+    ${colors.green('@openai <message>')}   Chat with OpenAI (GPT) with memory.
+    ${colors.green('@anthropic <msg>')}    Chat with Anthropic (Claude) with memory.
+    ${colors.green('@groq <message>')}     Chat with Groq (fast inference).
+    ${colors.green('@google <message>')}   Chat with Google (Gemini).
+    ${colors.green('@xai <message>')}      Chat with xAI (Grok).
+    ${colors.green('@mistral <message>')}  Chat with Mistral AI.
+                             ${colors.gray('Memory:')} ${colors.white('12 pairs (24 messages)')} preserved per preset.
+                             ${colors.gray('Env:')} Set ${colors.white('OPENAI_API_KEY')}, ${colors.white('ANTHROPIC_API_KEY')}, etc.
+    ${colors.green('ai:clear [preset]')}   Clear AI memory (all or specific preset).
+
   ${colors.bold('Network Tools:')}
     ${colors.green('whois <domain>')}      WHOIS lookup (domain or IP).
     ${colors.green('tls <host> [port]')}   Inspect TLS/SSL certificate.
@@ -2687,7 +2833,7 @@ ${colors.bold('Network:')}
   ${colors.bold('Web Crawler:')}
     ${colors.green('spider <url>')}        Crawl website following internal links.
                              ${colors.gray('Options:')}
-                             ${colors.white('--depth=4')}     ${colors.gray('Maximum depth to crawl')}
+                             ${colors.white('--depth=5')}     ${colors.gray('Maximum depth to crawl')}
                              ${colors.white('--limit=100')}   ${colors.gray('Maximum pages to crawl')}
                              ${colors.white('--concurrency=5')} ${colors.gray('Parallel requests')}
 
@@ -2707,7 +2853,8 @@ ${colors.bold('Network:')}
     › get /json
     › post /post name="Neo" active:=true role:Admin
     › load /heavy-endpoint users=100 mode=stress
-    › chat openai gpt-5.1
+    › @openai What is the capital of France?
+    › @anthropic Explain quantum computing
     › spider example.com depth=2 limit=50
     `);
     }