recker 1.0.28-next.c61382b → 1.0.28

package/dist/seo/analyzer.js

@@ -72,16 +72,6 @@ export class SeoAnalyzer {
     buildRuleContext(data) {
         const { meta, og, twitter, jsonLd, headings, content, linkAnalysis, imageAnalysis, links } = data;
         const htmlLang = this.$('html').attr('lang');
-        const hreflangTags = [];
-        this.$('link[rel="alternate"][hreflang]').each((_, el) => {
-            const $el = this.$(el);
-            const lang = $el.attr('hreflang');
-            const href = $el.attr('href');
-            if (lang && href) {
-                hreflangTags.push({ lang, href });
-            }
-        });
-        const ogLocale = this.$('meta[property="og:locale"]').attr('content');
         const genericTexts = SEO_THRESHOLDS.links.genericTexts;
         const genericTextLinks = links.filter((l) => {
             const text = l.text?.toLowerCase().trim();
@@ -206,8 +196,6 @@ export class SeoAnalyzer {
             titleMatchesH1: meta.title && h1Text ? meta.title.toLowerCase().trim() === h1Text.toLowerCase().trim() : undefined,
             ...this.analyzeUrlQuality(),
             ...this.analyzeJsRendering(content),
-            hreflangTags: hreflangTags.length > 0 ? hreflangTags : undefined,
-            ogLocale,
         };
     }
     analyzeUrlQuality() {

package/dist/seo/rules/index.d.ts

@@ -2,38 +2,6 @@ import { SeoRule, RuleCategory, RuleSeverity, RuleContext, RuleResult } from './
 export * from './types.js';
 export * from './thresholds.js';
 export declare const ALL_SEO_RULES: SeoRule[];
-export declare const SCORING_WEIGHTS: {
-    readonly severity: {
-        readonly error: {
-            readonly pass: 10;
-            readonly fail: -15;
-            readonly warn: -10;
-            readonly info: 0;
-        };
-        readonly warning: {
-            readonly pass: 5;
-            readonly fail: -8;
-            readonly warn: -5;
-            readonly info: 0;
-        };
-        readonly info: {
-            readonly pass: 2;
-            readonly fail: -3;
-            readonly warn: -2;
-            readonly info: 0;
-        };
-    };
-    readonly category: Record<RuleCategory, number>;
-};
-export declare function calculateWeightedScore(results: RuleResult[]): {
-    score: number;
-    maxPossible: number;
-    details: {
-        category: RuleCategory;
-        score: number;
-        weight: number;
-    }[];
-};
 export interface RulesEngineOptions {
     categories?: RuleCategory[];
     excludeCategories?: RuleCategory[];

package/dist/seo/rules/index.js

@@ -9,12 +9,6 @@ import { securityRules } from './security.js';
 import { schemaRules } from './schema.js';
 import { accessibilityRules } from './accessibility.js';
 import { mobileRules } from './mobile.js';
-import { i18nRules } from './i18n.js';
-import { ecommerceRules } from './ecommerce.js';
-import { localRules } from './local.js';
-import { cwvRules } from './cwv.js';
-import { crawlRules } from './crawl.js';
-import { readabilityRules } from './readability.js';
 export * from './types.js';
 export * from './thresholds.js';
 export const ALL_SEO_RULES = [
@@ -29,64 +23,7 @@ export const ALL_SEO_RULES = [
     ...schemaRules,
     ...accessibilityRules,
     ...mobileRules,
-    ...i18nRules,
-    ...ecommerceRules,
-    ...localRules,
-    ...cwvRules,
-    ...crawlRules,
-    ...readabilityRules,
 ];
-export const SCORING_WEIGHTS = {
-    severity: {
-        error: { pass: 10, fail: -15, warn: -10, info: 0 },
-        warning: { pass: 5, fail: -8, warn: -5, info: 0 },
-        info: { pass: 2, fail: -3, warn: -2, info: 0 },
-    },
-    category: {
-        title: 1.5,
-        meta: 1.3,
-        og: 1.0,
-        twitter: 0.8,
-        headings: 1.2,
-        images: 1.0,
-        links: 1.1,
-        content: 1.2,
-        technical: 1.3,
-        security: 0.9,
-        mobile: 1.2,
-        'structured-data': 1.0,
-        performance: 1.4,
-        accessibility: 0.8,
-    },
-};
-export function calculateWeightedScore(results) {
-    const categoryScores = {};
-    for (const result of results) {
-        const severityWeight = SCORING_WEIGHTS.severity[result.severity];
-        const statusScore = severityWeight[result.status] ?? 0;
-        if (!categoryScores[result.category]) {
-            categoryScores[result.category] = { score: 0, count: 0 };
-        }
-        categoryScores[result.category].score += statusScore;
-        categoryScores[result.category].count++;
-    }
-    let totalScore = 0;
-    let totalWeight = 0;
-    const details = [];
-    for (const [cat, data] of Object.entries(categoryScores)) {
-        const category = cat;
-        const categoryWeight = SCORING_WEIGHTS.category[category] ?? 1;
-        const normalizedScore = data.count > 0 ? data.score / data.count : 0;
-        const weightedScore = normalizedScore * categoryWeight;
-        details.push({ category, score: normalizedScore, weight: categoryWeight });
-        totalScore += weightedScore;
-        totalWeight += categoryWeight;
-    }
-    const maxPossible = 100;
-    const baseScore = 70;
-    const adjustedScore = Math.max(0, Math.min(100, baseScore + totalScore));
-    return { score: Math.round(adjustedScore), maxPossible, details };
-}
 export class SeoRulesEngine {
     rules;
     constructor(options = {}) {

package/dist/seo/rules/types.d.ts

@@ -134,12 +134,6 @@ export interface RuleContext {
     jsonLdTypes?: string[];
     url?: string;
     urlLength?: number;
-    hreflangTags?: Array<{
-        lang: string;
-        href: string;
-    }>;
-    ogLocale?: string;
-    alternateLanguages?: string[];
     titleMatchesH1?: boolean;
     urlHasUppercase?: boolean;
     urlHasSpecialChars?: boolean;
@@ -159,95 +153,6 @@ export interface RuleContext {
     htmlSize?: number;
     compressedSize?: number;
     isCompressed?: boolean;
-    isProductPage?: boolean;
-    productSchema?: {
-        name?: string;
-        image?: string | string[];
-        offers?: {
-            price?: number | string;
-            lowPrice?: number | string;
-            priceCurrency?: string;
-            availability?: string;
-            priceValidUntil?: string;
-            validFrom?: string;
-            validThrough?: string;
-        };
-        aggregateRating?: {
-            ratingValue?: number | string;
-            reviewCount?: number;
-            ratingCount?: number;
-        };
-        review?: unknown;
-        brand?: string | {
-            name?: string;
-        };
-        sku?: string;
-        gtin?: string;
-        gtin13?: string;
-        gtin14?: string;
-        gtin8?: string;
-        mpn?: string;
-    };
-    hasLocalBusinessSignals?: boolean;
-    localBusinessSchema?: {
-        '@type'?: string;
-        name?: string;
-        address?: {
-            streetAddress?: string;
-            addressLocality?: string;
-            addressRegion?: string;
-            postalCode?: string;
-            addressCountry?: string;
-        };
-        telephone?: string;
-        openingHoursSpecification?: unknown;
-        openingHours?: string | string[];
-        geo?: {
-            latitude?: number | string;
-            longitude?: number | string;
-        };
-        areaServed?: unknown;
-        priceRange?: string;
-    };
-    hasPhoneOnPage?: boolean;
-    hasAddressOnPage?: boolean;
-    lcpCandidate?: {
-        element?: string;
-        src?: string;
-        loading?: string;
-        fetchpriority?: string;
-    };
-    hasLcpPreload?: boolean;
-    webFonts?: Array<{
-        family?: string;
-        hasSwap?: boolean;
-        hasOptional?: boolean;
-        hasSizeAdjust?: boolean;
-        hasAscentOverride?: boolean;
-    }>;
-    renderBlockingStylesheets?: number;
-    renderBlockingScripts?: number;
-    hasAspectRatioCss?: boolean;
-    hasResponsiveImages?: boolean;
-    hasAdsWithoutReservedSpace?: boolean;
-    hasBannersWithoutMinHeight?: boolean;
-    hasInfiniteScroll?: boolean;
-    largeInlineScripts?: number;
-    inlineEventHandlers?: number;
-    hasHeavyAnimations?: boolean;
-    externalOrigins?: number;
-    hasCriticalResources?: boolean;
-    hasInlineCriticalCss?: boolean;
-    hasSitemapLink?: boolean;
-    sitemapUrl?: string;
-    robotsHasSitemap?: boolean;
-    isPaginatedPage?: boolean;
-    hasRelPrev?: boolean;
-    hasRelNext?: boolean;
-    passiveVoicePercentage?: number;
-    transitionWordPercentage?: number;
-    consecutiveSentenceStarts?: number;
-    complexWordPercentage?: number;
 }
 export interface RuleEvidence {
     found?: string | number | string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.28-next.c61382b",
+  "version": "1.0.28",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/seo/rules/crawl.d.ts

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

package/dist/seo/rules/crawl.js

@@ -1,307 +0,0 @@
-import { createResult } from './types.js';
-export const crawlRules = [
-    {
-        id: 'crawl-sitemap-reference',
-        name: 'Sitemap Reference',
-        category: 'technical',
-        severity: 'info',
-        description: 'Page should reference sitemap location',
-        check: (ctx) => {
-            if (ctx.hasSitemapLink) {
-                return createResult({ id: 'crawl-sitemap-reference', name: 'Sitemap Reference', category: 'technical', severity: 'info' }, 'pass', `Sitemap link found: ${ctx.sitemapUrl || 'referenced'}`);
-            }
-            if (ctx.robotsHasSitemap) {
-                return createResult({ id: 'crawl-sitemap-reference', name: 'Sitemap Reference', category: 'technical', severity: 'info' }, 'pass', 'Sitemap referenced in robots.txt');
-            }
-            return createResult({ id: 'crawl-sitemap-reference', name: 'Sitemap Reference', category: 'technical', severity: 'info' }, 'info', 'No sitemap reference found', {
-                recommendation: 'Add sitemap reference in robots.txt or HTML',
-                evidence: {
-                    expected: 'Sitemap: https://example.com/sitemap.xml in robots.txt',
-                    example: '<link rel="sitemap" type="application/xml" href="/sitemap.xml">',
-                    impact: 'Helps search engines discover all pages',
-                    learnMore: 'https://developers.google.com/search/docs/crawling-indexing/sitemaps/overview',
-                },
-            });
-        },
-    },
-    {
-        id: 'crawl-robots-noindex',
-        name: 'Robots Noindex',
-        category: 'technical',
-        severity: 'error',
-        description: 'Check if page is blocked from indexing',
-        check: (ctx) => {
-            if (!ctx.metaRobots)
-                return null;
-            const hasNoindex = ctx.metaRobots.some(r => r.toLowerCase().includes('noindex'));
-            if (hasNoindex) {
-                return createResult({ id: 'crawl-robots-noindex', name: 'Robots Noindex', category: 'technical', severity: 'error' }, 'fail', 'Page is set to noindex', {
-                    evidence: {
-                        found: ctx.metaRobots.join(', '),
-                        issue: 'This page will NOT appear in search results',
-                        impact: 'Remove noindex if this page should be indexed',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-robots-nofollow',
-        name: 'Robots Nofollow',
-        category: 'technical',
-        severity: 'warning',
-        description: 'Check if page links are blocked from following',
-        check: (ctx) => {
-            if (!ctx.metaRobots)
-                return null;
-            const hasNofollow = ctx.metaRobots.some(r => r.toLowerCase().includes('nofollow'));
-            if (hasNofollow) {
-                return createResult({ id: 'crawl-robots-nofollow', name: 'Robots Nofollow', category: 'technical', severity: 'warning' }, 'warn', 'Page has nofollow directive', {
-                    evidence: {
-                        found: ctx.metaRobots.join(', '),
-                        issue: 'Links on this page will not pass PageRank',
-                        impact: 'Internal pages should usually not have nofollow',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-robots-combined',
-        name: 'Robots Directives',
-        category: 'technical',
-        severity: 'info',
-        description: 'Review all robots meta directives',
-        check: (ctx) => {
-            if (!ctx.metaRobots || ctx.metaRobots.length === 0) {
-                return createResult({ id: 'crawl-robots-combined', name: 'Robots Directives', category: 'technical', severity: 'info' }, 'info', 'No robots meta tag (defaults to index, follow)', {
-                    recommendation: 'Explicitly set robots directives if needed',
-                    evidence: {
-                        expected: '<meta name="robots" content="index, follow">',
-                        impact: 'Default behavior allows full indexing and following',
-                    },
-                });
-            }
-            const directives = ctx.metaRobots.join(', ').toLowerCase();
-            const hasIndex = directives.includes('index') && !directives.includes('noindex');
-            const hasNoindex = directives.includes('noindex');
-            if (hasIndex && hasNoindex) {
-                return createResult({ id: 'crawl-robots-combined', name: 'Robots Directives', category: 'technical', severity: 'info' }, 'warn', 'Conflicting robots directives detected', {
-                    evidence: {
-                        found: ctx.metaRobots.join(', '),
-                        issue: 'Both index and noindex specified',
-                    },
-                });
-            }
-            return createResult({ id: 'crawl-robots-combined', name: 'Robots Directives', category: 'technical', severity: 'info' }, 'pass', `Robots: ${ctx.metaRobots.join(', ')}`);
-        },
-    },
-    {
-        id: 'crawl-x-robots-tag',
-        name: 'X-Robots-Tag Header',
-        category: 'technical',
-        severity: 'warning',
-        description: 'Check X-Robots-Tag HTTP header for indexing directives',
-        check: (ctx) => {
-            if (!ctx.responseHeaders)
-                return null;
-            const xRobotsTag = ctx.responseHeaders['x-robots-tag'] ||
-                ctx.responseHeaders['X-Robots-Tag'];
-            if (!xRobotsTag)
-                return null;
-            const tagValue = Array.isArray(xRobotsTag) ? xRobotsTag.join(', ') : xRobotsTag;
-            if (tagValue.toLowerCase().includes('noindex')) {
-                return createResult({ id: 'crawl-x-robots-tag', name: 'X-Robots-Tag Header', category: 'technical', severity: 'warning' }, 'fail', 'X-Robots-Tag contains noindex', {
-                    evidence: {
-                        found: tagValue,
-                        issue: 'HTTP header is blocking indexing',
-                        impact: 'Page will not appear in search results',
-                    },
-                });
-            }
-            return createResult({ id: 'crawl-x-robots-tag', name: 'X-Robots-Tag Header', category: 'technical', severity: 'warning' }, 'info', `X-Robots-Tag: ${tagValue}`);
-        },
-    },
-    {
-        id: 'crawl-canonical-present',
-        name: 'Canonical URL',
-        category: 'technical',
-        severity: 'warning',
-        description: 'Pages should have a canonical URL to prevent duplicate content',
-        check: (ctx) => {
-            if (!ctx.hasCanonical) {
-                return createResult({ id: 'crawl-canonical-present', name: 'Canonical URL', category: 'technical', severity: 'warning' }, 'warn', 'Missing canonical URL', {
-                    recommendation: 'Add a canonical link to prevent duplicate content issues',
-                    evidence: {
-                        expected: '<link rel="canonical" href="https://example.com/page">',
-                        impact: 'Without canonical, search engines may index multiple versions',
-                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/canonicalization',
-                    },
-                });
-            }
-            return createResult({ id: 'crawl-canonical-present', name: 'Canonical URL', category: 'technical', severity: 'warning' }, 'pass', `Canonical: ${ctx.canonicalUrl}`);
-        },
-    },
-    {
-        id: 'crawl-canonical-self',
-        name: 'Canonical Self-Reference',
-        category: 'technical',
-        severity: 'info',
-        description: 'Canonical should point to the current page or explicit alternate',
-        check: (ctx) => {
-            if (!ctx.hasCanonical || !ctx.canonicalUrl || !ctx.url)
-                return null;
-            const normalizeUrl = (url) => {
-                try {
-                    const u = new URL(url);
-                    let normalized = u.origin + u.pathname.replace(/\/$/, '');
-                    return normalized.toLowerCase();
-                }
-                catch {
-                    return url.toLowerCase().replace(/\/$/, '');
-                }
-            };
-            const currentNorm = normalizeUrl(ctx.url);
-            const canonicalNorm = normalizeUrl(ctx.canonicalUrl);
-            if (currentNorm !== canonicalNorm) {
-                return createResult({ id: 'crawl-canonical-self', name: 'Canonical Self-Reference', category: 'technical', severity: 'info' }, 'info', 'Canonical points to different URL', {
-                    evidence: {
-                        found: [`Current: ${ctx.url}`, `Canonical: ${ctx.canonicalUrl}`],
-                        issue: 'This page canonicalizes to a different URL',
-                        impact: 'Ensure this is intentional (e.g., www vs non-www consolidation)',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-canonical-absolute',
-        name: 'Canonical Absolute URL',
-        category: 'technical',
-        severity: 'warning',
-        description: 'Canonical URL should be absolute, not relative',
-        check: (ctx) => {
-            if (!ctx.canonicalUrl)
-                return null;
-            const isAbsolute = ctx.canonicalUrl.startsWith('http://') ||
-                ctx.canonicalUrl.startsWith('https://');
-            if (!isAbsolute) {
-                return createResult({ id: 'crawl-canonical-absolute', name: 'Canonical Absolute URL', category: 'technical', severity: 'warning' }, 'warn', 'Canonical URL is relative', {
-                    evidence: {
-                        found: ctx.canonicalUrl,
-                        expected: 'Absolute URL starting with https://',
-                        impact: 'Relative canonicals may be misinterpreted',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-canonical-https',
-        name: 'Canonical HTTPS',
-        category: 'technical',
-        severity: 'warning',
-        description: 'Canonical URL should use HTTPS',
-        check: (ctx) => {
-            if (!ctx.canonicalUrl)
-                return null;
-            if (ctx.canonicalUrl.startsWith('http://')) {
-                return createResult({ id: 'crawl-canonical-https', name: 'Canonical HTTPS', category: 'technical', severity: 'warning' }, 'warn', 'Canonical URL uses HTTP instead of HTTPS', {
-                    evidence: {
-                        found: ctx.canonicalUrl,
-                        expected: 'HTTPS canonical URL',
-                        impact: 'Google prefers HTTPS URLs for ranking',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-url-parameters',
-        name: 'URL Parameters',
-        category: 'technical',
-        severity: 'info',
-        description: 'URLs with tracking parameters should have proper canonical',
-        check: (ctx) => {
-            if (!ctx.url)
-                return null;
-            try {
-                const url = new URL(ctx.url);
-                const trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'fbclid', 'gclid', 'ref'];
-                const hasTracking = trackingParams.some(p => url.searchParams.has(p));
-                if (hasTracking && !ctx.hasCanonical) {
-                    return createResult({ id: 'crawl-url-parameters', name: 'URL Parameters', category: 'technical', severity: 'info' }, 'warn', 'URL has tracking parameters but no canonical', {
-                        recommendation: 'Add canonical pointing to clean URL without parameters',
-                        evidence: {
-                            found: url.search,
-                            expected: 'Canonical to base URL without tracking params',
-                            impact: 'Tracking parameters can cause duplicate content',
-                        },
-                    });
-                }
-            }
-            catch {
-            }
-            return null;
-        },
-    },
-    {
-        id: 'crawl-pagination-rel',
-        name: 'Pagination Links',
-        category: 'technical',
-        severity: 'info',
-        description: 'Paginated content should use proper rel attributes',
-        check: (ctx) => {
-            if (!ctx.isPaginatedPage)
-                return null;
-            const hasPrevNext = ctx.hasRelPrev || ctx.hasRelNext;
-            if (!hasPrevNext) {
-                return createResult({ id: 'crawl-pagination-rel', name: 'Pagination Links', category: 'technical', severity: 'info' }, 'info', 'Paginated page missing rel="prev/next" (deprecated but still useful)', {
-                    recommendation: 'Consider using rel="prev" and rel="next" for pagination',
-                    evidence: {
-                        example: '<link rel="prev" href="/page/1">\n<link rel="next" href="/page/3">',
-                        impact: 'Helps search engines understand pagination structure',
-                        learnMore: 'https://developers.google.com/search/docs/specialty/ecommerce/pagination-and-incremental-page-loading',
-                    },
-                });
-            }
-            return createResult({ id: 'crawl-pagination-rel', name: 'Pagination Links', category: 'technical', severity: 'info' }, 'pass', 'Pagination links present');
-        },
-    },
-    {
-        id: 'crawl-noarchive',
-        name: 'Cache Directives',
-        category: 'technical',
-        severity: 'info',
-        description: 'Check for noarchive and nocache directives',
-        check: (ctx) => {
-            if (!ctx.metaRobots)
-                return null;
-            const directives = ctx.metaRobots.join(', ').toLowerCase();
-            const hasNoarchive = directives.includes('noarchive');
-            const hasNocache = directives.includes('nocache');
-            const hasNosnippet = directives.includes('nosnippet');
-            const restrictions = [];
-            if (hasNoarchive)
-                restrictions.push('noarchive (no cached version)');
-            if (hasNocache)
-                restrictions.push('nocache (no cache)');
-            if (hasNosnippet)
-                restrictions.push('nosnippet (no search snippet)');
-            if (restrictions.length > 0) {
-                return createResult({ id: 'crawl-noarchive', name: 'Cache Directives', category: 'technical', severity: 'info' }, 'info', `Search restrictions: ${restrictions.join(', ')}`, {
-                    evidence: {
-                        found: restrictions,
-                        impact: 'These directives limit how search engines display your page',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-];

package/dist/seo/rules/cwv.d.ts

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