@crawlith/core 0.1.1 → 0.1.2

package/dist/report/export.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import chalk from '../utils/chalk.js';
+import { generateHtml, } from './html.js';
+import { renderCrawlMarkdown, renderCrawlCsvNodes, renderCrawlCsvEdges } from './crawlExport.js';
+import { renderAnalysisHtml, renderAnalysisMarkdown, renderAnalysisCsv } from '../analysis/analyze.js';
+export function parseExportFormats(exportOption) {
+    if (exportOption === undefined || exportOption === false)
+        return [];
+    if (exportOption === true)
+        return ['json'];
+    return exportOption.split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
+}
+export async function runCrawlExports(formats, outputDir, url, graphData, metrics, graphObj, report) {
+    if (formats.length === 0)
+        return;
+    await fs.mkdir(outputDir, { recursive: true });
+    if (formats.includes('json')) {
+        await fs.writeFile(path.join(outputDir, 'graph.json'), JSON.stringify(graphData, null, 2));
+        await fs.writeFile(path.join(outputDir, 'metrics.json'), JSON.stringify(metrics, null, 2));
+        if (report) {
+            await fs.writeFile(path.join(outputDir, 'report.json'), JSON.stringify(report, null, 2));
+        }
+        console.log(chalk.green(`JSON exports saved to ${outputDir} (graph.json, metrics.json${report ? ', report.json' : ''})`));
+    }
+    if (formats.includes('html')) {
+        const html = generateHtml(graphData, metrics);
+        await fs.writeFile(path.join(outputDir, 'graph.html'), html);
+        console.log(chalk.green(`HTML report saved to ${path.join(outputDir, 'graph.html')}`));
+    }
+    if (formats.includes('visualize')) {
+        const CrawlHtml = generateHtml(graphData, metrics);
+        await fs.writeFile(path.join(outputDir, 'crawl.html'), CrawlHtml);
+        console.log(chalk.green(`Visualization saved to ${path.join(outputDir, 'crawl.html')}`));
+    }
+    if (formats.includes('csv')) {
+        await fs.writeFile(path.join(outputDir, 'nodes.csv'), renderCrawlCsvNodes(graphData));
+        await fs.writeFile(path.join(outputDir, 'edges.csv'), renderCrawlCsvEdges(graphData));
+        console.log(chalk.green(`CSV exports saved to ${outputDir} (nodes.csv, edges.csv)`));
+    }
+    if (formats.includes('markdown')) {
+        const md = renderCrawlMarkdown(url, graphData, metrics, graphObj);
+        await fs.writeFile(path.join(outputDir, 'summary.md'), md);
+        console.log(chalk.green(`Markdown summary saved to ${path.join(outputDir, 'summary.md')}`));
+        if (report && report.plugins) {
+            for (const [pluginName, pluginData] of Object.entries(report.plugins)) {
+                // Ensure Exporter remains generic without plugin-specific logical branches
+                const serialized = JSON.stringify(pluginData, null, 2);
+                const pluginMd = `\n## Plugin: ${pluginName}\n\n\`\`\`json\n${serialized}\n\`\`\`\n`;
+                await fs.appendFile(path.join(outputDir, 'summary.md'), pluginMd);
+            }
+        }
+    }
+}
+export async function runAnalysisExports(formats, outputDir, result, isLive) {
+    if (formats.length === 0)
+        return;
+    await fs.mkdir(outputDir, { recursive: true });
+    if (formats.includes('json')) {
+        await fs.writeFile(path.join(outputDir, 'analysis.json'), JSON.stringify(result, null, 2));
+        console.log(chalk.green(`JSON export saved to ${path.join(outputDir, 'analysis.json')}`));
+    }
+    if (formats.includes('html')) {
+        const html = renderAnalysisHtml(result);
+        const filename = isLive ? 'page.html' : 'analysis.html';
+        await fs.writeFile(path.join(outputDir, filename), html, 'utf-8');
+        console.log(chalk.green(`HTML report saved to ${path.join(outputDir, filename)}`));
+    }
+    if (formats.includes('markdown')) {
+        const markdown = renderAnalysisMarkdown(result);
+        const filename = isLive ? 'analysis.md' : 'analysis.md';
+        await fs.writeFile(path.join(outputDir, filename), markdown, 'utf-8');
+        console.log(chalk.green(`Markdown report saved to ${path.join(outputDir, filename)}`));
+    }
+    if (formats.includes('csv')) {
+        const csv = renderAnalysisCsv(result);
+        const filename = isLive ? 'analysis.csv' : 'analysis.csv';
+        await fs.writeFile(path.join(outputDir, filename), csv, 'utf-8');
+        console.log(chalk.green(`CSV export saved to ${path.join(outputDir, filename)}`));
+    }
+}

package/dist/report/insight.d.ts

@@ -0,0 +1,27 @@
+import { Graph, Metrics } from '@crawlith/core';
+export interface CrawlInsightReport {
+    pages: number;
+    fetchedPages?: number;
+    summary: {
+        crawlDepth: number;
+        internalLinks: number;
+        externalLinks: number;
+    };
+    health?: {
+        score: number;
+        status: string;
+        weightedPenalties: any;
+    };
+    issues?: any;
+    topAuthorityPages: {
+        url: string;
+        score: number;
+    }[];
+}
+export declare function buildCrawlInsightReport(graph: Graph, metrics: Metrics, healthData?: {
+    health: any;
+    issues: any;
+}): CrawlInsightReport;
+export declare function renderInsightOutput(report: CrawlInsightReport, snapshotId: number): string;
+export declare function renderScoreBreakdown(health: any): string;
+export declare function hasCriticalIssues(report: CrawlInsightReport): boolean;

package/dist/report/insight.js

@@ -0,0 +1,103 @@
+export function buildCrawlInsightReport(graph, metrics, healthData) {
+    return {
+        pages: metrics.totalPages,
+        fetchedPages: metrics.sessionStats?.pagesFetched,
+        health: healthData?.health,
+        issues: healthData?.issues,
+        summary: {
+            crawlDepth: metrics.maxDepthFound,
+            internalLinks: metrics.totalEdges,
+            externalLinks: healthData?.issues?.externalLinks || 0
+        },
+        topAuthorityPages: metrics.topAuthorityPages.map(p => ({ url: p.url, score: p.authority }))
+    };
+}
+export function renderInsightOutput(report, snapshotId) {
+    const lines = [];
+    // Header
+    lines.push(`CRAWLITH — Crawl`);
+    lines.push('');
+    lines.push(`# ${snapshotId}`);
+    lines.push('');
+    if (report.fetchedPages !== undefined) {
+        if (report.fetchedPages === report.pages) {
+            lines.push(`${report.pages} pages crawled`);
+        }
+        else {
+            lines.push(`${report.fetchedPages} pages fetched / ${report.pages} discovered`);
+        }
+    }
+    else {
+        lines.push(`${report.pages} pages crawled`);
+    }
+    lines.push('');
+    // Health Score if available
+    if (report.health) {
+        lines.push(`Score: ${report.health.score} (${report.health.status})`);
+        lines.push('');
+    }
+    // ===== Critical =====
+    if (report.issues) {
+        const critical = [];
+        const addLine = (arr, condition, text) => condition && arr.push(text);
+        addLine(critical, report.issues.orphanPages > 0, `${report.issues.orphanPages} orphan pages`);
+        addLine(critical, report.issues.redirectChains > 0, `${report.issues.redirectChains} redirect chains`);
+        addLine(critical, report.issues.brokenInternalLinks > 0, `${report.issues.brokenInternalLinks} broken internal links`);
+        addLine(critical, report.issues.duplicateClusters > 0, `${report.issues.duplicateClusters} near-duplicate clusters`);
+        addLine(critical, report.issues.canonicalConflicts > 0, `${report.issues.canonicalConflicts} canonical conflicts`);
+        addLine(critical, report.issues.accidentalNoindex > 0, `${report.issues.accidentalNoindex} pages accidentally noindexed`);
+        addLine(critical, report.issues.blockedByRobots > 0, `${report.issues.blockedByRobots} pages blocked by robots.txt`);
+        if (critical.length > 0) {
+            lines.push(`Critical`);
+            for (const c of critical)
+                lines.push(`  • ${c}`);
+            lines.push('');
+        }
+        // ===== Warnings =====
+        const warnings = [];
+        addLine(warnings, report.issues.missingH1 > 0, `${report.issues.missingH1} pages missing H1`);
+        addLine(warnings, report.issues.thinContent > 0, `${report.issues.thinContent} thin content pages`);
+        addLine(warnings, report.issues.excessiveInternalLinkCount > 0, `${report.issues.excessiveInternalLinkCount} pages with excessive links`);
+        addLine(warnings, report.issues.imageAltMissing > 0, `${report.issues.imageAltMissing} pages missing image alt`);
+        if (warnings.length > 0) {
+            lines.push(`Warnings`);
+            for (const w of warnings)
+                lines.push(`  • ${w}`);
+            lines.push('');
+        }
+    }
+    // ===== Structure =====
+    lines.push(`Structure`);
+    lines.push(`  Depth Reached     ${report.summary.crawlDepth}`);
+    lines.push(`  Internal Links    ${report.summary.internalLinks}`);
+    lines.push(`  External Links    ${report.summary.externalLinks}`);
+    lines.push('');
+    // ===== Authority =====
+    if (report.topAuthorityPages.length > 0) {
+        lines.push(`Top Authority`);
+        for (const page of report.topAuthorityPages.slice(0, 10)) {
+            lines.push(`  ${page.url}   ${page.score.toFixed(3)}`);
+        }
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function renderScoreBreakdown(health) {
+    return [
+        'Health Score Breakdown',
+        `weights: ${JSON.stringify(health.weights)}`,
+        `penalties: ${JSON.stringify(health.weightedPenalties)}`
+    ].join('\n');
+}
+export function hasCriticalIssues(report) {
+    if (!report.issues)
+        return false;
+    const { issues } = report;
+    return (issues.orphanPages > 0 ||
+        issues.brokenInternalLinks > 0 ||
+        issues.redirectChains > 0 ||
+        issues.duplicateClusters > 0 ||
+        issues.canonicalConflicts > 0 ||
+        issues.accidentalNoindex > 0 ||
+        issues.blockedByRobots > 0);
+}

package/dist/scoring/health.d.ts

@@ -1,10 +1,4 @@
 import { Graph } from '../graph/graph.js';
-import { Metrics } from '../graph/metrics.js';
-export declare const THIN_CONTENT_THRESHOLD = 300;
-export declare const LOW_INTERNAL_LINK_THRESHOLD = 2;
-export declare const EXCESSIVE_INTERNAL_LINK_THRESHOLD = 150;
-export declare const HIGH_EXTERNAL_LINK_RATIO_THRESHOLD = 0.6;
-export declare const OPPORTUNITY_AUTHORITY_THRESHOLD = 0.8;
 export interface HealthScoreWeights {
     orphans: number;
     brokenLinks: number;
@@ -17,8 +11,8 @@ export interface HealthScoreWeights {
     lowInternalLinks: number;
     excessiveLinks: number;
     blockedByRobots: number;
+    crawlTraps: number;
 }
-export declare const DEFAULT_HEALTH_WEIGHTS: HealthScoreWeights;
 export interface CrawlIssueCounts {
     orphanPages: number;
     brokenInternalLinks: number;
@@ -38,13 +32,25 @@ export interface CrawlIssueCounts {
     underlinkedHighAuthorityPages: number;
     externalLinks: number;
     blockedByRobots: number;
+    crawlTraps: number;
 }
 export interface HealthScoreBreakdown {
     score: number;
     status: string;
-    weightedPenalties: Record<keyof HealthScoreWeights, number>;
+    weightedPenalties: Record<string, number>;
     weights: HealthScoreWeights;
 }
-export declare function healthStatusLabel(score: number, hasCritical?: boolean): string;
-export declare function calculateHealthScore(totalPages: number, issues: Pick<CrawlIssueCounts, 'orphanPages' | 'brokenInternalLinks' | 'redirectChains' | 'duplicateClusters' | 'thinContent' | 'missingH1' | 'accidentalNoindex' | 'canonicalConflicts' | 'lowInternalLinkCount' | 'excessiveInternalLinkCount' | 'blockedByRobots'>, weights?: HealthScoreWeights): HealthScoreBreakdown;
-export declare function collectCrawlIssues(graph: Graph, metrics: Metrics): CrawlIssueCounts;
+export declare const THIN_CONTENT_THRESHOLD = 200;
+export declare const LOW_INTERNAL_LINK_THRESHOLD = 2;
+export declare const EXCESSIVE_INTERNAL_LINK_THRESHOLD = 150;
+export declare const HIGH_EXTERNAL_LINK_RATIO_THRESHOLD = 0.6;
+export declare const OPPORTUNITY_AUTHORITY_THRESHOLD = 0.8;
+export declare const DEFAULT_HEALTH_WEIGHTS: HealthScoreWeights;
+export declare class HealthService {
+    calculateHealthScore(totalPages: number, issues: Pick<CrawlIssueCounts, 'orphanPages' | 'brokenInternalLinks' | 'redirectChains' | 'duplicateClusters' | 'thinContent' | 'missingH1' | 'accidentalNoindex' | 'canonicalConflicts' | 'lowInternalLinkCount' | 'excessiveInternalLinkCount' | 'blockedByRobots' | 'crawlTraps'>, weights?: HealthScoreWeights): HealthScoreBreakdown;
+    collectCrawlIssues(graph: Graph, metrics: any, rootOrigin?: string): CrawlIssueCounts;
+    private clamp;
+    private healthStatusLabel;
+}
+export declare const calculateHealthScore: (totalPages: number, issues: Pick<CrawlIssueCounts, "orphanPages" | "brokenInternalLinks" | "redirectChains" | "duplicateClusters" | "thinContent" | "missingH1" | "accidentalNoindex" | "canonicalConflicts" | "lowInternalLinkCount" | "excessiveInternalLinkCount" | "blockedByRobots" | "crawlTraps">, weights?: HealthScoreWeights) => HealthScoreBreakdown;
+export declare const healthStatusLabel: (score: number, hasCritical?: boolean) => "Needs Attention" | "Excellent" | "Good" | "Critical";

package/dist/scoring/health.js

@@ -2,7 +2,8 @@ import { analyzeContent } from '../analysis/content.js';
 import { analyzeH1 } from '../analysis/seo.js';
 import { analyzeImageAlts } from '../analysis/images.js';
 import { analyzeLinks } from '../analysis/links.js';
-export const THIN_CONTENT_THRESHOLD = 300;
+import { UrlUtil } from '../crawler/normalize.js';
+export const THIN_CONTENT_THRESHOLD = 200;
 export const LOW_INTERNAL_LINK_THRESHOLD = 2;
 export const EXCESSIVE_INTERNAL_LINK_THRESHOLD = 150;
 export const HIGH_EXTERNAL_LINK_RATIO_THRESHOLD = 0.6;
@@ -18,12 +19,188 @@ export const DEFAULT_HEALTH_WEIGHTS = {
     canonicalConflicts: 10,
     lowInternalLinks: 10,
     excessiveLinks: 5,
-    blockedByRobots: 100
+    blockedByRobots: 100,
+    crawlTraps: 50
 };
-function clamp(value, min, max) {
-    return Math.min(max, Math.max(min, value));
+export class HealthService {
+    calculateHealthScore(totalPages, issues, weights = DEFAULT_HEALTH_WEIGHTS) {
+        const safePages = Math.max(totalPages, 1);
+        const weightedPenalties = {
+            orphans: this.clamp(((issues.orphanPages || 0) / safePages) * weights.orphans, 0, weights.orphans),
+            brokenLinks: this.clamp(((issues.brokenInternalLinks || 0) / safePages) * weights.brokenLinks, 0, weights.brokenLinks),
+            redirectChains: this.clamp(((issues.redirectChains || 0) / safePages) * weights.redirectChains, 0, weights.redirectChains),
+            duplicateClusters: this.clamp(((issues.duplicateClusters || 0) / safePages) * weights.duplicateClusters, 0, weights.duplicateClusters),
+            thinContent: this.clamp(((issues.thinContent || 0) / safePages) * weights.thinContent, 0, weights.thinContent),
+            missingH1: this.clamp(((issues.missingH1 || 0) / safePages) * weights.missingH1, 0, weights.missingH1),
+            noindexMisuse: this.clamp(((issues.accidentalNoindex || 0) / safePages) * weights.noindexMisuse, 0, weights.noindexMisuse),
+            canonicalConflicts: this.clamp(((issues.canonicalConflicts || 0) / safePages) * weights.canonicalConflicts, 0, weights.canonicalConflicts),
+            lowInternalLinks: this.clamp(((issues.lowInternalLinkCount || 0) / safePages) * weights.lowInternalLinks, 0, weights.lowInternalLinks),
+            excessiveLinks: this.clamp(((issues.excessiveInternalLinkCount || 0) / safePages) * weights.excessiveLinks, 0, weights.excessiveLinks),
+            blockedByRobots: this.clamp(((issues.blockedByRobots || 0) / safePages) * weights.blockedByRobots, 0, weights.blockedByRobots),
+            crawlTraps: this.clamp(((issues.crawlTraps || 0) / safePages) * weights.crawlTraps, 0, weights.crawlTraps)
+        };
+        const totalPenalty = Object.values(weightedPenalties).reduce((sum, value) => sum + value, 0);
+        const score = Number(this.clamp(100 - totalPenalty, 0, 100).toFixed(1));
+        const hasCritical = ((issues.orphanPages || 0) > 0 ||
+            (issues.brokenInternalLinks || 0) > 0 ||
+            (issues.redirectChains || 0) > 0 ||
+            (issues.duplicateClusters || 0) > 0 ||
+            (issues.canonicalConflicts || 0) > 0 ||
+            (issues.accidentalNoindex || 0) > 0 ||
+            (issues.blockedByRobots || 0) > 0);
+        return {
+            score,
+            status: this.healthStatusLabel(score, hasCritical),
+            weightedPenalties,
+            weights
+        };
+    }
+    collectCrawlIssues(graph, metrics, rootOrigin = '') {
+        const nodes = graph.getNodes();
+        let brokenInternalLinks = 0;
+        let redirectChains = 0;
+        let canonicalConflicts = 0;
+        let accidentalNoindex = 0;
+        let missingH1 = 0;
+        let thinContent = 0;
+        let highExternalLinkRatio = 0;
+        let imageAltMissing = 0;
+        let lowInternalLinkCount = 0;
+        let excessiveInternalLinkCount = 0;
+        let strongPagesUnderLinking = 0;
+        let nearAuthorityThreshold = 0;
+        let underlinkedHighAuthorityPages = 0;
+        let externalLinks = 0;
+        let blockedByRobots = 0;
+        let crawlTraps = 0;
+        for (const node of nodes) {
+            if (!node.isInternal) {
+                continue;
+            }
+            if (node.crawlStatus === 'blocked' || node.crawlStatus === 'blocked_by_robots') {
+                blockedByRobots += 1;
+            }
+            if (node.crawlTrapFlag) {
+                crawlTraps += 1;
+            }
+            const isConfirmedError = node.status >= 400 || (node.status === 0 && (node.crawlStatus === 'network_error' || node.crawlStatus === 'failed_after_retries' || node.securityError || node.crawlStatus === 'fetched_error'));
+            if (isConfirmedError) {
+                brokenInternalLinks += 1;
+            }
+            if (node.brokenLinks) {
+                const actualBreaks = node.brokenLinks.filter(url => {
+                    const target = graph.nodes.get(url);
+                    return target && (target.status >= 400 || (target.status === 0 && (target.crawlStatus === 'network_error' || target.crawlStatus === 'failed_after_retries' || target.securityError || target.crawlStatus === 'fetched_error')));
+                });
+                brokenInternalLinks += actualBreaks.length;
+            }
+            if ((node.redirectChain?.length || 0) > 1) {
+                redirectChains += 1;
+            }
+            const absoluteUrl = rootOrigin ? (node.url.startsWith('http') ? node.url : new URL(node.url, rootOrigin).toString()) : node.url;
+            if (node.canonical && node.canonical !== node.url && node.canonical !== absoluteUrl) {
+                // Final check: normalize both to ignore trailing slash differences or protocol mismatches if they are considered "same"
+                const normCanonical = node.canonical.replace(/\/$/, '');
+                const normAbsolute = absoluteUrl.replace(/\/$/, '');
+                if (normCanonical !== normAbsolute) {
+                    canonicalConflicts += 1;
+                }
+            }
+            if (node.noindex && node.status >= 200 && node.status < 300) {
+                accidentalNoindex += 1;
+            }
+            if (node.inLinks === 1 && node.depth > 0) {
+                lowInternalLinkCount += 1;
+            }
+            if (node.outLinks > EXCESSIVE_INTERNAL_LINK_THRESHOLD) {
+                excessiveInternalLinkCount += 1;
+            }
+            if (!node.html) {
+                continue;
+            }
+            const h1Res = analyzeH1(node.html, '');
+            if (h1Res.count === 0) {
+                missingH1 += 1;
+            }
+            if (node.wordCount != null) {
+                if (node.wordCount < THIN_CONTENT_THRESHOLD) {
+                    thinContent += 1;
+                }
+            }
+            else if (node.html) {
+                const content = analyzeContent(node.html);
+                if (content.wordCount < THIN_CONTENT_THRESHOLD) {
+                    thinContent += 1;
+                }
+            }
+            const pageAbsUrl = rootOrigin ? UrlUtil.toAbsolute(node.url, rootOrigin) : node.url;
+            const links = analyzeLinks(node.html || '', pageAbsUrl, rootOrigin || node.url);
+            externalLinks += links.externalLinks;
+            if (links.externalRatio > HIGH_EXTERNAL_LINK_RATIO_THRESHOLD) {
+                highExternalLinkRatio += 1;
+            }
+            if (node.html) {
+                const imageAlt = analyzeImageAlts(node.html);
+                if (imageAlt.missingAlt > 0) {
+                    imageAltMissing += 1;
+                }
+            }
+        }
+        const clusters = graph.contentClusters || metrics.clusters || [];
+        const duplicateClusters = clusters.length;
+        const cannibalizationClusters = clusters.filter((cluster) => cluster.risk === 'high' || cluster.type === 'near').length;
+        for (const node of nodes) {
+            const authority = node.inLinks > 5 ? 0.8 : 0.2;
+            if (authority >= OPPORTUNITY_AUTHORITY_THRESHOLD && node.outLinks < 3) {
+                strongPagesUnderLinking += 1;
+            }
+            if (authority >= 0.65 && authority < OPPORTUNITY_AUTHORITY_THRESHOLD) {
+                nearAuthorityThreshold += 1;
+            }
+            if (authority >= OPPORTUNITY_AUTHORITY_THRESHOLD && node.inLinks < LOW_INTERNAL_LINK_THRESHOLD) {
+                underlinkedHighAuthorityPages += 1;
+            }
+        }
+        return {
+            orphanPages: metrics.orphanPages?.length || 0,
+            brokenInternalLinks,
+            redirectChains,
+            duplicateClusters,
+            canonicalConflicts,
+            accidentalNoindex,
+            missingH1,
+            thinContent,
+            lowInternalLinkCount,
+            excessiveInternalLinkCount,
+            highExternalLinkRatio,
+            imageAltMissing,
+            strongPagesUnderLinking,
+            cannibalizationClusters,
+            nearAuthorityThreshold,
+            underlinkedHighAuthorityPages,
+            externalLinks,
+            blockedByRobots,
+            crawlTraps
+        };
+    }
+    clamp(value, min, max) {
+        return Math.min(max, Math.max(min, value));
+    }
+    healthStatusLabel(score, hasCritical = false) {
+        if (hasCritical && score >= 75)
+            return 'Needs Attention';
+        if (score >= 90)
+            return 'Excellent';
+        if (score >= 75)
+            return 'Good';
+        if (score >= 50)
+            return 'Needs Attention';
+        return 'Critical';
+    }
 }
-export function healthStatusLabel(score, hasCritical = false) {
+const service = new HealthService();
+export const calculateHealthScore = (totalPages, issues, weights = DEFAULT_HEALTH_WEIGHTS) => service.calculateHealthScore(totalPages, issues, weights);
+export const healthStatusLabel = (score, hasCritical = false) => {
     if (hasCritical && score >= 75)
         return 'Needs Attention';
     if (score >= 90)
@@ -33,138 +210,4 @@ export function healthStatusLabel(score, hasCritical = false) {
     if (score >= 50)
         return 'Needs Attention';
     return 'Critical';
-}
-export function calculateHealthScore(totalPages, issues, weights = DEFAULT_HEALTH_WEIGHTS) {
-    const safePages = Math.max(totalPages, 1);
-    const weightedPenalties = {
-        orphans: clamp((issues.orphanPages / safePages) * weights.orphans, 0, weights.orphans),
-        brokenLinks: clamp((issues.brokenInternalLinks / safePages) * weights.brokenLinks, 0, weights.brokenLinks),
-        redirectChains: clamp((issues.redirectChains / safePages) * weights.redirectChains, 0, weights.redirectChains),
-        duplicateClusters: clamp((issues.duplicateClusters / safePages) * weights.duplicateClusters, 0, weights.duplicateClusters),
-        thinContent: clamp((issues.thinContent / safePages) * weights.thinContent, 0, weights.thinContent),
-        missingH1: clamp((issues.missingH1 / safePages) * weights.missingH1, 0, weights.missingH1),
-        noindexMisuse: clamp((issues.accidentalNoindex / safePages) * weights.noindexMisuse, 0, weights.noindexMisuse),
-        canonicalConflicts: clamp((issues.canonicalConflicts / safePages) * weights.canonicalConflicts, 0, weights.canonicalConflicts),
-        lowInternalLinks: clamp((issues.lowInternalLinkCount / safePages) * weights.lowInternalLinks, 0, weights.lowInternalLinks),
-        excessiveLinks: clamp((issues.excessiveInternalLinkCount / safePages) * weights.excessiveLinks, 0, weights.excessiveLinks),
-        blockedByRobots: clamp((issues.blockedByRobots / safePages) * weights.blockedByRobots, 0, weights.blockedByRobots)
-    };
-    const totalPenalty = Object.values(weightedPenalties).reduce((sum, value) => sum + value, 0);
-    const score = Number(clamp(100 - totalPenalty, 0, 100).toFixed(1));
-    const hasCritical = (issues.orphanPages > 0 ||
-        issues.brokenInternalLinks > 0 ||
-        issues.redirectChains > 0 ||
-        issues.duplicateClusters > 0 ||
-        issues.canonicalConflicts > 0 ||
-        issues.accidentalNoindex > 0 ||
-        issues.blockedByRobots > 0);
-    return {
-        score,
-        status: healthStatusLabel(score, hasCritical),
-        weightedPenalties,
-        weights
-    };
-}
-export function collectCrawlIssues(graph, metrics) {
-    const nodes = graph.getNodes();
-    let brokenInternalLinks = 0;
-    let redirectChains = 0;
-    let canonicalConflicts = 0;
-    let accidentalNoindex = 0;
-    let missingH1 = 0;
-    let thinContent = 0;
-    let highExternalLinkRatio = 0;
-    let imageAltMissing = 0;
-    let lowInternalLinkCount = 0;
-    let excessiveInternalLinkCount = 0;
-    let strongPagesUnderLinking = 0;
-    let nearAuthorityThreshold = 0;
-    let underlinkedHighAuthorityPages = 0;
-    let externalLinks = 0;
-    let blockedByRobots = 0;
-    for (const node of nodes) {
-        if (node.crawlStatus === 'blocked' || node.crawlStatus === 'blocked_by_robots') {
-            blockedByRobots += 1;
-        }
-        const isConfirmedError = node.status >= 400 || (node.status === 0 && (node.crawlStatus === 'network_error' || node.crawlStatus === 'failed_after_retries' || node.securityError || node.crawlStatus === 'fetched_error'));
-        if (isConfirmedError) {
-            brokenInternalLinks += 1;
-        }
-        if (node.brokenLinks) {
-            const actualBreaks = node.brokenLinks.filter(url => {
-                const target = graph.nodes.get(url);
-                return target && (target.status >= 400 || (target.status === 0 && (target.crawlStatus === 'network_error' || target.crawlStatus === 'failed_after_retries' || target.securityError || target.crawlStatus === 'fetched_error')));
-            });
-            brokenInternalLinks += actualBreaks.length;
-        }
-        if ((node.redirectChain?.length || 0) > 1) {
-            redirectChains += 1;
-        }
-        if (node.canonical && node.canonical !== node.url) {
-            canonicalConflicts += 1;
-        }
-        if (node.noindex && node.status >= 200 && node.status < 300) {
-            accidentalNoindex += 1;
-        }
-        if (node.inLinks < LOW_INTERNAL_LINK_THRESHOLD && node.depth > 0) {
-            lowInternalLinkCount += 1;
-        }
-        if (node.outLinks > EXCESSIVE_INTERNAL_LINK_THRESHOLD) {
-            excessiveInternalLinkCount += 1;
-        }
-        if (!node.html) {
-            continue;
-        }
-        const h1 = analyzeH1(node.html, '');
-        if (h1.count === 0) {
-            missingH1 += 1;
-        }
-        const content = analyzeContent(node.html);
-        if (content.wordCount < THIN_CONTENT_THRESHOLD) {
-            thinContent += 1;
-        }
-        const links = analyzeLinks(node.html, node.url, node.url);
-        externalLinks += links.externalLinks;
-        if (links.externalRatio > HIGH_EXTERNAL_LINK_RATIO_THRESHOLD) {
-            highExternalLinkRatio += 1;
-        }
-        const imageAlt = analyzeImageAlts(node.html);
-        if (imageAlt.missingAlt > 0) {
-            imageAltMissing += 1;
-        }
-    }
-    const duplicateClusters = graph.duplicateClusters?.length || 0;
-    const cannibalizationClusters = graph.duplicateClusters?.filter((cluster) => cluster.type === 'near').length || 0;
-    for (const node of nodes) {
-        const authority = node.pageRank || 0;
-        if (authority >= OPPORTUNITY_AUTHORITY_THRESHOLD && node.outLinks < 3) {
-            strongPagesUnderLinking += 1;
-        }
-        if (authority >= 0.65 && authority < OPPORTUNITY_AUTHORITY_THRESHOLD) {
-            nearAuthorityThreshold += 1;
-        }
-        if (authority >= OPPORTUNITY_AUTHORITY_THRESHOLD && node.inLinks < LOW_INTERNAL_LINK_THRESHOLD) {
-            underlinkedHighAuthorityPages += 1;
-        }
-    }
-    return {
-        orphanPages: metrics.orphanPages.length,
-        brokenInternalLinks,
-        redirectChains,
-        duplicateClusters,
-        canonicalConflicts,
-        accidentalNoindex,
-        missingH1,
-        thinContent,
-        lowInternalLinkCount,
-        excessiveInternalLinkCount,
-        highExternalLinkRatio,
-        imageAltMissing,
-        strongPagesUnderLinking,
-        cannibalizationClusters,
-        nearAuthorityThreshold,
-        underlinkedHighAuthorityPages,
-        externalLinks,
-        blockedByRobots
-    };
-}
+};

package/dist/utils/chalk.d.ts

@@ -0,0 +1,6 @@
+interface Chalk {
+    (text: unknown): string;
+    [key: string]: Chalk;
+}
+declare const chalk: Chalk;
+export default chalk;

package/dist/utils/chalk.js

@@ -0,0 +1,41 @@
+import { styleText } from 'node:util';
+const alias = {
+    grey: 'gray'
+};
+const chalk = createChalk([]);
+function createChalk(styles) {
+    const formatter = ((text) => applyStyles(styles, text));
+    return new Proxy(formatter, {
+        apply(_target, _thisArg, args) {
+            return applyStyles(styles, args[0]);
+        },
+        get(_target, prop) {
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            const style = alias[prop] ?? prop;
+            return createChalk([...styles, style]);
+        }
+    });
+}
+function applyStyles(styles, text) {
+    const value = String(text ?? '');
+    if (styles.length === 0 || !isColorEnabled()) {
+        return value;
+    }
+    return styleText(styles, value);
+}
+function isColorEnabled() {
+    if (process.env.NO_COLOR !== undefined || process.env.NODE_DISABLE_COLORS !== undefined) {
+        return false;
+    }
+    const forceColor = process.env.FORCE_COLOR;
+    if (forceColor === '0') {
+        return false;
+    }
+    if (forceColor !== undefined) {
+        return true;
+    }
+    return Boolean(process.stdout?.isTTY);
+}
+export default chalk;