@crawlith/core 0.1.1 → 0.1.2

package/src/report/crawlExport.ts

@@ -1,58 +0,0 @@
-export function renderCrawlCsvNodes(graphData: any): string {
-    const nodeHeaders = ['URL', 'Depth', 'Status', 'InboundLinks', 'OutboundLinks', 'PageRankScore'];
-    const nodeRows = graphData.nodes.map((n: any) => {
-        const outbound = graphData.edges.filter((e: any) => e.source === n.url).length;
-        const inbound = graphData.edges.filter((e: any) => e.target === n.url).length;
-        const statusStr = n.status === 0 ? 'Pending/Limit' : n.status;
-        return [n.url, n.depth, statusStr, inbound, outbound, (n.pageRankScore || 0).toFixed(3)].join(',');
-    });
-    return [nodeHeaders.join(','), ...nodeRows].join('\n');
-}
-
-export function renderCrawlCsvEdges(graphData: any): string {
-    const edgeHeaders = ['Source', 'Target', 'Weight'];
-    const edgeRows = graphData.edges.map((e: any) => [e.source, e.target, e.weight].join(','));
-    return [edgeHeaders.join(','), ...edgeRows].join('\n');
-}
-
-export function renderCrawlMarkdown(url: string, graphData: any, metrics: any, graph: any): string {
-    const md = [
-        `# Crawlith Crawl Summary - ${url}`,
-        '',
-        `## 📊 Metrics`,
-        `- Total Pages Discovered: ${metrics.totalPages}`,
-        `- Session Pages Crawled: ${graph.sessionStats?.pagesFetched ?? 0}`,
-        `- Total Edges: ${metrics.totalEdges}`,
-        `- Avg Depth: ${metrics.averageDepth.toFixed(2)}`,
-        `- Max Depth: ${metrics.maxDepthFound}`,
-        `- Crawl Efficiency: ${(metrics.crawlEfficiencyScore * 100).toFixed(1)}%`,
-        '',
-        `## 📄 Top Pages (by In-degree)`,
-    ];
-
-    const topPages = [...graphData.nodes]
-        .map((n: any) => ({ ...n, inLinks: graphData.edges.filter((e: any) => e.target === n.url).length }))
-        .sort((a, b) => b.inLinks - a.inLinks)
-        .slice(0, 10);
-
-    md.push('| URL | Inbound | Status |');
-    md.push('| :--- | :--- | :--- |');
-    topPages.forEach(p => {
-        const statusStr = p.status === 0 ? 'Pending/Limit' : p.status;
-        md.push(`| ${p.url} | ${p.inLinks} | ${statusStr} |`);
-    });
-
-    if (metrics.topPageRankPages?.length > 0) {
-        md.push('');
-        md.push('## 🏆 Top PageRank Pages');
-        md.push('| URL | Score |');
-        md.push('| :--- | :--- |');
-        metrics.topPageRankPages.slice(0, 10).forEach((p: any) => {
-            const node = graph.nodes?.get ? graph.nodes.get(p.url) : graph.getNodes?.().find((x: any) => x.url === p.url);
-            const score = node?.pageRankScore ?? 0;
-            md.push(`| ${p.url} | ${score.toFixed(3)}/100 |`);
-        });
-    }
-
-    return md.join('\n');
-}

package/src/report/crawl_template.ts

@@ -1,9 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const templatePath = path.join(__dirname, 'crawl.html');
-
-export const Crawl_HTML = fs.readFileSync(templatePath, 'utf-8');

package/src/report/html.ts

@@ -1,27 +0,0 @@
-import { Metrics } from '../graph/metrics.js';
-import { Crawl_HTML } from './crawl_template.js';
-
-function safeJson(data: any): string {
-    return JSON.stringify(data).replace(/</g, '\\u003c');
-}
-
-export function generateHtml(graphData: any, metrics: Metrics): string {
-    // Strip heavy HTML content from nodes to keep the report lightweight
-    const vizGraphData = {
-        ...graphData,
-        nodes: graphData.nodes ? graphData.nodes.map((n: any) => {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { html, ...rest } = n;
-            return rest;
-        }) : []
-    };
-
-    const graphJson = safeJson(vizGraphData);
-    const metricsJson = safeJson(metrics);
-
-    return Crawl_HTML.replace('</body>', `<script>
-        window.GRAPH_DATA = ${graphJson};
-        window.METRICS_DATA = ${metricsJson};
-    </script>
-    </body>`);
-}

package/src/scoring/health.ts

@@ -1,241 +0,0 @@
-import { Graph } from '../graph/graph.js';
-import { Metrics } from '../graph/metrics.js';
-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;
-export const LOW_INTERNAL_LINK_THRESHOLD = 2;
-export const EXCESSIVE_INTERNAL_LINK_THRESHOLD = 150;
-export const HIGH_EXTERNAL_LINK_RATIO_THRESHOLD = 0.6;
-export const OPPORTUNITY_AUTHORITY_THRESHOLD = 0.8;
-
-export interface HealthScoreWeights {
-    orphans: number;
-    brokenLinks: number;
-    redirectChains: number;
-    duplicateClusters: number;
-    thinContent: number;
-    missingH1: number;
-    noindexMisuse: number;
-    canonicalConflicts: number;
-    lowInternalLinks: number;
-    excessiveLinks: number;
-    blockedByRobots: number;
-}
-
-export const DEFAULT_HEALTH_WEIGHTS: HealthScoreWeights = {
-    orphans: 50,
-    brokenLinks: 100,
-    redirectChains: 20,
-    duplicateClusters: 25,
-    thinContent: 15,
-    missingH1: 10,
-    noindexMisuse: 20,
-    canonicalConflicts: 10,
-    lowInternalLinks: 10,
-    excessiveLinks: 5,
-    blockedByRobots: 100
-};
-
-export interface CrawlIssueCounts {
-    orphanPages: number;
-    brokenInternalLinks: number;
-    redirectChains: number;
-    duplicateClusters: number;
-    canonicalConflicts: number;
-    accidentalNoindex: number;
-    missingH1: number;
-    thinContent: number;
-    lowInternalLinkCount: number;
-    excessiveInternalLinkCount: number;
-    highExternalLinkRatio: number;
-    imageAltMissing: number;
-    strongPagesUnderLinking: number;
-    cannibalizationClusters: number;
-    nearAuthorityThreshold: number;
-    underlinkedHighAuthorityPages: number;
-    externalLinks: number;
-    blockedByRobots: number;
-}
-
-export interface HealthScoreBreakdown {
-    score: number;
-    status: string;
-    weightedPenalties: Record<keyof HealthScoreWeights, number>;
-    weights: HealthScoreWeights;
-}
-
-function clamp(value: number, min: number, max: number): number {
-    return Math.min(max, Math.max(min, value));
-}
-
-export function healthStatusLabel(score: number, hasCritical: boolean = false): string {
-    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 calculateHealthScore(
-    totalPages: number,
-    issues: Pick<CrawlIssueCounts, 'orphanPages' | 'brokenInternalLinks' | 'redirectChains' | 'duplicateClusters' | 'thinContent' | 'missingH1' | 'accidentalNoindex' | 'canonicalConflicts' | 'lowInternalLinkCount' | 'excessiveInternalLinkCount' | 'blockedByRobots'>,
-    weights: HealthScoreWeights = DEFAULT_HEALTH_WEIGHTS
-): HealthScoreBreakdown {
-    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: Graph, metrics: Metrics): CrawlIssueCounts {
-    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/src/scoring/hits.ts

@@ -1,153 +0,0 @@
-import { Graph, GraphNode } from '../graph/graph.js';
-
-export interface HITSOptions {
-    iterations?: number;
-}
-
-/**
- * Computes Hub and Authority scores using the HITS algorithm.
- * Operates purely on the internal link graph.
- * Optimized for performance using array-based adjacency lists.
- */
-export function computeHITS(graph: Graph, options: HITSOptions = {}): void {
-    const iterations = options.iterations || 20;
-    const nodes = graph.getNodes();
-
-    // 1. Filter eligible nodes
-    // Eligibility: status 200 (crawled) or status 0 (discovered)
-    // Non-redirect, not noindex (if known), non-external
-    const eligibleNodes = nodes.filter(n =>
-        (n.status === 200 || n.status === 0) &&
-        (!n.redirectChain || n.redirectChain.length === 0) &&
-        !n.noindex
-    );
-
-    const N = eligibleNodes.length;
-    if (N === 0) return;
-
-    // Map URL to Index for O(1) access
-    const urlToIndex = new Map<string, number>();
-    for (let i = 0; i < N; i++) {
-        urlToIndex.set(eligibleNodes[i].url, i);
-    }
-
-    // Build Adjacency Lists (Indices)
-    // incoming[i] = list of { sourceIndex, weight }
-    // outgoing[i] = list of { targetIndex, weight }
-    const incoming: { sourceIndex: number, weight: number }[][] = new Array(N).fill(null).map(() => []);
-    const outgoing: { targetIndex: number, weight: number }[][] = new Array(N).fill(null).map(() => []);
-
-    const allEdges = graph.getEdges();
-    for (const edge of allEdges) {
-        if (edge.source === edge.target) continue;
-
-        const sourceIndex = urlToIndex.get(edge.source);
-        const targetIndex = urlToIndex.get(edge.target);
-
-        if (sourceIndex !== undefined && targetIndex !== undefined) {
-            incoming[targetIndex].push({ sourceIndex, weight: edge.weight });
-            outgoing[sourceIndex].push({ targetIndex, weight: edge.weight });
-        }
-    }
-
-    // Initialize Scores
-    const authScores = new Float64Array(N).fill(1.0);
-    const hubScores = new Float64Array(N).fill(1.0);
-
-    // 2. Iteration
-    for (let iter = 0; iter < iterations; iter++) {
-        // Update Authorities
-        let normAuth = 0;
-        for (let i = 0; i < N; i++) {
-            const inLinks = incoming[i];
-            let newAuth = 0;
-            for (let j = 0; j < inLinks.length; j++) {
-                const link = inLinks[j];
-                newAuth += hubScores[link.sourceIndex] * link.weight;
-            }
-            authScores[i] = newAuth;
-            normAuth += newAuth * newAuth;
-        }
-
-        // Normalize Authorities (L2 norm)
-        normAuth = Math.sqrt(normAuth);
-        if (normAuth > 0) {
-            for (let i = 0; i < N; i++) {
-                authScores[i] /= normAuth;
-            }
-        }
-
-        // Update Hubs
-        let normHub = 0;
-        for (let i = 0; i < N; i++) {
-            const outLinks = outgoing[i];
-            let newHub = 0;
-            for (let j = 0; j < outLinks.length; j++) {
-                const link = outLinks[j];
-                newHub += authScores[link.targetIndex] * link.weight;
-            }
-            hubScores[i] = newHub;
-            normHub += newHub * newHub;
-        }
-
-        // Normalize Hubs (L2 norm)
-        normHub = Math.sqrt(normHub);
-        if (normHub > 0) {
-            for (let i = 0; i < N; i++) {
-                hubScores[i] /= normHub;
-            }
-        }
-    }
-
-    // 3. Assign back to GraphNodes
-    for (let i = 0; i < N; i++) {
-        eligibleNodes[i].authorityScore = authScores[i];
-        eligibleNodes[i].hubScore = hubScores[i];
-    }
-
-    // 4. Classification Logic
-    classifyLinkRoles(eligibleNodes);
-}
-
-function classifyLinkRoles(nodes: GraphNode[]): void {
-    if (nodes.length === 0) return;
-
-    const authScores = nodes.map(n => n.authorityScore || 0).sort((a, b) => a - b);
-    const hubScores = nodes.map(n => n.hubScore || 0).sort((a, b) => a - b);
-
-    // Use 75th percentile as "high" threshold
-    // Using median (50th percentile) as per original implementation,
-    // but the comment said "Use 75th percentile" while code used median.
-    // I'll stick to median to avoid breaking existing behavior, but correct the comment or logic?
-    // The original code:
-    // const medianAuth = authScores[Math.floor(authScores.length / 2)];
-    // const isHighAuth = auth > medianAuth && auth > 0.0001;
-    // So it uses median. I'll keep it as median.
-
-    const medianAuth = authScores[Math.floor(authScores.length / 2)];
-    const medianHub = hubScores[Math.floor(hubScores.length / 2)];
-    const maxAuth = authScores[authScores.length - 1];
-    const maxHub = hubScores[hubScores.length - 1];
-
-    for (const node of nodes) {
-        const auth = node.authorityScore || 0;
-        const hub = node.hubScore || 0;
-
-        // A node is high if it's above median, OR if it's the max (to handle uniform distributions)
-        // auth > 0 check is essential.
-        const isHighAuth = (auth > medianAuth || (auth === maxAuth && auth > 0)) && auth > 0.00001;
-        const isHighHub = (hub > medianHub || (hub === maxHub && hub > 0)) && hub > 0.00001;
-
-        if (isHighAuth && isHighHub) {
-            node.linkRole = 'power';
-        } else if (isHighAuth) {
-            node.linkRole = 'authority';
-        } else if (isHighHub) {
-            node.linkRole = 'hub';
-        } else if (auth > 0.00001 && hub > 0.00001) {
-            node.linkRole = 'balanced';
-        } else {
-            node.linkRole = 'peripheral';
-        }
-    }
-}

package/src/scoring/orphanSeverity.ts

@@ -1,176 +0,0 @@
-export type OrphanType = 'hard' | 'near' | 'soft' | 'crawl-only';
-export type ImpactLevel = 'low' | 'medium' | 'high' | 'critical';
-
-export interface CrawlNode {
-  url: string;
-  depth: number;
-  inLinks: number;
-  outLinks: number;
-  status: number;
-  discoveredViaSitemap?: boolean;
-  robotsExcluded?: boolean;
-  canonicalUrl?: string;
-  isHomepage?: boolean;
-  wordCount?: number;
-  hasStructuredData?: boolean;
-  pageType?: string;
-  noindex?: boolean;
-  duplicateContent?: boolean;
-  isProductOrCommercial?: boolean;
-}
-
-export interface CrawlEdge {
-  source: string;
-  target: string;
-}
-
-export interface OrphanScoringOptions {
-  enabled: boolean;
-  severityEnabled: boolean;
-  includeSoftOrphans: boolean;
-  minInbound: number;
-  rootUrl?: string;
-}
-
-export type AnnotatedNode = CrawlNode & {
-  orphan: boolean;
-  orphanType?: OrphanType;
-  orphanSeverity?: number;
-  impactLevel?: ImpactLevel;
-};
-
-const LOW_VALUE_PATTERNS = [
-  /[?&](page|p)=\d+/i,
-  /\/(page|tag|tags|category|categories)\//i,
-  /[?&](q|query|search|filter|sort)=/i,
-  /\/search(\/|\?|$)/i
-];
-
-function isLowValuePage(node: CrawlNode): boolean {
-  const type = (node.pageType || '').toLowerCase();
-  if (['pagination', 'tag', 'category', 'filter', 'search', 'archive'].includes(type)) {
-    return true;
-  }
-  if (node.noindex) {
-    return true;
-  }
-  return LOW_VALUE_PATTERNS.some((pattern) => pattern.test(node.url));
-}
-
-function clampScore(score: number): number {
-  return Math.max(0, Math.min(100, Math.round(score)));
-}
-
-export function mapImpactLevel(score: number): ImpactLevel {
-  if (score <= 39) return 'low';
-  if (score <= 69) return 'medium';
-  if (score <= 89) return 'high';
-  return 'critical';
-}
-
-export function calculateOrphanSeverity(orphanType: OrphanType, node: CrawlNode): number {
-  let score = 0;
-
-  switch (orphanType) {
-    case 'hard':
-      score = 90;
-      break;
-    case 'crawl-only':
-      score = 80;
-      break;
-    case 'near':
-      score = node.inLinks <= 1 ? 70 : 60;
-      break;
-    case 'soft':
-      score = 50;
-      break;
-  }
-
-  let positiveModifier = 0;
-  if ((node.wordCount || 0) > 800) positiveModifier += 10;
-  if (node.hasStructuredData) positiveModifier += 10;
-  if (node.depth <= 2) positiveModifier += 10;
-  if (node.isProductOrCommercial) positiveModifier += 10;
-  positiveModifier = Math.min(20, positiveModifier);
-
-  let negativeModifier = 0;
-  if ((node.wordCount || 0) > 0 && (node.wordCount || 0) < 300) negativeModifier += 20;
-  if (node.noindex) negativeModifier += 20;
-  if (node.duplicateContent) negativeModifier += 20;
-  if ((node.pageType || '').toLowerCase() === 'archive' || (node.pageType || '').toLowerCase() === 'pagination') negativeModifier += 20;
-  negativeModifier = Math.min(20, negativeModifier);
-
-  score += positiveModifier;
-  score -= negativeModifier;
-
-  return clampScore(score);
-}
-
-function consolidateInboundByCanonical(nodes: CrawlNode[]): Map<string, number> {
-  const canonicalInbound = new Map<string, number>();
-  for (const node of nodes) {
-    const canonical = node.canonicalUrl || node.url;
-    canonicalInbound.set(canonical, (canonicalInbound.get(canonical) || 0) + node.inLinks);
-  }
-  return canonicalInbound;
-}
-
-export function annotateOrphans(nodes: CrawlNode[], edges: CrawlEdge[], options: OrphanScoringOptions): AnnotatedNode[] {
-  if (!options.enabled) {
-    return nodes.map((node) => ({ ...node, orphan: false }));
-  }
-
-  const canonicalInbound = consolidateInboundByCanonical(nodes);
-  const nodeByUrl = new Map(nodes.map((node) => [node.url, node]));
-
-  return nodes.map((node) => {
-    const isHomepage = node.isHomepage || (options.rootUrl ? node.url === options.rootUrl : node.depth === 0);
-    if (isHomepage || node.robotsExcluded) {
-      return { ...node, orphan: false };
-    }
-
-    const canonical = node.canonicalUrl || node.url;
-    const inbound = canonicalInbound.get(canonical) || 0;
-
-    let orphanType: OrphanType | undefined;
-
-    if (inbound === 0) {
-      orphanType = node.discoveredViaSitemap ? 'crawl-only' : 'hard';
-    } else if (inbound <= options.minInbound) {
-      orphanType = 'near';
-    }
-
-    if (!orphanType && options.includeSoftOrphans && inbound > 0) {
-      const inboundSources = edges
-        .filter((edge) => edge.target === node.url)
-        .map((edge) => nodeByUrl.get(edge.source))
-        .filter((source): source is CrawlNode => Boolean(source));
-
-      if (inboundSources.length > 0 && inboundSources.every((source) => isLowValuePage(source))) {
-        orphanType = 'soft';
-      }
-    }
-
-    if (!orphanType) {
-      return { ...node, orphan: false };
-    }
-
-    if (!options.severityEnabled) {
-      return {
-        ...node,
-        orphan: true,
-        orphanType
-      };
-    }
-
-    const orphanSeverity = calculateOrphanSeverity(orphanType, { ...node, inLinks: inbound });
-
-    return {
-      ...node,
-      orphan: true,
-      orphanType,
-      orphanSeverity,
-      impactLevel: mapImpactLevel(orphanSeverity)
-    };
-  });
-}

package/src/utils/version.ts

@@ -1,18 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-let version = '0.0.1';
-
-try {
-    const pkgPath = join(__dirname, '../../package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    version = pkg.version;
-} catch {
-    // Fallback to internal default
-}
-
-export { version };