recker 1.0.29 → 1.0.31

package/dist/mcp/tools/seo.js

@@ -0,0 +1,427 @@
+import { createClient } from '../../core/client.js';
+import { analyzeSeo } from '../../seo/analyzer.js';
+import { seoSpider } from '../../seo/seo-spider.js';
+function formatCheck(check) {
+    const icon = check.status === 'pass' ? '✓' : check.status === 'fail' ? '✗' : '⚠';
+    let line = `${icon} [${check.status.toUpperCase()}] ${check.name}: ${check.message}`;
+    if (check.recommendation) {
+        line += `\n   → ${check.recommendation}`;
+    }
+    return line;
+}
+function createIssueSummary(checks) {
+    const critical = checks.filter(c => c.status === 'fail');
+    const warnings = checks.filter(c => c.status === 'warn');
+    const passed = checks.filter(c => c.status === 'pass').length;
+    return { critical, warnings, passed, total: checks.length };
+}
+function extractCategory(name) {
+    const lowerName = name.toLowerCase();
+    const categories = [
+        'meta', 'content', 'links', 'images', 'technical', 'security',
+        'performance', 'mobile', 'accessibility', 'schema', 'structural',
+        'i18n', 'pwa', 'social', 'ecommerce', 'local', 'cwv',
+        'readability', 'crawl', 'internal-linking', 'best-practices'
+    ];
+    for (const cat of categories) {
+        if (lowerName.startsWith(cat) || lowerName.includes(cat)) {
+            return cat;
+        }
+    }
+    return 'general';
+}
+function generateQuickWins(report) {
+    const quickWins = [];
+    for (const check of report.checks) {
+        if (check.status === 'pass')
+            continue;
+        const category = extractCategory(check.name);
+        let priority = 'medium';
+        if (check.status === 'fail') {
+            priority = 'high';
+        }
+        else if (['meta', 'title', 'content'].includes(category)) {
+            priority = 'medium';
+        }
+        else {
+            priority = 'low';
+        }
+        if (check.name.toLowerCase().includes('title') && check.status === 'fail') {
+            priority = 'high';
+        }
+        if (check.name.toLowerCase().includes('meta description') && check.status === 'fail') {
+            priority = 'high';
+        }
+        if (check.name.toLowerCase().includes('h1') && check.status === 'fail') {
+            priority = 'high';
+        }
+        if (check.name.toLowerCase().includes('canonical') && check.status === 'fail') {
+            priority = 'high';
+        }
+        if (check.name.toLowerCase().includes('https') && check.status === 'fail') {
+            priority = 'high';
+        }
+        quickWins.push({
+            priority,
+            category,
+            issue: check.name,
+            action: check.recommendation || check.message,
+            impact: check.evidence?.impact || 'Improves SEO ranking and user experience',
+        });
+    }
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    quickWins.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    return quickWins;
+}
+async function seoAnalyze(args) {
+    const url = String(args.url || '');
+    const categories = args.categories;
+    const verbose = Boolean(args.verbose);
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const client = createClient({ timeout: 30000 });
+        const response = await client.get(url);
+        const html = await response.text();
+        const responseHeaders = {};
+        response.headers.forEach((val, key) => {
+            responseHeaders[key] = val;
+        });
+        const report = await analyzeSeo(html, {
+            baseUrl: url,
+            responseHeaders,
+            rules: categories ? { categories: categories } : undefined,
+        });
+        const summary = createIssueSummary(report.checks);
+        const output = {
+            url,
+            score: report.score,
+            grade: report.grade,
+            summary: {
+                critical: summary.critical.length,
+                warnings: summary.warnings.length,
+                passed: summary.passed,
+                total: summary.total,
+            },
+            timing: report.timing,
+        };
+        if (report.openGraph) {
+            output.openGraph = report.openGraph;
+        }
+        if (summary.critical.length > 0) {
+            output.criticalIssues = summary.critical.map(c => ({
+                name: c.name,
+                message: c.message,
+                recommendation: c.recommendation,
+                evidence: c.evidence,
+            }));
+        }
+        if (summary.warnings.length > 0) {
+            output.warnings = summary.warnings.slice(0, verbose ? undefined : 10).map(c => ({
+                name: c.name,
+                message: c.message,
+                recommendation: c.recommendation,
+            }));
+            if (!verbose && summary.warnings.length > 10) {
+                output.warningsNote = `Showing 10 of ${summary.warnings.length} warnings. Use verbose=true to see all.`;
+            }
+        }
+        if (verbose) {
+            output.detailedAnalysis = {
+                title: report.title,
+                metaDescription: report.metaDescription,
+                headings: report.headings,
+                content: report.content,
+                links: report.links,
+                images: report.images,
+                technical: report.technical,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(output, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `SEO analysis failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+async function seoSpiderCrawl(args) {
+    const url = String(args.url || '');
+    const maxPages = Number(args.maxPages) || 100;
+    const maxDepth = Number(args.maxDepth) || 5;
+    const concurrency = Number(args.concurrency) || 3;
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await seoSpider(url, {
+            seo: true,
+            maxPages,
+            maxDepth,
+            concurrency,
+            delay: 200,
+        });
+        const output = {
+            url,
+            crawlDuration: result.duration,
+            summary: result.summary,
+        };
+        if (result.siteWideIssues.length > 0) {
+            output.siteWideIssues = result.siteWideIssues.map(issue => ({
+                type: issue.type,
+                severity: issue.severity,
+                message: issue.message,
+                affectedUrls: issue.affectedUrls.slice(0, 5),
+                affectedCount: issue.affectedUrls.length,
+                value: issue.value,
+            }));
+        }
+        const pageResults = result.pages
+            .filter(p => p.seoReport)
+            .map(p => ({
+            url: p.url,
+            status: p.status,
+            score: p.seoReport?.score,
+            grade: p.seoReport?.grade,
+            criticalIssues: p.seoReport?.checks.filter(c => c.status === 'fail').length || 0,
+            warnings: p.seoReport?.checks.filter(c => c.status === 'warn').length || 0,
+        }))
+            .sort((a, b) => (a.score || 0) - (b.score || 0));
+        output.pages = pageResults;
+        const errorPages = result.pages.filter(p => p.error);
+        if (errorPages.length > 0) {
+            output.crawlErrors = errorPages.map(p => ({
+                url: p.url,
+                error: p.error,
+            }));
+        }
+        const recommendations = [];
+        if (result.summary.duplicateTitles > 0) {
+            recommendations.push(`Fix ${result.summary.duplicateTitles} pages with duplicate titles - each page should have a unique title`);
+        }
+        if (result.summary.duplicateDescriptions > 0) {
+            recommendations.push(`Fix ${result.summary.duplicateDescriptions} pages with duplicate meta descriptions`);
+        }
+        if (result.summary.duplicateH1s > 0) {
+            recommendations.push(`Fix ${result.summary.duplicateH1s} pages with duplicate H1 headings`);
+        }
+        if (result.summary.orphanPages > 0) {
+            recommendations.push(`Add internal links to ${result.summary.orphanPages} orphan pages that have no incoming links`);
+        }
+        if (result.summary.avgScore < 70) {
+            recommendations.push(`Overall site SEO score is ${result.summary.avgScore}/100 - focus on pages with lowest scores first`);
+        }
+        if (recommendations.length > 0) {
+            output.recommendations = recommendations;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(output, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `SEO spider failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+async function seoQuickWins(args) {
+    const url = String(args.url || '');
+    const limit = Number(args.limit) || 10;
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const client = createClient({ timeout: 30000 });
+        const response = await client.get(url);
+        const html = await response.text();
+        const responseHeaders = {};
+        response.headers.forEach((val, key) => {
+            responseHeaders[key] = val;
+        });
+        const report = await analyzeSeo(html, {
+            baseUrl: url,
+            responseHeaders,
+        });
+        const quickWins = generateQuickWins(report).slice(0, limit);
+        const high = quickWins.filter(w => w.priority === 'high');
+        const medium = quickWins.filter(w => w.priority === 'medium');
+        const low = quickWins.filter(w => w.priority === 'low');
+        const output = {
+            url,
+            score: report.score,
+            grade: report.grade,
+            quickWins: {
+                high: high.map(w => ({
+                    issue: w.issue,
+                    action: w.action,
+                    impact: w.impact,
+                    category: w.category,
+                })),
+                medium: medium.map(w => ({
+                    issue: w.issue,
+                    action: w.action,
+                    category: w.category,
+                })),
+                low: low.map(w => ({
+                    issue: w.issue,
+                    action: w.action,
+                    category: w.category,
+                })),
+            },
+            summary: {
+                totalIssues: quickWins.length,
+                highPriority: high.length,
+                mediumPriority: medium.length,
+                lowPriority: low.length,
+            },
+            advice: high.length > 0
+                ? `Start with the ${high.length} high-priority issues first. These have the biggest impact on SEO.`
+                : medium.length > 0
+                    ? `Good job! No critical issues. Focus on the ${medium.length} medium-priority improvements.`
+                    : 'Excellent! Your page is well-optimized. Consider the minor improvements listed.',
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(output, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Quick wins analysis failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+export const seoTools = [
+    {
+        name: 'rek_seo_analyze',
+        description: `Analyze a single web page for SEO issues using 250+ rules across 21 categories.
+
+Returns:
+- SEO score (0-100) and grade (A-F)
+- Critical issues that must be fixed
+- Warnings and recommendations
+- OpenGraph/social meta analysis
+- Request timing breakdown
+
+Perfect for analyzing your localhost dev server or any public URL. Categories include: meta, content, links, images, technical, security, performance, mobile, accessibility, schema, structural, i18n, PWA, social, e-commerce, local SEO, Core Web Vitals, readability, crawlability, internal linking, and best practices.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'URL to analyze (e.g., http://localhost:3000 or https://example.com)',
+                },
+                categories: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by specific categories (e.g., ["meta", "security", "performance"]). Leave empty for all.',
+                },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Include detailed analysis (headings, links, images breakdown)',
+                    default: false,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'rek_seo_spider',
+        description: `Crawl an entire website and analyze SEO across all pages.
+
+Detects site-wide issues:
+- Duplicate titles, descriptions, and H1s
+- Orphan pages (no internal links pointing to them)
+- Pages with low SEO scores
+
+Returns per-page scores and prioritized recommendations for improving overall site SEO. Great for auditing a full site before launch or finding issues across your dev environment.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'Starting URL to crawl (e.g., http://localhost:3000)',
+                },
+                maxPages: {
+                    type: 'number',
+                    description: 'Maximum pages to crawl',
+                    default: 100,
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum link depth to follow',
+                    default: 5,
+                },
+                concurrency: {
+                    type: 'number',
+                    description: 'Parallel requests (be respectful to servers)',
+                    default: 3,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'rek_seo_quick_wins',
+        description: `Get prioritized, actionable SEO improvements for a page.
+
+Returns issues sorted by priority (high/medium/low) with:
+- What to fix
+- How to fix it
+- Expected impact
+
+Use this when you want a focused list of what to work on next, rather than a full audit.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'URL to analyze',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of quick wins to return',
+                    default: 10,
+                },
+            },
+            required: ['url'],
+        },
+    },
+];
+export const seoToolHandlers = {
+    rek_seo_analyze: seoAnalyze,
+    rek_seo_spider: seoSpiderCrawl,
+    rek_seo_quick_wins: seoQuickWins,
+};

package/dist/presets/anthropic.d.ts

@@ -1,6 +1,8 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface AnthropicPresetOptions {
     apiKey: string;
     version?: string;
+    model?: string;
 }
-export declare function anthropic(options: AnthropicPresetOptions): ClientOptions;
+export declare function anthropic(options: AnthropicPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/anthropic.js

@@ -1,4 +1,13 @@
 export function anthropic(options) {
+    const _aiConfig = {
+        provider: 'anthropic',
+        apiKey: options.apiKey,
+        model: options.model ?? 'claude-sonnet-4-5',
+        headers: {
+            'anthropic-version': options.version || '2023-06-01',
+        },
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://api.anthropic.com/v1',
         headers: {
@@ -12,6 +21,7 @@ export function anthropic(options) {
             backoff: 'exponential',
             delay: 1000,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/azure-openai.d.ts

@@ -1,8 +1,10 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface AzureOpenAIPresetOptions {
     resourceName: string;
     apiKey: string;
     apiVersion?: string;
     deploymentName?: string;
+    model?: string;
 }
-export declare function azureOpenai(options: AzureOpenAIPresetOptions): ClientOptions;
+export declare function azureOpenai(options: AzureOpenAIPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/azure-openai.js

@@ -3,6 +3,15 @@ export function azureOpenai(options) {
     const baseUrl = options.deploymentName
         ? `https://${options.resourceName}.openai.azure.com/openai/deployments/${options.deploymentName}`
         : `https://${options.resourceName}.openai.azure.com/openai`;
+    const _aiConfig = {
+        provider: 'azure-openai',
+        apiKey: options.apiKey,
+        model: options.model ?? options.deploymentName ?? 'gpt-4o',
+        resourceName: options.resourceName,
+        deploymentName: options.deploymentName,
+        apiVersion,
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl,
         headers: {
@@ -20,6 +29,7 @@ export function azureOpenai(options) {
             backoff: 'exponential',
             delay: 1000,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/cohere.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface CoherePresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function cohere(options: CoherePresetOptions): ClientOptions;
+export declare function cohere(options: CoherePresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/cohere.js

@@ -1,9 +1,14 @@
 export function cohere(options) {
+    const _aiConfig = {
+        provider: 'cohere',
+        apiKey: options.apiKey,
+        model: options.model ?? 'command-a-03-2025',
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://api.cohere.ai/v1',
         headers: {
             'Authorization': `Bearer ${options.apiKey}`,
-            'Content-Type': 'application/json',
         },
         timeout: 5 * 60 * 1000,
         retry: {
@@ -11,6 +16,7 @@ export function cohere(options) {
             backoff: 'exponential',
             delay: 1000,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/deepseek.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface DeepSeekPresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function deepseek(options: DeepSeekPresetOptions): ClientOptions;
+export declare function deepseek(options: DeepSeekPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/deepseek.js

@@ -1,9 +1,14 @@
 export function deepseek(options) {
+    const _aiConfig = {
+        provider: 'deepseek',
+        apiKey: options.apiKey,
+        model: options.model ?? 'deepseek-v3.2',
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://api.deepseek.com/v1',
         headers: {
             'Authorization': `Bearer ${options.apiKey}`,
-            'Content-Type': 'application/json',
         },
         timeout: 10 * 60 * 1000,
         retry: {
@@ -11,6 +16,7 @@ export function deepseek(options) {
             backoff: 'exponential',
             delay: 1000,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/fireworks.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface FireworksPresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function fireworks(options: FireworksPresetOptions): ClientOptions;
+export declare function fireworks(options: FireworksPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/fireworks.js

@@ -1,9 +1,14 @@
 export function fireworks(options) {
+    const _aiConfig = {
+        provider: 'fireworks',
+        apiKey: options.apiKey,
+        model: options.model ?? 'accounts/fireworks/models/llama-v3p3-70b-instruct',
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://api.fireworks.ai/inference/v1',
         headers: {
             'Authorization': `Bearer ${options.apiKey}`,
-            'Content-Type': 'application/json',
         },
         timeout: 5 * 60 * 1000,
         retry: {
@@ -11,6 +16,7 @@ export function fireworks(options) {
             backoff: 'exponential',
             delay: 500,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/gemini.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface GeminiPresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function gemini(options: GeminiPresetOptions): ClientOptions;
+export declare function gemini(options: GeminiPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/gemini.js

@@ -1,4 +1,10 @@
 export function gemini(options) {
+    const _aiConfig = {
+        provider: 'google',
+        apiKey: options.apiKey,
+        model: options.model ?? 'gemini-3-pro',
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
         headers: {
@@ -11,6 +17,7 @@ export function gemini(options) {
             backoff: 'exponential',
             delay: 1000,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/groq.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface GroqPresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function groq(options: GroqPresetOptions): ClientOptions;
+export declare function groq(options: GroqPresetOptions): ClientOptions & ClientOptionsWithAI;

package/dist/presets/groq.js

@@ -1,9 +1,14 @@
 export function groq(options) {
+    const _aiConfig = {
+        provider: 'groq',
+        apiKey: options.apiKey,
+        model: options.model ?? 'llama-3.3-70b-versatile',
+        memory: { maxPairs: 12 },
+    };
     return {
         baseUrl: 'https://api.groq.com/openai/v1',
         headers: {
             'Authorization': `Bearer ${options.apiKey}`,
-            'Content-Type': 'application/json',
         },
         timeout: 2 * 60 * 1000,
         retry: {
@@ -11,6 +16,7 @@ export function groq(options) {
             backoff: 'exponential',
             delay: 500,
             statusCodes: [408, 429, 500, 502, 503, 504]
-        }
+        },
+        _aiConfig,
     };
 }

package/dist/presets/huggingface.d.ts

@@ -1,5 +1,7 @@
 import { ClientOptions } from '../types/index.js';
+import type { ClientOptionsWithAI } from '../types/ai-client.js';
 export interface HuggingFacePresetOptions {
     apiKey: string;
+    model?: string;
 }
-export declare function huggingface(options: HuggingFacePresetOptions): ClientOptions;
+export declare function huggingface(options: HuggingFacePresetOptions): ClientOptions & ClientOptionsWithAI;