recker 1.0.34 → 1.0.35-next.1b43fea

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
 import colors from '../utils/colors.js';
 import { formatColumns } from '../utils/columns.js';
+import { summarizeErrors, formatErrorSummary } from './helpers.js';
 async function readStdin() {
     if (process.stdin.isTTY) {
         return null;
@@ -1041,9 +1042,22 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                 const maxResponseTime = responseTimes.length > 0 ? Math.max(...responseTimes) : 0;
                 const reqPerSec = result.duration > 0 ? (result.pages.length / (result.duration / 1000)).toFixed(1) : '0';
                 const statusCounts = new Map();
+                const errorDetails = [];
                 for (const page of result.pages) {
-                    const status = page.status || 0;
-                    statusCounts.set(status, (statusCounts.get(status) || 0) + 1);
+                    if (page.status && page.status > 0) {
+                        const key = page.status.toString();
+                        statusCounts.set(key, (statusCounts.get(key) || 0) + 1);
+                    }
+                    else if (page.error) {
+                        const { classifyError } = await import('./helpers.js');
+                        const classified = classifyError(page.error);
+                        const key = classified.category.type;
+                        statusCounts.set(key, (statusCounts.get(key) || 0) + 1);
+                        errorDetails.push({ url: page.url, error: page.error, status: page.status || 0 });
+                    }
+                    else {
+                        statusCounts.set('UNKNOWN', (statusCounts.get('UNKNOWN') || 0) + 1);
+                    }
                 }
                 let totalInternalLinks = 0;
                 let totalExternalLinks = 0;
@@ -1069,12 +1083,55 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                 console.log(`    ${colors.gray('Throughput:')}    ${reqPerSec} req/s`);
                 console.log(colors.bold('\n  HTTP Status:'));
                 const sortedStatuses = Array.from(statusCounts.entries()).sort((a, b) => b[1] - a[1]);
-                for (const [status, count] of sortedStatuses.slice(0, 5)) {
-                    const statusLabel = status === 0 ? 'Error' : status.toString();
-                    const statusColor = status >= 400 || status === 0 ? colors.red :
-                        status >= 300 ? colors.yellow : colors.green;
+                for (const [statusKey, count] of sortedStatuses.slice(0, 8)) {
+                    const statusNum = parseInt(statusKey);
+                    const isHttpStatus = !isNaN(statusNum) && statusNum > 0;
+                    let statusLabel;
+                    let statusColor;
+                    if (isHttpStatus) {
+                        statusLabel = statusNum.toString();
+                        statusColor = statusNum >= 500 ? colors.red :
+                            statusNum >= 400 ? colors.yellow :
+                                statusNum >= 300 ? colors.cyan : colors.green;
+                    }
+                    else {
+                        statusLabel = statusKey;
+                        statusColor = statusKey.startsWith('HTTP_4') ? colors.yellow :
+                            statusKey.startsWith('HTTP_5') ? colors.red :
+                                statusKey === 'TIMEOUT' ? colors.yellow :
+                                    colors.red;
+                    }
                     const pct = ((count / result.pages.length) * 100).toFixed(0);
-                    console.log(`    ${statusColor(statusLabel.padEnd(5))} ${count.toString().padStart(3)} (${pct}%)`);
+                    console.log(`    ${statusColor(statusLabel.padEnd(12))} ${count.toString().padStart(3)} (${pct}%)`);
+                }
+                if (errorDetails.length > 0) {
+                    console.log(colors.bold('\n  Errors:'));
+                    const grouped = new Map();
+                    for (const err of errorDetails) {
+                        const { classifyError } = await import('./helpers.js');
+                        const classified = classifyError(err.error);
+                        const key = classified.category.type;
+                        if (!grouped.has(key))
+                            grouped.set(key, []);
+                        grouped.get(key).push(err);
+                    }
+                    for (const [type, errs] of grouped) {
+                        const paths = errs.map(e => {
+                            try {
+                                return new URL(e.url).pathname;
+                            }
+                            catch {
+                                return e.url;
+                            }
+                        });
+                        console.log(`    ${colors.red(type.padEnd(16))} ${errs.length} page${errs.length > 1 ? 's' : ''}`);
+                        for (const path of paths.slice(0, 3)) {
+                            console.log(`      ${colors.gray('→')} ${path.slice(0, 60)}`);
+                        }
+                        if (paths.length > 3) {
+                            console.log(`      ${colors.gray(`... and ${paths.length - 3} more`)}`);
+                        }
+                    }
                 }
                 console.log(colors.bold('\n  Content:'));
                 console.log(`    ${colors.gray('Internal links:')} ${totalInternalLinks.toLocaleString()}`);
@@ -1181,27 +1238,9 @@ ${colors.bold(colors.yellow('Focus Modes:'))}
                         console.log(`    ${colors.cyan(page.links.length.toString().padStart(3))} ${title}`);
                     }
                 }
-                const formatError = (error) => {
-                    const statusMatch = error.match(/status code (\d{3})/i);
-                    if (statusMatch) {
-                        return `HTTP ${statusMatch[1]}`;
-                    }
-                    return error.length > 50 ? error.slice(0, 47) + '...' : error;
-                };
-                if (result.errors.length > 0 && result.errors.length <= 10) {
-                    console.log(colors.bold('\n  Errors:'));
-                    for (const err of result.errors) {
-                        const path = new URL(err.url).pathname;
-                        console.log(`    ${colors.red('✗')} ${path.padEnd(30)} → ${formatError(err.error)}`);
-                    }
-                }
-                else if (result.errors.length > 10) {
-                    console.log(colors.bold('\n  Errors:'));
-                    for (const err of result.errors.slice(0, 5)) {
-                        const path = new URL(err.url).pathname;
-                        console.log(`    ${colors.red('✗')} ${path.padEnd(30)} → ${formatError(err.error)}`);
-                    }
-                    console.log(colors.gray(`    ... and ${result.errors.length - 5} more errors`));
+                if (result.errors.length > 0) {
+                    const errorSummary = summarizeErrors(result.errors);
+                    console.log(formatErrorSummary(errorSummary));
                 }
                 if (outputFile) {
                     const jsonOutput = {

package/dist/cli/presets.d.ts

@@ -1 +1,5 @@
-export declare function resolvePreset(name: string): any;
+export interface ResolvePresetOptions {
+    throwOnError?: boolean;
+    silent?: boolean;
+}
+export declare function resolvePreset(name: string, options?: ResolvePresetOptions): any;

package/dist/cli/presets.js

@@ -10,38 +10,62 @@ const ENV_MAPPING = {
     slack: ['SLACK_TOKEN'],
     vercel: ['VERCEL_TOKEN'],
     supabase: ['SUPABASE_URL', 'SUPABASE_KEY'],
+    groq: ['GROQ_API_KEY'],
+    google: ['GOOGLE_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'],
 };
-export function resolvePreset(name) {
+export function resolvePreset(name, options = {}) {
+    const { throwOnError = false, silent = false } = options;
     const presetFn = presets[name];
     if (!presetFn) {
-        console.error(colors.red(`Error: Unknown preset '@${name}'`));
-        process.exit(1);
+        const msg = `Unknown preset '@${name}'`;
+        if (throwOnError) {
+            throw new Error(msg);
+        }
+        if (!silent) {
+            console.error(colors.red(`Error: ${msg}`));
+        }
+        return null;
     }
     const requiredEnvs = ENV_MAPPING[name];
-    const options = {};
+    const presetOptions = {};
     if (requiredEnvs) {
         let missing = false;
         for (const envVar of requiredEnvs) {
             const value = process.env[envVar];
             if (!value) {
-                console.error(colors.yellow(`Warning: Missing env variable ${envVar} for preset @${name}`));
+                if (!silent) {
+                    console.error(colors.yellow(`Warning: Missing env variable ${envVar} for preset @${name}`));
+                }
                 missing = true;
             }
             else {
                 const key = mapEnvToOption(name, envVar);
-                options[key] = value;
+                presetOptions[key] = value;
             }
         }
-        if (missing) {
+        if (missing && !silent) {
             console.log(colors.gray(`Tip: export ${requiredEnvs.join('=... ')}=...`));
         }
     }
     try {
-        return presetFn(options);
+        return presetFn(presetOptions);
     }
     catch (error) {
-        console.error(colors.red(`Error initializing preset @${name}: ${error.message}`));
-        process.exit(1);
+        const msg = `Error initializing preset @${name}: ${error.message}`;
+        if (throwOnError) {
+            throw new Error(msg);
+        }
+        if (!silent) {
+            console.error(colors.red(msg));
+        }
+        return null;
     }
 }
 function mapEnvToOption(preset, env) {

package/dist/cli/tui/ai-chat.d.ts

@@ -1,2 +1,7 @@
 import readline from 'node:readline';
-export declare function startAIChat(rl: readline.Interface, provider?: string, apiKey?: string, model?: string): Promise<void>;
+import type { Client } from '../../core/client.js';
+export interface AIMode {
+    aiClients: Map<string, Client>;
+    variables?: Record<string, any>;
+}
+export declare function startAIChat(rl: readline.Interface, provider: string | undefined, context: AIMode): Promise<void>;

package/dist/cli/tui/ai-chat.js

@@ -1,100 +1,304 @@
 import readline from 'node:readline';
 import colors from '../../utils/colors.js';
-import { createAI } from '../../ai/client.js';
-export async function startAIChat(rl, provider = 'openai', apiKey, model) {
-    console.clear();
-    console.log(colors.bold(colors.magenta(`🤖 Rek AI Chat (${provider})`)));
-    console.log(colors.gray('Type your message. Ctrl+C to exit.'));
-    const envKey = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
-    const key = apiKey || process.env[envKey];
-    if (!key) {
-        console.log(colors.yellow(`
-Warning: No API Key found for ${provider}.`));
-        console.log(`Please set it via environment variable ${colors.bold(envKey)} or passing it to the command.`);
-        console.log(`Example: set ${envKey}=sk-... inside the shell.`);
+import { createClient } from '../../core/client.js';
+import { resolvePreset } from '../presets.js';
+const AI_PRESETS = [
+    'openai', 'anthropic', 'groq', 'google', 'xai',
+    'mistral', 'cohere', 'deepseek', 'fireworks', 'together', 'perplexity'
+];
+const ENV_VAR_MAP = {
+    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',
+};
+export async function startAIChat(rl, provider = 'openai', context) {
+    let currentProvider = provider.toLowerCase();
+    if (!AI_PRESETS.includes(currentProvider)) {
+        console.log(colors.red(`Unknown AI provider: ${currentProvider}`));
+        console.log(colors.gray(`Available: ${AI_PRESETS.join(', ')}`));
         return;
     }
-    const client = createAI({
-        defaultProvider: provider,
-        providers: {
-            [provider]: { apiKey: key }
-        },
-        observability: false
-    });
-    const history = [
-        { role: 'system', content: 'You are Recker AI, a helpful and concise assistant in a terminal environment.' }
-    ];
-    rl.setPrompt(colors.magenta('You › '));
+    console.clear();
+    printHeader(currentProvider);
+    let client = await getOrCreateClient(currentProvider, context);
+    if (!client)
+        return;
+    const getPrompt = () => colors.magenta(`${currentProvider} › `);
+    rl.setPrompt(getPrompt());
     rl.prompt();
+    let isGenerating = false;
+    let abortController = null;
     return new Promise((resolve) => {
+        const cleanup = () => {
+            rl.off('line', onLine);
+            rl.off('SIGINT', onSigInt);
+            if (process.stdin.isTTY) {
+                process.stdin.off('keypress', onKeypress);
+            }
+            console.log('');
+            console.log(colors.gray('Exiting AI mode...'));
+        };
         const onLine = async (line) => {
             const input = line.trim();
             if (!input) {
                 rl.prompt();
                 return;
             }
-            if (input.toLowerCase() === '/clear') {
-                history.length = 1;
-                console.clear();
-                console.log(colors.gray('Context cleared.'));
-                rl.prompt();
-                return;
+            if (input.startsWith('/')) {
+                const handled = await handleCommand(input, currentProvider, client, context, rl, () => {
+                    cleanup();
+                    resolve();
+                }, async (newProvider) => {
+                    currentProvider = newProvider;
+                    client = await getOrCreateClient(currentProvider, context);
+                    if (client) {
+                        rl.setPrompt(getPrompt());
+                        console.log(colors.green(`Switched to ${currentProvider}`));
+                        const memory = client.ai.getMemory();
+                        if (memory.length > 0) {
+                            console.log(colors.gray(`Memory: ${Math.floor(memory.length / 2)} pairs`));
+                        }
+                    }
+                    rl.prompt();
+                });
+                if (handled)
+                    return;
             }
-            if (input.toLowerCase() === '/exit') {
-                cleanup();
-                resolve();
+            if (!client || !client.hasAI) {
+                console.log(colors.red('AI client not available'));
+                rl.prompt();
                 return;
             }
-            history.push({ role: 'user', content: input });
             rl.pause();
-            process.stdout.write(colors.cyan('AI  › '));
-            let fullResponse = '';
+            isGenerating = true;
+            abortController = new AbortController();
+            const model = client._aiConfig?.model || currentProvider;
+            process.stdout.write(colors.gray(`${model} › `));
             try {
-                const stream = await client.stream({
-                    provider: provider,
-                    model: model,
-                    messages: history
-                });
-                for await (const chunk of stream) {
-                    const content = typeof chunk === 'string' ? chunk : chunk.content || chunk.delta?.content || '';
-                    if (content) {
-                        process.stdout.write(content);
-                        fullResponse += content;
+                const stream = await client.ai.chatStream(input);
+                let hasContent = false;
+                for await (const event of stream) {
+                    if (abortController?.signal.aborted) {
+                        console.log(colors.yellow('\n[Interrupted]'));
+                        break;
+                    }
+                    if (event.type === 'text') {
+                        if (!hasContent) {
+                            process.stdout.write('\n' + colors.orange(event.content));
+                            hasContent = true;
+                        }
+                        else {
+                            process.stdout.write(colors.orange(event.content));
+                        }
+                    }
+                    else if (event.type === 'error') {
+                        console.log(colors.red(`\nError: ${event.error}`));
                     }
                 }
-                process.stdout.write('\n');
-                history.push({ role: 'assistant', content: fullResponse });
+                console.log(colors.reset(''));
+                const memory = client.ai.getMemory();
+                const pairs = Math.floor(memory.length / 2);
+                console.log(colors.gray(`Memory: ${pairs}/12 pairs`));
             }
             catch (error) {
-                console.log(colors.red(`
-Error: ${error.message}`));
-                if (error.cause)
-                    console.log(colors.gray(error.cause));
+                handleError(error, currentProvider);
             }
             finally {
+                isGenerating = false;
+                abortController = null;
                 rl.resume();
                 rl.prompt();
             }
         };
-        const cleanup = () => {
-            rl.off('line', onLine);
-            rl.off('SIGINT', onSigInt);
-            process.stdin.off('keypress', onKeypress);
-        };
-        if (process.stdin.isTTY)
-            readline.emitKeypressEvents(process.stdin);
         const onKeypress = (_str, key) => {
             if (key && key.name === 'escape') {
-                cleanup();
-                resolve();
+                if (isGenerating && abortController) {
+                    abortController.abort();
+                }
+                else {
+                    cleanup();
+                    resolve();
+                }
             }
         };
-        process.stdin.on('keypress', onKeypress);
+        if (process.stdin.isTTY) {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.on('keypress', onKeypress);
+        }
         rl.on('line', onLine);
         const onSigInt = () => {
-            cleanup();
-            resolve();
+            if (isGenerating && abortController) {
+                abortController.abort();
+            }
+            else {
+                cleanup();
+                resolve();
+            }
         };
         rl.once('SIGINT', onSigInt);
     });
 }
+async function getOrCreateClient(provider, context) {
+    let client = context.aiClients.get(provider);
+    if (client) {
+        return client;
+    }
+    try {
+        const presetConfig = resolvePreset(provider);
+        if (!presetConfig) {
+            console.log(colors.red(`Unknown preset: ${provider}`));
+            return null;
+        }
+        if (!presetConfig._aiConfig) {
+            console.log(colors.red(`Preset ${provider} does not support AI features.`));
+            return null;
+        }
+        client = createClient(presetConfig);
+        context.aiClients.set(provider, client);
+        return client;
+    }
+    catch (error) {
+        const envVar = ENV_VAR_MAP[provider] || `${provider.toUpperCase()}_API_KEY`;
+        console.log(colors.red(`Failed to initialize ${provider}`));
+        console.log(colors.gray(`Make sure ${envVar} is set.`));
+        return null;
+    }
+}
+async function handleCommand(input, currentProvider, client, context, rl, onExit, onSwitch) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    switch (cmd) {
+        case 'exit':
+        case 'quit':
+        case 'q':
+            onExit();
+            return true;
+        case 'clear':
+            if (client?.hasAI) {
+                client.ai.clearMemory();
+                console.log(colors.green(`Memory cleared for ${currentProvider}`));
+            }
+            rl.prompt();
+            return true;
+        case 'switch':
+        case 's':
+            const newProvider = args[0]?.toLowerCase();
+            if (!newProvider) {
+                console.log(colors.yellow('Usage: /switch <provider>'));
+                console.log(colors.gray(`Available: ${AI_PRESETS.join(', ')}`));
+                rl.prompt();
+                return true;
+            }
+            if (!AI_PRESETS.includes(newProvider)) {
+                console.log(colors.red(`Unknown provider: ${newProvider}`));
+                console.log(colors.gray(`Available: ${AI_PRESETS.join(', ')}`));
+                rl.prompt();
+                return true;
+            }
+            await onSwitch(newProvider);
+            return true;
+        case 'model':
+        case 'm':
+            const model = client?._aiConfig?.model || 'default';
+            console.log(colors.cyan(`Current model: ${model}`));
+            console.log(colors.gray('Note: Model is set by the preset configuration.'));
+            rl.prompt();
+            return true;
+        case 'memory':
+        case 'mem':
+            if (client?.hasAI) {
+                const memory = client.ai.getMemory();
+                const pairs = Math.floor(memory.length / 2);
+                console.log(colors.cyan(`Memory: ${pairs}/12 pairs (${memory.length} messages)`));
+                if (pairs > 0) {
+                    console.log(colors.gray('Last exchange:'));
+                    const lastTwo = memory.slice(-2);
+                    for (const msg of lastTwo) {
+                        const role = msg.role === 'user' ? colors.magenta('You') : colors.orange('AI');
+                        const preview = msg.content.slice(0, 100) + (msg.content.length > 100 ? '...' : '');
+                        console.log(`  ${role}: ${colors.gray(preview)}`);
+                    }
+                }
+            }
+            rl.prompt();
+            return true;
+        case 'providers':
+        case 'list':
+            console.log(colors.cyan('Available AI providers:'));
+            for (const p of AI_PRESETS) {
+                const isActive = p === currentProvider ? colors.green(' (active)') : '';
+                const hasClient = context.aiClients.has(p) ? colors.gray(' [loaded]') : '';
+                console.log(`  ${p}${isActive}${hasClient}`);
+            }
+            rl.prompt();
+            return true;
+        case 'help':
+        case 'h':
+        case '?':
+            printHelp();
+            rl.prompt();
+            return true;
+        default:
+            console.log(colors.yellow(`Unknown command: /${cmd}`));
+            console.log(colors.gray('Type /help for available commands'));
+            rl.prompt();
+            return true;
+    }
+}
+function handleError(error, provider) {
+    if (error.message?.includes('API key') || error.message?.includes('401') || error.message?.includes('Unauthorized')) {
+        const envVar = ENV_VAR_MAP[provider] || `${provider.toUpperCase()}_API_KEY`;
+        console.log(colors.red(`\nAuthentication error for ${provider}`));
+        console.log(colors.gray(`Set ${envVar} environment variable.`));
+    }
+    else if (error.message?.includes('429') || error.message?.includes('rate limit')) {
+        console.log(colors.yellow(`\nRate limited by ${provider}. Wait a moment and try again.`));
+    }
+    else {
+        console.log(colors.red(`\nError: ${error.message || error}`));
+    }
+}
+function printHeader(provider) {
+    console.log(colors.bold(colors.cyan('Rek AI Mode')));
+    console.log('');
+    console.log(`  ${colors.gray('Provider:')} ${colors.white(provider)}`);
+    console.log('');
+    console.log(`  ${colors.green('/switch')} ${colors.gray('<provider>')}  ${colors.gray('Change AI provider')}`);
+    console.log(`  ${colors.green('/clear')}              ${colors.gray('Clear conversation memory')}`);
+    console.log(`  ${colors.green('/memory')}             ${colors.gray('Show memory status')}`);
+    console.log(`  ${colors.green('/help')}               ${colors.gray('Show all commands')}`);
+    console.log('');
+    console.log(`  ${colors.yellow('ESC')} ${colors.gray('or')} ${colors.yellow('/exit')}          ${colors.gray('Exit AI mode')}`);
+    console.log('');
+    console.log(colors.gray('─'.repeat(50)));
+    console.log('');
+}
+function printHelp() {
+    console.log(`
+${colors.bold(colors.cyan('AI Mode Commands'))}
+
+  ${colors.green('/switch <provider>')}  Switch to another AI provider
+  ${colors.green('/clear')}              Clear conversation memory
+  ${colors.green('/memory')}             Show memory status
+  ${colors.green('/model')}              Show current model
+  ${colors.green('/providers')}          List available providers
+  ${colors.green('/help')}               Show this help
+  ${colors.green('/exit')}               Exit AI mode
+
+${colors.bold('Shortcuts')}
+  ${colors.gray('ESC')}                  Exit AI mode (or abort generation)
+  ${colors.gray('Ctrl+C')}               Exit AI mode
+
+${colors.bold('Available Providers')}
+  ${AI_PRESETS.join(', ')}
+`);
+}

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

@@ -106,4 +106,5 @@ export declare class RekShell {
     private runUpload;
     private runDownload;
     private printHelp;
+    private printCommandHelp;
 }