recker 1.0.27 → 1.0.28-next.9eb3868

package/dist/seo/rules/readability.js

@@ -0,0 +1,255 @@
+import { createResult } from './types.js';
+export const readabilityRules = [
+    {
+        id: 'readability-flesch-score',
+        name: 'Flesch Reading Ease',
+        category: 'content',
+        severity: 'info',
+        description: 'Content should be easy to read for the target audience',
+        check: (ctx) => {
+            if (ctx.fleschReadingEase === undefined)
+                return null;
+            const score = ctx.fleschReadingEase;
+            let level;
+            let status;
+            if (score >= 60) {
+                level = score >= 80 ? 'Easy' : score >= 70 ? 'Fairly Easy' : 'Standard';
+                status = 'pass';
+            }
+            else if (score >= 50) {
+                level = 'Fairly Difficult';
+                status = 'info';
+            }
+            else if (score >= 30) {
+                level = 'Difficult';
+                status = 'warn';
+            }
+            else {
+                level = 'Very Difficult';
+                status = 'warn';
+            }
+            if (status === 'warn') {
+                return createResult({ id: 'readability-flesch-score', name: 'Flesch Reading Ease', category: 'content', severity: 'info' }, status, `Flesch score: ${Math.round(score)} (${level})`, {
+                    recommendation: 'Simplify content for better readability',
+                    evidence: {
+                        found: Math.round(score),
+                        expected: '60-70 for general web content',
+                        impact: 'Difficult content has higher bounce rates',
+                        learnMore: 'https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-flesch-score', name: 'Flesch Reading Ease', category: 'content', severity: 'info' }, status, `Flesch score: ${Math.round(score)} (${level})`);
+        },
+    },
+    {
+        id: 'readability-sentence-length',
+        name: 'Sentence Length',
+        category: 'content',
+        severity: 'info',
+        description: 'Sentences should be concise for better readability',
+        check: (ctx) => {
+            if (ctx.avgSentenceLength === undefined)
+                return null;
+            const avgLength = ctx.avgSentenceLength;
+            if (avgLength > 30) {
+                return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'warn', `Average sentence length: ${Math.round(avgLength)} words (too long)`, {
+                    recommendation: 'Break long sentences into shorter ones',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '15-20 words per sentence ideal, max 25',
+                        impact: 'Long sentences are harder to understand on mobile',
+                    },
+                });
+            }
+            if (avgLength > 25) {
+                return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'info', `Average sentence length: ${Math.round(avgLength)} words (slightly long)`, {
+                    recommendation: 'Consider shortening some sentences',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '15-20 words per sentence',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'pass', `Average sentence length: ${Math.round(avgLength)} words`);
+        },
+    },
+    {
+        id: 'readability-paragraph-length',
+        name: 'Paragraph Length',
+        category: 'content',
+        severity: 'info',
+        description: 'Paragraphs should be short for web readability',
+        check: (ctx) => {
+            if (ctx.avgParagraphLength === undefined)
+                return null;
+            const avgLength = ctx.avgParagraphLength;
+            if (avgLength > 150) {
+                return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'warn', `Average paragraph length: ${Math.round(avgLength)} words (too long)`, {
+                    recommendation: 'Break paragraphs into smaller chunks',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '40-80 words per paragraph for web',
+                        impact: 'Wall of text reduces engagement and increases bounce rate',
+                    },
+                });
+            }
+            if (avgLength > 100) {
+                return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'info', `Average paragraph length: ${Math.round(avgLength)} words`, {
+                    recommendation: 'Consider breaking longer paragraphs',
+                });
+            }
+            return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'pass', `Average paragraph length: ${Math.round(avgLength)} words`);
+        },
+    },
+    {
+        id: 'readability-passive-voice',
+        name: 'Passive Voice',
+        category: 'content',
+        severity: 'info',
+        description: 'Limit passive voice for clearer writing',
+        check: (ctx) => {
+            if (ctx.passiveVoicePercentage === undefined)
+                return null;
+            const percentage = ctx.passiveVoicePercentage;
+            if (percentage > 20) {
+                return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'warn', `Passive voice: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Convert passive sentences to active voice',
+                    evidence: {
+                        found: `${Math.round(percentage)}%`,
+                        expected: 'Less than 10% passive voice',
+                        example: 'Instead of "The button was clicked by the user" → "The user clicked the button"',
+                    },
+                });
+            }
+            if (percentage > 15) {
+                return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'info', `Passive voice: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Consider reducing passive voice usage',
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'readability-transition-words',
+        name: 'Transition Words',
+        category: 'content',
+        severity: 'info',
+        description: 'Use transition words for better flow',
+        check: (ctx) => {
+            if (ctx.transitionWordPercentage === undefined)
+                return null;
+            const percentage = ctx.transitionWordPercentage;
+            if (percentage < 20) {
+                return createResult({ id: 'readability-transition-words', name: 'Transition Words', category: 'content', severity: 'info' }, 'info', `Transition words: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Add transition words for better content flow',
+                    evidence: {
+                        found: `${Math.round(percentage)}%`,
+                        expected: 'At least 30% of sentences',
+                        example: 'Words like: however, therefore, additionally, furthermore, for example',
+                        impact: 'Transition words improve comprehension and engagement',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-transition-words', name: 'Transition Words', category: 'content', severity: 'info' }, 'pass', `Transition words: ${Math.round(percentage)}% of sentences`);
+        },
+    },
+    {
+        id: 'readability-subheading-distribution',
+        name: 'Subheading Distribution',
+        category: 'content',
+        severity: 'info',
+        description: 'Break content with subheadings every 300 words',
+        check: (ctx) => {
+            if (!ctx.wordCount || !ctx.h2Count)
+                return null;
+            const wordsPerSubheading = ctx.wordCount / (ctx.h2Count + 1);
+            if (ctx.wordCount > 500 && wordsPerSubheading > 400) {
+                return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'warn', `${Math.round(wordsPerSubheading)} words between subheadings (too many)`, {
+                    recommendation: 'Add more H2/H3 subheadings to break up content',
+                    evidence: {
+                        found: `${ctx.h2Count} subheadings for ${ctx.wordCount} words`,
+                        expected: 'One subheading every 250-350 words',
+                        impact: 'Subheadings improve scannability and featured snippet eligibility',
+                    },
+                });
+            }
+            if (ctx.wordCount > 300 && wordsPerSubheading > 300) {
+                return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'info', `${Math.round(wordsPerSubheading)} words per section`, {
+                    recommendation: 'Consider adding more subheadings',
+                });
+            }
+            return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'pass', `${Math.round(wordsPerSubheading)} words per section (good)`);
+        },
+    },
+    {
+        id: 'readability-text-variety',
+        name: 'Text Variety',
+        category: 'content',
+        severity: 'info',
+        description: 'Use varied sentence structures and word choices',
+        check: (ctx) => {
+            if (ctx.consecutiveSentenceStarts === undefined)
+                return null;
+            if (ctx.consecutiveSentenceStarts > 3) {
+                return createResult({ id: 'readability-text-variety', name: 'Text Variety', category: 'content', severity: 'info' }, 'info', `${ctx.consecutiveSentenceStarts} consecutive sentences start similarly`, {
+                    recommendation: 'Vary sentence beginnings for better flow',
+                    evidence: {
+                        impact: 'Repetitive sentence structures feel monotonous',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'readability-word-complexity',
+        name: 'Word Complexity',
+        category: 'content',
+        severity: 'info',
+        description: 'Avoid overly complex vocabulary',
+        check: (ctx) => {
+            if (ctx.complexWordPercentage === undefined)
+                return null;
+            if (ctx.complexWordPercentage > 15) {
+                return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'warn', `Complex words: ${Math.round(ctx.complexWordPercentage)}%`, {
+                    recommendation: 'Use simpler vocabulary where possible',
+                    evidence: {
+                        found: `${Math.round(ctx.complexWordPercentage)}% words with 3+ syllables`,
+                        expected: 'Less than 10% complex words for general audience',
+                        impact: 'Complex vocabulary reduces comprehension',
+                    },
+                });
+            }
+            if (ctx.complexWordPercentage > 10) {
+                return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'info', `Complex words: ${Math.round(ctx.complexWordPercentage)}%`);
+            }
+            return null;
+        },
+    },
+    {
+        id: 'readability-list-usage',
+        name: 'List Usage',
+        category: 'content',
+        severity: 'info',
+        description: 'Use lists to improve scannability',
+        check: (ctx) => {
+            if (!ctx.wordCount || ctx.listCount === undefined)
+                return null;
+            if (ctx.wordCount > 500 && ctx.listCount === 0) {
+                return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'info', 'No lists found in long-form content', {
+                    recommendation: 'Consider using bullet points or numbered lists',
+                    evidence: {
+                        found: `${ctx.wordCount} words with 0 lists`,
+                        expected: 'At least 1 list per 500 words for long content',
+                        impact: 'Lists improve scannability and featured snippet eligibility',
+                    },
+                });
+            }
+            if (ctx.listCount > 0) {
+                return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'pass', `${ctx.listCount} list(s) found`);
+            }
+            return null;
+        },
+    },
+];

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

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

package/dist/seo/rules/schema.js

@@ -0,0 +1,54 @@
+import { createResult } from './types.js';
+export const schemaRules = [
+    {
+        id: 'json-ld-exists',
+        name: 'Structured Data',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Page should have JSON-LD structured data',
+        check: (ctx) => {
+            if (ctx.jsonLdCount === undefined)
+                return null;
+            if (ctx.jsonLdCount === 0) {
+                return createResult({ id: 'json-ld-exists', name: 'Structured Data', category: 'structured-data', severity: 'info' }, 'info', 'No JSON-LD structured data found', { recommendation: 'Add Schema.org structured data for rich snippets' });
+            }
+            const types = ctx.jsonLdTypes?.join(', ') || 'unknown';
+            return createResult({ id: 'json-ld-exists', name: 'Structured Data', category: 'structured-data', severity: 'info' }, 'pass', `${ctx.jsonLdCount} JSON-LD block(s) found`, { value: types });
+        },
+    },
+    {
+        id: 'schema-standard-types',
+        name: 'Schema Types',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Use standard Schema.org types',
+        check: (ctx) => {
+            if (!ctx.jsonLdTypes || ctx.jsonLdTypes.length === 0)
+                return null;
+            const recommended = [
+                'WebSite', 'WebPage', 'Article', 'Product', 'BreadcrumbList',
+                'Organization', 'Person', 'LocalBusiness', 'Recipe', 'Event',
+                'JobPosting', 'FAQPage', 'HowTo', 'VideoObject',
+                'SoftwareApplication', 'Review'
+            ];
+            const hasStandard = ctx.jsonLdTypes.some(t => recommended.includes(t));
+            if (!hasStandard) {
+                return createResult({ id: 'schema-standard-types', name: 'Schema Types', category: 'structured-data', severity: 'info' }, 'info', 'Using uncommon Schema.org types', { value: ctx.jsonLdTypes.join(', '), recommendation: `Consider using standard types like ${recommended.slice(0, 3).join(', ')}` });
+            }
+            return createResult({ id: 'schema-standard-types', name: 'Schema Types', category: 'structured-data', severity: 'info' }, 'pass', 'Using standard Schema.org types', { value: ctx.jsonLdTypes.join(', ') });
+        },
+    },
+    {
+        id: 'breadcrumbs-presence',
+        name: 'Breadcrumbs Presence',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Breadcrumbs improve navigation and SEO structure',
+        check: (ctx) => {
+            if (!ctx.hasBreadcrumbsHtml && !ctx.hasBreadcrumbsSchema) {
+                return createResult({ id: 'breadcrumbs-presence', name: 'Breadcrumbs Presence', category: 'structured-data', severity: 'info' }, 'info', 'No breadcrumbs found (HTML or Schema.org)', { recommendation: 'Add breadcrumbs using HTML and/or Schema.org BreadcrumbList' });
+            }
+            return null;
+        },
+    },
+];

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

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

package/dist/seo/rules/security.js

@@ -0,0 +1,147 @@
+import { createResult } from './types.js';
+export const securityRules = [
+    {
+        id: 'https-required',
+        name: 'HTTPS',
+        category: 'security',
+        severity: 'error',
+        description: 'Page must be served over HTTPS',
+        check: (ctx) => {
+            if (ctx.isHttps === false) {
+                return createResult({ id: 'https-required', name: 'HTTPS', category: 'security', severity: 'error' }, 'fail', 'Page is not served over HTTPS', { recommendation: 'Enable HTTPS for all pages' });
+            }
+            if (ctx.isHttps === true) {
+                return createResult({ id: 'https-required', name: 'HTTPS', category: 'security', severity: 'error' }, 'pass', 'Page is served over HTTPS');
+            }
+            return null;
+        },
+    },
+    {
+        id: 'mixed-content',
+        name: 'Mixed Content',
+        category: 'security',
+        severity: 'error',
+        description: 'HTTPS pages should not load HTTP resources',
+        check: (ctx) => {
+            if (ctx.hasMixedContent) {
+                return createResult({ id: 'mixed-content', name: 'Mixed Content', category: 'security', severity: 'error' }, 'fail', 'Page has mixed content (HTTP resources on HTTPS page)', { recommendation: 'Update all resources to use HTTPS' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'security-csp-exists',
+        name: 'Content Security Policy (CSP)',
+        category: 'security',
+        severity: 'warning',
+        description: 'Content Security Policy header should be present to mitigate XSS attacks.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const cspHeader = ctx.responseHeaders['content-security-policy'] || ctx.responseHeaders['Content-Security-Policy'];
+            if (!cspHeader) {
+                return createResult({ id: 'security-csp-exists', name: 'Content Security Policy', category: 'security', severity: 'warning' }, 'warn', 'Content-Security-Policy header is missing', { recommendation: 'Implement a strong Content-Security-Policy to prevent XSS attacks.' });
+            }
+            return createResult({ id: 'security-csp-exists', name: 'Content Security Policy', category: 'security', severity: 'warning' }, 'pass', 'Content-Security-Policy header is present');
+        },
+    },
+    {
+        id: 'security-xfo-exists',
+        name: 'X-Frame-Options',
+        category: 'security',
+        severity: 'warning',
+        description: 'X-Frame-Options header should be present to prevent clickjacking.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xfoHeader = ctx.responseHeaders['x-frame-options'] || ctx.responseHeaders['X-Frame-Options'];
+            if (!xfoHeader) {
+                return createResult({ id: 'security-xfo-exists', name: 'X-Frame-Options', category: 'security', severity: 'warning' }, 'warn', 'X-Frame-Options header is missing', { recommendation: 'Implement X-Frame-Options to prevent clickjacking attacks.' });
+            }
+            return createResult({ id: 'security-xfo-exists', name: 'X-Frame-Options', category: 'security', severity: 'warning' }, 'pass', `X-Frame-Options header is present: ${xfoHeader}`);
+        },
+    },
+    {
+        id: 'security-cors-config',
+        name: 'CORS Configuration',
+        category: 'security',
+        severity: 'warning',
+        description: 'Review Access-Control-Allow-Origin header for proper CORS configuration.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const acaoHeader = ctx.responseHeaders['access-control-allow-origin'] || ctx.responseHeaders['Access-Control-Allow-Origin'];
+            if (acaoHeader === '*') {
+                return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'warn', 'Access-Control-Allow-Origin is set to "*"', { recommendation: 'Avoid wildcard (*) in Access-Control-Allow-Origin for sensitive content. Specify allowed origins.' });
+            }
+            if (!acaoHeader) {
+                return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'info', 'Access-Control-Allow-Origin header is missing', { recommendation: 'Consider explicit CORS configuration if resources are consumed cross-origin.' });
+            }
+            return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'pass', `Access-Control-Allow-Origin: ${acaoHeader}`);
+        },
+    },
+    {
+        id: 'security-hsts-exists',
+        name: 'Strict-Transport-Security (HSTS)',
+        category: 'security',
+        severity: 'warning',
+        description: 'HSTS header forces secure connections and improves SEO indirectly.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const hstsHeader = ctx.responseHeaders['strict-transport-security'] || ctx.responseHeaders['Strict-Transport-Security'];
+            if (!hstsHeader) {
+                return createResult({ id: 'security-hsts-exists', name: 'HSTS Header', category: 'security', severity: 'warning' }, 'warn', 'Strict-Transport-Security header is missing', { recommendation: 'Implement HSTS to force secure connections and benefit SEO.' });
+            }
+            return createResult({ id: 'security-hsts-exists', name: 'HSTS Header', category: 'security', severity: 'warning' }, 'pass', `Strict-Transport-Security header is present: ${hstsHeader}`);
+        },
+    },
+    {
+        id: 'security-xcto-exists',
+        name: 'X-Content-Type-Options',
+        category: 'security',
+        severity: 'warning',
+        description: 'X-Content-Type-Options header prevents MIME sniffing attacks.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xctoHeader = ctx.responseHeaders['x-content-type-options'] || ctx.responseHeaders['X-Content-Type-Options'];
+            if (!xctoHeader) {
+                return createResult({ id: 'security-xcto-exists', name: 'X-Content-Type-Options', category: 'security', severity: 'warning' }, 'warn', 'X-Content-Type-Options header is missing', { recommendation: 'Implement X-Content-Type-Options: nosniff to prevent MIME sniffing.' });
+            }
+            return createResult({ id: 'security-xcto-exists', name: 'X-Content-Type-Options', category: 'security', severity: 'warning' }, 'pass', `X-Content-Type-Options header is present: ${xctoHeader}`);
+        },
+    },
+    {
+        id: 'security-rp-exists',
+        name: 'Referrer-Policy',
+        category: 'security',
+        severity: 'info',
+        description: 'Referrer-Policy controls how much referrer information is sent with requests.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const rpHeader = ctx.responseHeaders['referrer-policy'] || ctx.responseHeaders['Referrer-Policy'];
+            if (!rpHeader) {
+                return createResult({ id: 'security-rp-exists', name: 'Referrer-Policy', category: 'security', severity: 'info' }, 'info', 'Referrer-Policy header is missing', { recommendation: 'Consider implementing a Referrer-Policy for better privacy and control (e.g., strict-origin-when-cross-origin).' });
+            }
+            return createResult({ id: 'security-rp-exists', name: 'Referrer-Policy', category: 'security', severity: 'info' }, 'pass', `Referrer-Policy header is present: ${rpHeader}`);
+        },
+    },
+    {
+        id: 'security-pp-exists',
+        name: 'Permissions-Policy',
+        category: 'security',
+        severity: 'info',
+        description: 'Permissions-Policy controls browser features available to the page and iframes.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const ppHeader = ctx.responseHeaders['permissions-policy'] || ctx.responseHeaders['Permissions-Policy'];
+            if (!ppHeader) {
+                return createResult({ id: 'security-pp-exists', name: 'Permissions-Policy', category: 'security', severity: 'info' }, 'info', 'Permissions-Policy header is missing', { recommendation: 'Consider implementing a Permissions-Policy to disable unused browser features and enhance security (e.g., camera=(), microphone=()).' });
+            }
+            return createResult({ id: 'security-pp-exists', name: 'Permissions-Policy', category: 'security', severity: 'info' }, 'pass', `Permissions-Policy header is present: ${ppHeader}`);
+        },
+    },
+];

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

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