recker 1.0.30 → 1.0.32-next.02f2bae

package/dist/mcp/search/hybrid-search.js

@@ -1,5 +1,5 @@
 import Fuse from 'fuse.js';
-import { cosineSimilarity, combineScores, levenshtein } from './math.js';
+import { cosineSimilarity, levenshtein } from './math.js';
 import { loadEmbeddings } from '../embeddings-loader.js';
 import { StateError } from '../../core/errors.js';
 let cachedEmbeddings = null;
@@ -99,7 +99,9 @@ export class HybridSearch {
             for (const result of semanticResults) {
                 const existing = results.get(result.id);
                 if (existing) {
-                    existing.score = combineScores(existing.score, result.score);
+                    const maxScore = Math.max(existing.score, result.score);
+                    const bonus = Math.min(existing.score, result.score) * 0.3;
+                    existing.score = Math.min(1.0, maxScore + bonus);
                     existing.source = 'hybrid';
                 }
                 else {

package/dist/seo/analyzer.d.ts

@@ -26,6 +26,13 @@ export declare class SeoAnalyzer {
     private analyzeTrustSignals;
     private calculateTextHtmlRatio;
     private convertToCheckResults;
+    private buildSummary;
+    private calculateMetaCompleteness;
+    private calculateSocialCompleteness;
+    private calculateTechnicalCompleteness;
+    private calculateContentCompleteness;
+    private calculateImageCompleteness;
+    private calculateLinkCompleteness;
     private analyzeHeadings;
     private analyzeContent;
     private buildLinkAnalysis;

package/dist/seo/analyzer.js

@@ -49,11 +49,21 @@ export class SeoAnalyzer {
         const ruleResults = this.rulesEngine.evaluate(context);
         const checks = this.convertToCheckResults(ruleResults);
         const { score, grade } = this.calculateScore(checks);
+        const summary = this.buildSummary(ruleResults, checks, {
+            content,
+            imageAnalysis,
+            linkAnalysis,
+            meta,
+            og,
+            twitter,
+            technical,
+        });
         return {
             url,
             timestamp: new Date(),
             grade,
             score,
+            summary,
             checks,
             title: meta.title ? { text: meta.title, length: meta.title.length } : undefined,
             metaDescription: meta.description ? { text: meta.description, length: meta.description.length } : undefined,
@@ -72,16 +82,17 @@ export class SeoAnalyzer {
                 image: Array.isArray(twitter.image) ? twitter.image[0] : twitter.image,
                 site: twitter.site,
             } : undefined,
+            structuredData: {
+                count: jsonLd.length,
+                types: jsonLd.map((j) => j['@type']).filter(Boolean),
+                items: jsonLd,
+            },
             headings: headings,
             content,
             links: linkAnalysis,
             images: imageAnalysis,
             social,
             technical,
-            jsonLd: {
-                count: jsonLd.length,
-                types: jsonLd.map((j) => j['@type']).filter(Boolean),
-            },
         };
     }
     buildRuleContext(data) {
@@ -503,6 +514,191 @@ export class SeoAnalyzer {
             evidence: r.evidence,
         }));
     }
+    buildSummary(ruleResults, checks, data) {
+        const passed = checks.filter(c => c.status === 'pass').length;
+        const warnings = checks.filter(c => c.status === 'warn').length;
+        const errors = checks.filter(c => c.status === 'fail').length;
+        const infos = checks.filter(c => c.status === 'info').length;
+        const totalChecks = checks.length;
+        const scoringChecks = totalChecks - infos;
+        const passRate = scoringChecks > 0 ? Math.round((passed / scoringChecks) * 100) : 100;
+        const issuesByCategory = {};
+        for (const result of ruleResults) {
+            const cat = result.category;
+            if (!issuesByCategory[cat]) {
+                issuesByCategory[cat] = { passed: 0, warnings: 0, errors: 0 };
+            }
+            if (result.status === 'pass')
+                issuesByCategory[cat].passed++;
+            else if (result.status === 'warn')
+                issuesByCategory[cat].warnings++;
+            else if (result.status === 'fail')
+                issuesByCategory[cat].errors++;
+        }
+        const topIssues = ruleResults
+            .filter(r => r.status === 'fail' || r.status === 'warn')
+            .sort((a, b) => {
+            if (a.status === 'fail' && b.status !== 'fail')
+                return -1;
+            if (a.status !== 'fail' && b.status === 'fail')
+                return 1;
+            return 0;
+        })
+            .slice(0, 5)
+            .map(r => ({
+            name: r.name,
+            message: r.message,
+            category: r.category,
+            severity: (r.status === 'fail' ? 'error' : 'warning'),
+        }));
+        const quickWins = [];
+        if (!data.meta.title)
+            quickWins.push('Add a page title');
+        if (!data.meta.description)
+            quickWins.push('Add a meta description');
+        if (!data.og.title && !data.og.description)
+            quickWins.push('Add OpenGraph meta tags for social sharing');
+        if (!data.twitter.card)
+            quickWins.push('Add Twitter Card meta tags');
+        if (!data.technical.hasCanonical)
+            quickWins.push('Add a canonical URL');
+        if (!data.technical.hasLang)
+            quickWins.push('Add lang attribute to <html>');
+        if (data.imageAnalysis.withoutAlt > 0)
+            quickWins.push(`Add alt text to ${data.imageAnalysis.withoutAlt} image(s)`);
+        if (data.linkAnalysis.withoutText > 0)
+            quickWins.push(`Add text to ${data.linkAnalysis.withoutText} empty link(s)`);
+        const limitedQuickWins = quickWins.slice(0, 5);
+        const htmlSize = this.$('html').html()?.length;
+        const domElements = this.$('*').length;
+        const vitals = {
+            htmlSize,
+            domElements,
+            ttfb: this.options.responseHeaders ? undefined : undefined,
+            totalTime: undefined,
+            wordCount: data.content.wordCount,
+            readingTime: data.content.readingTimeMinutes,
+            imageCount: data.imageAnalysis.total,
+            linkCount: data.linkAnalysis.total,
+        };
+        const completeness = {
+            meta: this.calculateMetaCompleteness(data.meta),
+            social: this.calculateSocialCompleteness(data.og, data.twitter),
+            technical: this.calculateTechnicalCompleteness(data.technical),
+            content: this.calculateContentCompleteness(data.content),
+            images: this.calculateImageCompleteness(data.imageAnalysis),
+            links: this.calculateLinkCompleteness(data.linkAnalysis),
+        };
+        return {
+            totalChecks,
+            passed,
+            warnings,
+            errors,
+            infos,
+            passRate,
+            issuesByCategory,
+            topIssues,
+            quickWins: limitedQuickWins,
+            vitals,
+            completeness,
+        };
+    }
+    calculateMetaCompleteness(meta) {
+        let score = 0;
+        const total = 5;
+        if (meta.title)
+            score++;
+        if (meta.description)
+            score++;
+        if (meta.canonical)
+            score++;
+        if (meta.viewport)
+            score++;
+        if (meta.charset)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateSocialCompleteness(og, twitter) {
+        let score = 0;
+        const total = 8;
+        if (og.title)
+            score++;
+        if (og.description)
+            score++;
+        if (og.image)
+            score++;
+        if (og.url)
+            score++;
+        if (twitter.card)
+            score++;
+        if (twitter.title)
+            score++;
+        if (twitter.description)
+            score++;
+        if (twitter.image)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateTechnicalCompleteness(technical) {
+        let score = 0;
+        const total = 5;
+        if (technical.hasCanonical)
+            score++;
+        if (technical.hasViewport)
+            score++;
+        if (technical.hasCharset)
+            score++;
+        if (technical.hasLang)
+            score++;
+        if (technical.hasRobotsMeta)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateContentCompleteness(content) {
+        let score = 0;
+        const total = 5;
+        if (content.wordCount >= 300)
+            score++;
+        if (content.paragraphCount >= 3)
+            score++;
+        if (content.listCount > 0)
+            score++;
+        if (content.readingTimeMinutes >= 1)
+            score++;
+        if (content.strongTagCount > 0 || content.emTagCount > 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateImageCompleteness(images) {
+        if (images.total === 0)
+            return 100;
+        let score = 0;
+        const total = 4;
+        if (images.withoutAlt === 0)
+            score++;
+        if (images.lazy > 0)
+            score++;
+        if (images.missingDimensions === 0)
+            score++;
+        if (images.modernFormats > 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateLinkCompleteness(links) {
+        if (links.total === 0)
+            return 100;
+        let score = 0;
+        const total = 4;
+        if (links.internal > 0)
+            score++;
+        if (links.external > 0)
+            score++;
+        if (links.withoutText === 0)
+            score++;
+        if (links.broken === 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
     analyzeHeadings() {
         const issues = [];
         const structure = [];

package/dist/seo/rules/ai-search.d.ts

@@ -0,0 +1,2 @@
+import { SeoRule } from './types.js';
+export declare const aiSearchRules: SeoRule[];