recker 1.0.43 → 1.0.44

package/dist/seo/formatter.d.ts

@@ -0,0 +1,16 @@
+import type { SeoReport, SeoCheckResult } from './types.js';
+export interface SeoFormatOptions {
+    showAll?: boolean;
+    showEvidence?: boolean;
+    maxIssuesPerCategory?: number;
+    showKeywords?: boolean;
+    showTiming?: boolean;
+    compact?: boolean;
+}
+export declare function gradeColor(grade: string): (text: string) => string;
+export declare function scoreColor(score: number): (text: string) => string;
+export declare function statusIcon(status: string): string;
+export declare function formatCheck(check: SeoCheckResult, showEvidence?: boolean): string[];
+export declare function formatSeoReport(report: SeoReport, url: string, options?: SeoFormatOptions): string;
+export declare function formatSeoReportJson(report: SeoReport, url: string): object;
+export declare function getScoringExplanation(): string;

package/dist/seo/formatter.js

@@ -0,0 +1,228 @@
+import colors from '../utils/colors.js';
+export function gradeColor(grade) {
+    if (grade === 'A')
+        return colors.green;
+    if (grade === 'B')
+        return colors.cyan;
+    if (grade === 'C')
+        return colors.yellow;
+    if (grade === 'D')
+        return colors.magenta;
+    return colors.red;
+}
+export function scoreColor(score) {
+    if (score >= 90)
+        return colors.green;
+    if (score >= 70)
+        return colors.yellow;
+    return colors.red;
+}
+export function statusIcon(status) {
+    switch (status) {
+        case 'pass': return colors.green('✔');
+        case 'warn': return colors.yellow('⚠');
+        case 'fail': return colors.red('✖');
+        case 'info': return colors.blue('ℹ');
+        default: return '•';
+    }
+}
+export function formatCheck(check, showEvidence = false) {
+    const lines = [];
+    const icon = statusIcon(check.status);
+    lines.push(` ${icon} ${check.message}`);
+    if (check.value !== undefined) {
+        lines.push(`    ${colors.gray('Value:')} ${check.value}`);
+    }
+    if (check.recommendation) {
+        lines.push(`    ${colors.gray('Fix:')} ${check.recommendation}`);
+    }
+    if (showEvidence && check.evidence) {
+        if (check.evidence.found) {
+            lines.push(`    ${colors.gray('Found:')} ${check.evidence.found}`);
+        }
+        if (check.evidence.expected) {
+            lines.push(`    ${colors.gray('Expected:')} ${check.evidence.expected}`);
+        }
+        if (check.evidence.impact) {
+            lines.push(`    ${colors.gray('Impact:')} ${check.evidence.impact}`);
+        }
+        if (check.evidence.learnMore) {
+            lines.push(`    ${colors.gray('Learn more:')} ${check.evidence.learnMore}`);
+        }
+    }
+    return lines;
+}
+export function formatSeoReport(report, url, options = {}) {
+    const { showAll = false, showEvidence = false, maxIssuesPerCategory = 10, showKeywords = true, showTiming = true, compact = false, } = options;
+    const lines = [];
+    const s = report.summary;
+    lines.push('');
+    lines.push(` ${colors.bold(colors.cyan('🔍 SEO Analysis Report'))}`);
+    lines.push(` ${colors.gray('URL:')} ${url}`);
+    if (showTiming && report.timing?.total) {
+        lines.push(` ${colors.gray('Time:')} ${report.timing.total}ms`);
+    }
+    const gColor = gradeColor(report.grade);
+    const sColor = scoreColor(report.score);
+    lines.push('');
+    lines.push(` ${colors.bold('Grade:')} ${gColor(colors.bold(report.grade))}  ${colors.bold('Score:')} ${sColor(report.score.toString())}/100`);
+    lines.push(colors.gray(' ──────────────────────────────────────────────────'));
+    lines.push('');
+    lines.push(` ${colors.bold('Summary')}`);
+    lines.push(` ${colors.green('✔ Passed:')} ${s.passed}   ${colors.yellow('⚠ Warnings:')} ${s.warnings}   ${colors.red('✖ Errors:')} ${s.errors}   ${colors.blue('ℹ Info:')} ${s.infos}`);
+    if (s.vitals) {
+        lines.push(` ${colors.gray('Words:')} ${s.vitals.wordCount} | ${colors.gray('Images:')} ${s.vitals.imageCount} | ${colors.gray('Links:')} ${s.vitals.linkCount}`);
+    }
+    if (!compact) {
+        if (report.title) {
+            const titleStatus = report.title.length >= 30 && report.title.length <= 60 ? colors.green('✔') : colors.yellow('⚠');
+            lines.push('');
+            lines.push(` ${colors.bold('Title:')} ${report.title.text} ${colors.gray(`(${report.title.length} chars)`)} ${titleStatus}`);
+        }
+        if (report.metaDescription) {
+            const desc = report.metaDescription.text.length > 80
+                ? report.metaDescription.text.slice(0, 77) + '...'
+                : report.metaDescription.text;
+            const descStatus = report.metaDescription.length >= 120 && report.metaDescription.length <= 160 ? colors.green('✔') : colors.yellow('⚠');
+            lines.push(` ${colors.bold('Description:')} ${desc} ${colors.gray(`(${report.metaDescription.length} chars)`)} ${descStatus}`);
+        }
+    }
+    if (s.topIssues && s.topIssues.length > 0) {
+        lines.push('');
+        lines.push(` ${colors.bold('Top Issues')}`);
+        s.topIssues.slice(0, 5).forEach(issue => {
+            const icon = issue.severity === 'error' ? colors.red('✖') : colors.yellow('⚠');
+            lines.push(` ${icon} ${colors.bold(issue.name)}: ${issue.message}`);
+        });
+    }
+    if (showKeywords && report.keywords && report.keywords.topKeywords.length > 0) {
+        lines.push('');
+        lines.push(` ${colors.bold('Top Keywords')}`);
+        const kws = report.keywords.topKeywords.slice(0, 8).map(k => `${k.word} (${k.count})`).join(', ');
+        lines.push(` ${colors.gray(kws)}`);
+    }
+    if (!compact && report.openGraph && Object.values(report.openGraph).some(v => v)) {
+        lines.push('');
+        lines.push(` ${colors.bold('OpenGraph')}`);
+        if (report.openGraph.title)
+            lines.push(`   ${colors.cyan('og:title')}       ${report.openGraph.title}`);
+        if (report.openGraph.description) {
+            const ogDesc = report.openGraph.description.length > 60
+                ? report.openGraph.description.slice(0, 57) + '...'
+                : report.openGraph.description;
+            lines.push(`   ${colors.cyan('og:description')} ${ogDesc}`);
+        }
+        if (report.openGraph.image)
+            lines.push(`   ${colors.cyan('og:image')}       ${report.openGraph.image}`);
+    }
+    const categories = [...new Set(report.checks.map(c => c.category))].filter(Boolean);
+    categories.forEach(cat => {
+        const catChecks = report.checks.filter(c => c.category === cat);
+        const issues = catChecks.filter(c => c.status !== 'pass' && c.status !== 'info');
+        const passed = catChecks.filter(c => c.status === 'pass');
+        if (issues.length === 0 && !showAll)
+            return;
+        lines.push('');
+        lines.push(` ${colors.bold(cat.toUpperCase())} ${colors.gray(`(${passed.length}/${catChecks.length} passed)`)}`);
+        const checksToShow = showAll ? catChecks : issues;
+        checksToShow.slice(0, maxIssuesPerCategory).forEach(check => {
+            formatCheck(check, showEvidence).forEach(line => lines.push(line));
+        });
+        if (checksToShow.length > maxIssuesPerCategory) {
+            lines.push(`   ${colors.gray(`... and ${checksToShow.length - maxIssuesPerCategory} more`)}`);
+        }
+    });
+    if (!compact && s.quickWins && s.quickWins.length > 0) {
+        lines.push('');
+        lines.push(` ${colors.bold('Quick Wins')}`);
+        s.quickWins.slice(0, 5).forEach(win => {
+            lines.push(` ${colors.green('→')} ${win}`);
+        });
+    }
+    if (!compact && s.completeness) {
+        lines.push('');
+        lines.push(` ${colors.bold('Completeness Scores')}`);
+        const comp = s.completeness;
+        const bar = (val) => {
+            const filled = Math.round(val / 10);
+            const empty = 10 - filled;
+            const color = val >= 80 ? colors.green : val >= 50 ? colors.yellow : colors.red;
+            return color('█'.repeat(filled)) + colors.gray('░'.repeat(empty));
+        };
+        lines.push(`   Meta:      ${bar(comp.meta)} ${comp.meta}%`);
+        lines.push(`   Social:    ${bar(comp.social)} ${comp.social}%`);
+        lines.push(`   Technical: ${bar(comp.technical)} ${comp.technical}%`);
+        lines.push(`   Content:   ${bar(comp.content)} ${comp.content}%`);
+        lines.push(`   Images:    ${bar(comp.images)} ${comp.images}%`);
+        lines.push(`   Links:     ${bar(comp.links)} ${comp.links}%`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatSeoReportJson(report, url) {
+    return {
+        url,
+        analyzedAt: new Date().toISOString(),
+        timing: report.timing,
+        score: report.score,
+        grade: report.grade,
+        title: report.title,
+        metaDescription: report.metaDescription,
+        content: report.content,
+        headings: report.headings,
+        links: report.links,
+        images: report.images,
+        openGraph: report.openGraph,
+        twitterCard: report.twitterCard,
+        social: report.social,
+        structuredData: report.structuredData,
+        technical: report.technical,
+        keywords: report.keywords,
+        checks: report.checks,
+        summary: {
+            total: report.checks.length,
+            passed: report.checks.filter(c => c.status === 'pass').length,
+            warnings: report.checks.filter(c => c.status === 'warn').length,
+            errors: report.checks.filter(c => c.status === 'fail').length,
+            info: report.checks.filter(c => c.status === 'info').length,
+            passRate: report.summary.passRate,
+            completeness: report.summary.completeness,
+            quickWins: report.summary.quickWins,
+        },
+    };
+}
+export function getScoringExplanation() {
+    return `
+SEO Score Calculation
+=====================
+
+The SEO score is calculated as a weighted average of all rule checks:
+
+  - Pass:    100 points (rule fully satisfied)
+  - Warning:  50 points (partial compliance)
+  - Fail:      0 points (rule violated)
+  - Info:    N/A (informational, doesn't affect score)
+
+Final Score = (Sum of rule points) / (Number of scored rules) × 100
+
+Grade Scale:
+  A: 90-100  Excellent SEO
+  B: 80-89   Good SEO
+  C: 70-79   Needs improvement
+  D: 60-69   Poor SEO
+  F: 0-59    Critical issues
+
+Category Weights:
+  All categories are weighted equally. Each rule within a category
+  contributes equally to the final score.
+
+Completeness Scores:
+  Each category has a completeness score (0-100%) based on:
+  - Meta: title, description, canonical, viewport, charset
+  - Social: og:title, og:description, og:image, og:url, twitter:card, etc.
+  - Technical: canonical, viewport, charset, lang, robots
+  - Content: word count, paragraphs, lists, emphasis
+  - Images: alt text, lazy loading, dimensions, modern formats
+  - Links: internal, external, no broken links, text content
+`;
+}

package/dist/seo/index.d.ts

@@ -1,4 +1,6 @@
 export { SeoAnalyzer, analyzeSeo } from './analyzer.js';
+export { formatSeoReport, formatSeoReportJson, getScoringExplanation, gradeColor, scoreColor, statusIcon, formatCheck, } from './formatter.js';
+export type { SeoFormatOptions } from './formatter.js';
 export { SeoSpider, seoSpider } from './seo-spider.js';
 export type { SeoSpiderOptions, SeoPageResult, SiteWideIssue, SeoSpiderResult, } from './seo-spider.js';
 export { SeoRulesEngine, createRulesEngine, SEO_THRESHOLDS, ALL_SEO_RULES, } from './rules/index.js';

package/dist/seo/index.js

@@ -1,3 +1,4 @@
 export { SeoAnalyzer, analyzeSeo } from './analyzer.js';
+export { formatSeoReport, formatSeoReportJson, getScoringExplanation, gradeColor, scoreColor, statusIcon, formatCheck, } from './formatter.js';
 export { SeoSpider, seoSpider } from './seo-spider.js';
 export { SeoRulesEngine, createRulesEngine, SEO_THRESHOLDS, ALL_SEO_RULES, } from './rules/index.js';

package/dist/seo/keywords.d.ts

@@ -0,0 +1,16 @@
+export interface KeywordItem {
+    word: string;
+    count: number;
+    density: number;
+}
+export interface KeywordCloud {
+    totalWords: number;
+    uniqueWords: number;
+    topKeywords: KeywordItem[];
+}
+export declare function generateKeywordCloud(sources: {
+    visibleText: string;
+    title?: string;
+    description?: string;
+    keywords?: string;
+}, limit?: number): KeywordCloud;

package/dist/seo/keywords.js

@@ -0,0 +1,55 @@
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'and', 'or', 'but', 'if', 'because', 'as', 'what',
+    'when', 'where', 'how', 'who', 'which', 'this', 'that', 'these', 'those',
+    'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+    'do', 'does', 'did', 'at', 'by', 'for', 'from', 'in', 'into', 'of', 'off',
+    'on', 'onto', 'out', 'over', 'to', 'up', 'with', 'about', 'some', 'any',
+    'it', 'its', 'you', 'your', 'we', 'our', 'they', 'their', 'he', 'his',
+    'she', 'her', 'i', 'my', 'me', 'not', 'no', 'can', 'will', 'just',
+    'o', 'a', 'os', 'as', 'um', 'uma', 'uns', 'umas', 'e', 'ou', 'mas', 'se',
+    'porque', 'como', 'quando', 'onde', 'que', 'quem', 'qual', 'este', 'esta',
+    'esse', 'essa', 'aquele', 'aquela', 'isto', 'isso', 'aquilo', 'é', 'são',
+    'foi', 'foram', 'ser', 'sendo', 'ter', 'tem', 'tinha', 'fazer', 'faz', 'fez',
+    'em', 'no', 'na', 'nos', 'nas', 'de', 'do', 'da', 'dos', 'das', 'por',
+    'para', 'com', 'sem', 'sobre', 'sob', 'ante', 'até', 'ao', 'aos',
+    'eu', 'meu', 'minha', 'você', 'seu', 'sua', 'nós', 'nosso', 'nossa',
+    'eles', 'elas', 'dele', 'dela', 'não', 'sim', 'muito', 'muita', 'mais',
+    'pelo', 'pela', 'pelos', 'pelas', 'num', 'numa', 'está', 'estão'
+]);
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s\u00C0-\u00FF]/g, '')
+        .split(/\s+/)
+        .filter(w => w.length > 2)
+        .filter(w => !STOP_WORDS.has(w));
+}
+export function generateKeywordCloud(sources, limit = 20) {
+    const combinedText = [
+        sources.title,
+        sources.title,
+        sources.description,
+        sources.keywords,
+        sources.keywords,
+        sources.visibleText
+    ].filter(Boolean).join(' ');
+    const tokens = tokenize(combinedText);
+    const totalWords = tokens.length;
+    const frequency = {};
+    for (const token of tokens) {
+        frequency[token] = (frequency[token] || 0) + 1;
+    }
+    const sortedKeywords = Object.entries(frequency)
+        .map(([word, count]) => ({
+        word,
+        count,
+        density: totalWords > 0 ? parseFloat(((count / totalWords) * 100).toFixed(2)) : 0
+    }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, limit);
+    return {
+        totalWords,
+        uniqueWords: Object.keys(frequency).length,
+        topKeywords: sortedKeywords
+    };
+}