@ai-lighthouse/cli 1.0.0 → 1.0.2

package/dist/ui/components/OverviewSection.js

@@ -1,107 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-export const OverviewSection = ({ aiReadiness }) => {
-    const getStatusColor = (status) => {
-        if (status === 'excellent')
-            return 'green';
-        if (status === 'good')
-            return 'blue';
-        if (status === 'needs-work')
-            return 'yellow';
-        return 'red';
-    };
-    const renderProgressBar = (score, width = 20) => {
-        const filled = Math.round((score / 100) * width);
-        const empty = width - filled;
-        const color = score >= 80 ? 'green' : score >= 60 ? 'yellow' : 'red';
-        return (React.createElement(Text, { color: color },
-            '█'.repeat(filled),
-            React.createElement(Text, { dimColor: true }, '░'.repeat(empty)),
-            ` ${Math.round(score)}%`));
-    };
-    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
-        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "cyan" }, "\uD83E\uDD16 AI Agent Perspective"),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Box, null,
-                    React.createElement(Text, null,
-                        aiReadiness.aiPerspective?.canUnderstand ? '✅' : '❌',
-                        " Can Understand",
-                        aiReadiness.aiPerspective?.canExtract ? '✅' : '❌',
-                        " Can Extract")),
-                React.createElement(Box, null,
-                    React.createElement(Text, null,
-                        aiReadiness.aiPerspective?.canIndex ? '✅' : '❌',
-                        " Can Index",
-                        aiReadiness.aiPerspective?.canAnswer ? '✅' : '❌',
-                        " Can Answer")),
-                React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { dimColor: true },
-                        "Confidence: ",
-                        Math.round((aiReadiness.aiPerspective?.confidence || 0) * 100),
-                        "%"))),
-            aiReadiness.aiPerspective?.mainBlockers && aiReadiness.aiPerspective.mainBlockers.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, { bold: true, color: "red" }, "Main Blockers:"),
-                aiReadiness.aiPerspective.mainBlockers.map((blocker, idx) => (React.createElement(Text, { key: idx, color: "red" },
-                    "\u2022 ",
-                    blocker)))))),
-        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-            React.createElement(Text, { bold: true, underline: true }, "\uD83C\uDFAF Dimension Scores"),
-            Object.entries(aiReadiness.dimensions || {}).map(([key, dim]) => (React.createElement(Box, { key: key, flexDirection: "column", marginTop: 1 },
-                React.createElement(Box, { justifyContent: "space-between" },
-                    React.createElement(Text, { bold: true, color: getStatusColor(dim.status) },
-                        getDimensionIcon(key),
-                        " ",
-                        formatDimensionName(key)),
-                    React.createElement(Text, { color: getStatusColor(dim.status) },
-                        Math.round(dim.score),
-                        "/100")),
-                React.createElement(Box, { marginTop: 0.5 }, renderProgressBar(dim.score)),
-                dim.recommendation && (React.createElement(Box, { marginTop: 0.5 },
-                    React.createElement(Text, { dimColor: true },
-                        "\u2192 ",
-                        dim.recommendation))))))),
-        aiReadiness.quickWins && aiReadiness.quickWins.length > 0 && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, marginTop: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, "\u26A1 Quick Wins (High Impact, Low Effort)"),
-            aiReadiness.quickWins.slice(0, 5).map((win, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginTop: 1 },
-                React.createElement(Text, { bold: true },
-                    idx + 1,
-                    ". ",
-                    win.issue),
-                React.createElement(Text, { dimColor: true },
-                    "Impact: ",
-                    win.impact,
-                    " \u2022 Effort: ",
-                    win.effort),
-                React.createElement(Text, { color: "cyan" },
-                    "\u2192 ",
-                    win.fix))))))));
-};
-function getDimensionIcon(key) {
-    const icons = {
-        technical: '⚙️',
-        contentQuality: '📝',
-        crawlability: '🕷️',
-        discoverability: '🔍',
-        knowledge: '🧠',
-        extractability: '🔄',
-        comprehensibility: '💡',
-        trustworthiness: '✅',
-        accessibility: '♿',
-    };
-    return icons[key] || '📌';
-}
-function formatDimensionName(key) {
-    const names = {
-        technical: 'Technical',
-        contentQuality: 'Content Quality',
-        crawlability: 'Crawlability',
-        discoverability: 'Discoverability',
-        knowledge: 'Knowledge',
-        extractability: 'Extractability',
-        comprehensibility: 'Comprehensibility',
-        trustworthiness: 'Trustworthiness',
-        accessibility: 'Accessibility',
-    };
-    return names[key] || key;
-}

package/dist/ui/components/ScoreDisplay.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-interface ScoreDisplayProps {
-    score: number;
-    grade: string;
-    url: string;
-}
-export declare const ScoreDisplay: React.FC<ScoreDisplayProps>;
-export {};

package/dist/ui/components/ScoreDisplay.js

@@ -1,41 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import Gradient from 'ink-gradient';
-import BigText from 'ink-big-text';
-export const ScoreDisplay = ({ score, grade, url }) => {
-    const getGradeColor = (grade) => {
-        if (grade.startsWith('A'))
-            return 'green';
-        if (grade.startsWith('B'))
-            return 'blue';
-        if (grade.startsWith('C'))
-            return 'yellow';
-        return 'red';
-    };
-    const getScoreMessage = (score) => {
-        if (score >= 90)
-            return { status: 'Excellent', message: 'Your site is AI-ready!', color: 'green' };
-        if (score >= 80)
-            return { status: 'Good', message: 'Your site works well with AI', color: 'blue' };
-        if (score >= 70)
-            return { status: 'Fair', message: 'Room for improvement', color: 'yellow' };
-        if (score >= 60)
-            return { status: 'Poor', message: 'Needs significant work', color: 'yellow' };
-        return { status: 'Critical', message: 'Major issues detected', color: 'red' };
-    };
-    const { status, message, color } = getScoreMessage(score);
-    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Gradient, { name: "rainbow" },
-                React.createElement(BigText, { text: `${score}`, font: "block" }))),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: getGradeColor(grade) },
-                "Grade: ",
-                grade,
-                " \u2022 ",
-                status)),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, url)),
-        React.createElement(Box, { borderStyle: "round", borderColor: color, paddingX: 2, paddingY: 1 },
-            React.createElement(Text, { color: color }, message))));
-};

package/dist/ui/components/TechnicalSection.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface TechnicalSectionProps {
-    result: any;
-    scoring: any;
-}
-export declare const TechnicalSection: React.FC<TechnicalSectionProps>;
-export {};

package/dist/ui/components/TechnicalSection.js

@@ -1,110 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-export const TechnicalSection = ({ result, scoring }) => {
-    const renderProgressBar = (score, width = 20) => {
-        const filled = Math.round((score / 100) * width);
-        const empty = width - filled;
-        const color = score >= 80 ? 'green' : score >= 60 ? 'yellow' : 'red';
-        return (React.createElement(Text, { color: color },
-            '█'.repeat(filled),
-            React.createElement(Text, { dimColor: true }, '░'.repeat(empty)),
-            ` ${Math.round(score)}%`));
-    };
-    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
-        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "blue" }, "\uD83D\uDCCA Category Scores"),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                scoring?.crawlability !== undefined && (React.createElement(Box, { flexDirection: "column", marginTop: 0.5 },
-                    React.createElement(Box, { justifyContent: "space-between" },
-                        React.createElement(Text, { bold: true }, "\uD83D\uDD77\uFE0F  Crawlability"),
-                        React.createElement(Text, null,
-                            Math.round(scoring.crawlability),
-                            "/100")),
-                    React.createElement(Box, { marginTop: 0.5 }, renderProgressBar(scoring.crawlability)))),
-                scoring?.structure !== undefined && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-                    React.createElement(Box, { justifyContent: "space-between" },
-                        React.createElement(Text, { bold: true }, "\uD83D\uDCD0 Structure"),
-                        React.createElement(Text, null,
-                            Math.round(scoring.structure),
-                            "/100")),
-                    React.createElement(Box, { marginTop: 0.5 }, renderProgressBar(scoring.structure)))),
-                scoring?.schema_coverage !== undefined && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-                    React.createElement(Box, { justifyContent: "space-between" },
-                        React.createElement(Text, { bold: true }, "\uD83C\uDFF7\uFE0F  Schema Coverage"),
-                        React.createElement(Text, null,
-                            Math.round(scoring.schema_coverage),
-                            "/100")),
-                    React.createElement(Box, { marginTop: 0.5 }, renderProgressBar(scoring.schema_coverage)))),
-                scoring?.content_clarity !== undefined && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-                    React.createElement(Box, { justifyContent: "space-between" },
-                        React.createElement(Text, { bold: true }, "\uD83D\uDCDD Content Clarity"),
-                        React.createElement(Text, null,
-                            Math.round(scoring.content_clarity),
-                            "/100")),
-                    React.createElement(Box, { marginTop: 0.5 }, renderProgressBar(scoring.content_clarity)))))),
-        result.chunking && Object.keys(result.chunking).length > 0 ? (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, "\uD83D\uDCC4 Content Chunking Analysis"),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Strategy:"),
-                    " ",
-                    result.chunking.chunkingStrategy),
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Total Chunks:"),
-                    " ",
-                    result.chunking.totalChunks),
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Avg Tokens/Chunk:"),
-                    " ",
-                    result.chunking.averageTokensPerChunk),
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Avg Noise Ratio:"),
-                    " ",
-                    (result.chunking.averageNoiseRatio * 100).toFixed(1),
-                    "%")),
-            result.chunking.chunkingStrategy === 'heading-based' && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "green" }, "\u2713 Heading-based chunking is ideal for AI comprehension"))),
-            result.chunking.chunkingStrategy === 'paragraph-based' && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "yellow" }, "\u26A0 Consider adding headings for better semantic structure"))))) : (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "\uD83D\uDCA1 Enable chunking analysis with --enable-chunking to see how your content is divided for AI processing"))),
-        result.extractability && Object.keys(result.extractability).length > 0 ? (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, "\uD83D\uDD04 Extractability Analysis"),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Overall Score:"),
-                    " ",
-                    result.extractability.score.extractabilityScore,
-                    "/100"),
-                React.createElement(Text, null,
-                    React.createElement(Text, { bold: true }, "Server-Rendered:"),
-                    " ",
-                    result.extractability.score.serverRenderedPercent,
-                    "%")),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, { bold: true, underline: true }, "Content Type Extractability:"),
-                Object.entries(result.extractability.contentTypes).map(([type, data]) => {
-                    const percentage = data.percentage;
-                    const color = percentage >= 80 ? 'green' : percentage >= 50 ? 'yellow' : 'red';
-                    return (React.createElement(Box, { key: type, marginTop: 0.5 },
-                        React.createElement(Text, null,
-                            React.createElement(Text, { bold: true },
-                                type.charAt(0).toUpperCase() + type.slice(1),
-                                ":"),
-                            ' ',
-                            React.createElement(Text, { color: color },
-                                percentage,
-                                "%"),
-                            ' ',
-                            React.createElement(Text, { dimColor: true },
-                                "(",
-                                data.extractable,
-                                "/",
-                                data.total,
-                                ")"))));
-                })),
-            result.extractability.score.extractabilityScore >= 80 && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "green" }, "\u2713 Good extractability - AI can easily read your content"))),
-            result.extractability.score.extractabilityScore < 50 && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "red" }, "\u26A0 Low extractability - Consider server-side rendering"))))) : (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "\uD83D\uDCA1 Enable extractability analysis with --enable-extractability to see how well AI can extract your content")))));
-};

package/dist/utils/comprehensive-formatter.d.ts

@@ -1,5 +0,0 @@
-/**
- * Comprehensive CLI formatter that displays all data shown on the website
- */
-export declare function formatComprehensiveReport(result: any, aiReadiness: any): string;
-export declare function formatDetailedIssues(issues: any[]): string;

package/dist/utils/comprehensive-formatter.js

@@ -1,370 +0,0 @@
-import chalk from 'chalk';
-/**
- * Comprehensive CLI formatter that displays all data shown on the website
- */
-export function formatComprehensiveReport(result, aiReadiness) {
-    const sections = [];
-    // LLM/AI Understanding Section
-    if (result.llm) {
-        sections.push(formatLLMSection(result.llm));
-    }
-    // Chunking Section
-    if (result.chunking) {
-        sections.push(formatChunkingSection(result.chunking));
-    }
-    // Extractability Section
-    if (result.extractability) {
-        sections.push(formatExtractabilitySection(result.extractability));
-    }
-    // Hallucination Risk Section
-    if (result.hallucinationReport) {
-        sections.push(formatHallucinationSection(result.hallucinationReport));
-    }
-    // Mirror Report Section
-    if (result.mirrorReport) {
-        sections.push(formatMirrorReportSection(result.mirrorReport));
-    }
-    // Dimension Scores
-    if (aiReadiness?.dimensions) {
-        sections.push(formatDimensionsSection(aiReadiness.dimensions));
-    }
-    // Quick Wins
-    if (aiReadiness?.quickWins && aiReadiness.quickWins.length > 0) {
-        sections.push(formatQuickWinsSection(aiReadiness.quickWins));
-    }
-    return sections.join('\n\n');
-}
-function formatLLMSection(llm) {
-    const lines = [];
-    lines.push(chalk.bold.blue('📝 AI Understanding Analysis'));
-    lines.push('─'.repeat(70));
-    if (llm.summary) {
-        lines.push(chalk.bold('Summary:'));
-        lines.push(`  ${llm.summary}`);
-        lines.push('');
-    }
-    if (llm.pageType) {
-        lines.push(chalk.bold('Inferred Page Type:'));
-        lines.push(`  ${chalk.magenta.bold(llm.pageType)}`);
-        if (llm.pageTypeInsights && llm.pageTypeInsights.length > 0) {
-            lines.push('');
-            lines.push(chalk.bold('💡 AI-Generated Insights:'));
-            llm.pageTypeInsights.forEach((insight) => {
-                lines.push(`  ${chalk.cyan('•')} ${insight}`);
-            });
-        }
-        lines.push('');
-    }
-    if (llm.keyTopics && llm.keyTopics.length > 0) {
-        lines.push(chalk.bold('Key Topics:'));
-        lines.push(`  ${llm.keyTopics.map((t) => chalk.blue(t)).join(', ')}`);
-        lines.push('');
-    }
-    const metadata = [];
-    if (llm.readingLevel) {
-        metadata.push(`Reading Level: ${llm.readingLevel.description}`);
-    }
-    if (llm.sentiment) {
-        metadata.push(`Sentiment: ${llm.sentiment}`);
-    }
-    if (llm.technicalDepth) {
-        metadata.push(`Technical Depth: ${llm.technicalDepth}`);
-    }
-    if (metadata.length > 0) {
-        lines.push(chalk.bold('Metadata:'));
-        metadata.forEach(m => lines.push(`  ${m}`));
-        lines.push('');
-    }
-    if (llm.topEntities && llm.topEntities.length > 0) {
-        lines.push(chalk.bold('🔍 Key Entities:'));
-        llm.topEntities.slice(0, 5).forEach((entity) => {
-            const relevance = entity.relevance ? ` - ${Math.round(entity.relevance * 100)}% relevance` : '';
-            lines.push(`  ${chalk.cyan('•')} ${chalk.bold(entity.name)} ${chalk.dim(`(${entity.type})${relevance}`)}`);
-        });
-        lines.push('');
-    }
-    if (llm.questions && llm.questions.length > 0) {
-        lines.push(chalk.bold('❓ Questions AI Can Answer:'));
-        llm.questions.slice(0, 5).forEach((q, idx) => {
-            const difficulty = chalk.dim(`[${q.difficulty.toUpperCase()}]`);
-            lines.push(`  ${idx + 1}. ${difficulty} ${q.question}`);
-        });
-        lines.push('');
-    }
-    if (llm.suggestedFAQ && llm.suggestedFAQ.length > 0) {
-        lines.push(chalk.bold('💡 Suggested FAQs:'));
-        llm.suggestedFAQ
-            .filter((f) => f.importance === 'high')
-            .slice(0, 3)
-            .forEach((faq, idx) => {
-            lines.push(`  ${idx + 1}. Q: ${chalk.yellow(faq.question)}`);
-            lines.push(`     A: ${chalk.dim(faq.suggestedAnswer)}`);
-        });
-    }
-    return lines.join('\n');
-}
-function formatChunkingSection(chunking) {
-    const lines = [];
-    lines.push(chalk.bold.green('📄 Content Chunking Analysis'));
-    lines.push('─'.repeat(70));
-    const grid = [
-        ['Strategy', chunking.chunkingStrategy],
-        ['Total Chunks', chunking.totalChunks.toString()],
-        ['Avg Tokens/Chunk', chunking.averageTokensPerChunk.toString()],
-        ['Avg Noise Ratio', `${(chunking.averageNoiseRatio * 100).toFixed(1)}%`],
-    ];
-    grid.forEach(([label, value]) => {
-        lines.push(`  ${chalk.bold(label + ':').padEnd(25)} ${chalk.cyan(value)}`);
-    });
-    if (chunking.chunkingStrategy === 'heading-based') {
-        lines.push('');
-        lines.push(chalk.green('  ✓ Heading-based chunking is ideal for AI comprehension'));
-    }
-    else if (chunking.chunkingStrategy === 'paragraph-based') {
-        lines.push('');
-        lines.push(chalk.yellow('  ⚠ Consider adding headings for better semantic structure'));
-    }
-    if (chunking.chunks && chunking.chunks.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('Chunk Distribution:'));
-        // Show token distribution
-        const tokenCounts = chunking.chunks.map((c) => c.tokenCount);
-        const min = Math.min(...tokenCounts);
-        const max = Math.max(...tokenCounts);
-        const avg = tokenCounts.reduce((a, b) => a + b, 0) / tokenCounts.length;
-        lines.push(`  Min Tokens: ${min}, Max Tokens: ${max}, Avg: ${avg.toFixed(0)}`);
-        // Show noise distribution
-        const noiseRatios = chunking.chunks.map((c) => c.noiseRatio);
-        const avgNoise = noiseRatios.reduce((a, b) => a + b, 0) / noiseRatios.length;
-        lines.push(`  Avg Noise per Chunk: ${(avgNoise * 100).toFixed(1)}%`);
-    }
-    return lines.join('\n');
-}
-function formatExtractabilitySection(extractability) {
-    const lines = [];
-    lines.push(chalk.bold.yellow('🔄 Extractability Analysis'));
-    lines.push('─'.repeat(70));
-    const grid = [
-        ['Overall Score', `${extractability.score.extractabilityScore}/100`],
-        ['Server-Rendered', `${extractability.score.serverRenderedPercent}%`],
-    ];
-    grid.forEach(([label, value]) => {
-        lines.push(`  ${chalk.bold(label + ':').padEnd(25)} ${chalk.cyan(value)}`);
-    });
-    lines.push('');
-    lines.push(chalk.bold('Content Type Extractability:'));
-    Object.entries(extractability.contentTypes).forEach(([type, data]) => {
-        const percentage = data.percentage;
-        const color = percentage >= 80 ? chalk.green : percentage >= 50 ? chalk.yellow : chalk.red;
-        lines.push(`  ${chalk.bold(type.charAt(0).toUpperCase() + type.slice(1) + ':').padEnd(15)} ${color(`${percentage}%`)} (${data.extractable}/${data.total})`);
-    });
-    const overallScore = extractability.score.extractabilityScore;
-    if (overallScore >= 80) {
-        lines.push('');
-        lines.push(chalk.green('  ✓ Good extractability - AI can easily read your content'));
-    }
-    else if (overallScore < 50) {
-        lines.push('');
-        lines.push(chalk.red('  ⚠ Low extractability - Consider server-side rendering'));
-    }
-    return lines.join('\n');
-}
-function formatHallucinationSection(report) {
-    const lines = [];
-    lines.push(chalk.bold.red('⚠️  Hallucination Risk Assessment'));
-    lines.push('─'.repeat(70));
-    const riskScore = report.hallucinationRiskScore;
-    const riskColor = riskScore >= 70 ? chalk.red : riskScore >= 40 ? chalk.yellow : chalk.green;
-    lines.push(`  ${chalk.bold('Risk Score:')} ${riskColor.bold(`${riskScore}/100`)}`);
-    if (report.factCheckSummary) {
-        lines.push('');
-        lines.push(chalk.bold('Fact Check Summary:'));
-        const summary = report.factCheckSummary;
-        lines.push(`  Total Facts:      ${chalk.cyan(summary.totalFacts)}`);
-        lines.push(`  Verified:         ${chalk.green(summary.verifiedFacts)}`);
-        lines.push(`  Unverified:       ${chalk.yellow(summary.unverifiedFacts)}`);
-        lines.push(`  Contradictions:   ${chalk.red(summary.contradictions)}`);
-        if (summary.ambiguities !== undefined) {
-            lines.push(`  Ambiguities:      ${chalk.yellow(summary.ambiguities)}`);
-        }
-    }
-    if (report.factCheckSummary && report.factCheckSummary.unverifiedFacts > 0) {
-        lines.push('');
-        lines.push(chalk.yellow('💡 Tip: Add citations and links to verify claims and reduce AI hallucination risk'));
-    }
-    if (report.triggers && report.triggers.length > 0) {
-        const highSeverityTriggers = report.triggers.filter((t) => t.severity === 'high' || t.severity === 'critical');
-        if (highSeverityTriggers.length > 0) {
-            lines.push('');
-            lines.push(chalk.bold('🚨 High-Risk Triggers:'));
-            highSeverityTriggers.slice(0, 5).forEach((trigger, idx) => {
-                lines.push(`  ${idx + 1}. ${chalk.red(`[${trigger.severity.toUpperCase()}]`)} ${trigger.type}`);
-                lines.push(`     ${chalk.dim(trigger.description)}`);
-                if (trigger.confidence) {
-                    lines.push(`     ${chalk.dim(`Confidence: ${Math.round(trigger.confidence * 100)}%`)}`);
-                }
-            });
-        }
-    }
-    if (report.recommendations && report.recommendations.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('💡 Recommendations:'));
-        report.recommendations.slice(0, 3).forEach((rec, idx) => {
-            lines.push(`  ${idx + 1}. ${rec}`);
-        });
-    }
-    return lines.join('\n');
-}
-function formatMirrorReportSection(report) {
-    const lines = [];
-    lines.push(chalk.bold.magenta('🔍 AI Misunderstanding Check'));
-    lines.push('─'.repeat(70));
-    const alignmentColor = report.summary.alignmentScore >= 80 ? chalk.green :
-        report.summary.alignmentScore >= 60 ? chalk.yellow : chalk.red;
-    const clarityColor = report.summary.clarityScore >= 80 ? chalk.green :
-        report.summary.clarityScore >= 60 ? chalk.yellow : chalk.red;
-    lines.push(`  ${chalk.bold('Alignment Score:').padEnd(25)} ${alignmentColor.bold(`${report.summary.alignmentScore}/100`)}`);
-    lines.push(`  ${chalk.bold('Clarity Score:').padEnd(25)} ${clarityColor.bold(`${report.summary.clarityScore}/100`)}`);
-    lines.push(`  ${chalk.bold('Critical Issues:').padEnd(25)} ${chalk.red(report.summary.critical)}`);
-    lines.push(`  ${chalk.bold('Major Issues:').padEnd(25)} ${chalk.yellow(report.summary.major)}`);
-    // AI Interpretation - What AI Actually Understood
-    if (report.llmInterpretation) {
-        lines.push('');
-        lines.push(chalk.bold.blue('🤖 What AI Actually Understood'));
-        lines.push(chalk.dim(`   (${Math.round(report.llmInterpretation.confidence * 100)}% confident)`));
-        if (report.llmInterpretation.productName) {
-            lines.push(`  ${chalk.bold('Product:')} ${report.llmInterpretation.productName}`);
-        }
-        if (report.llmInterpretation.purpose) {
-            lines.push(`  ${chalk.bold('Purpose:')} ${report.llmInterpretation.purpose}`);
-        }
-        if (report.llmInterpretation.valueProposition) {
-            lines.push(`  ${chalk.bold.magenta('💎 Value:')} ${report.llmInterpretation.valueProposition}`);
-        }
-        if (report.llmInterpretation.keyBenefits && report.llmInterpretation.keyBenefits.length > 0) {
-            lines.push(`  ${chalk.bold('Benefits:')}`);
-            report.llmInterpretation.keyBenefits.forEach((benefit) => {
-                lines.push(`    • ${benefit}`);
-            });
-        }
-        if (report.llmInterpretation.keyFeatures && report.llmInterpretation.keyFeatures.length > 0) {
-            lines.push(`  ${chalk.bold('Features:')}`);
-            report.llmInterpretation.keyFeatures.slice(0, 3).forEach((feature) => {
-                lines.push(`    • ${feature}`);
-            });
-        }
-        if (report.llmInterpretation.targetAudience) {
-            lines.push(`  ${chalk.bold('Audience:')} ${report.llmInterpretation.targetAudience}`);
-        }
-    }
-    if (report.mismatches && report.mismatches.length > 0) {
-        const priorityMismatches = report.mismatches.filter((m) => m.severity === 'critical' || m.severity === 'major');
-        if (priorityMismatches.length > 0) {
-            lines.push('');
-            lines.push(chalk.bold('Priority Mismatches:'));
-            priorityMismatches.slice(0, 5).forEach((mismatch, idx) => {
-                const icon = mismatch.severity === 'critical' ? '🔴' : '🟡';
-                lines.push(`  ${icon} ${idx + 1}. ${chalk.bold(mismatch.field)}`);
-                lines.push(`     ${chalk.dim(mismatch.description)}`);
-                lines.push(`     ${chalk.cyan('→')} ${mismatch.recommendation}`);
-            });
-        }
-    }
-    if (report.recommendations && report.recommendations.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('💡 Top Recommendations:'));
-        report.recommendations.slice(0, 3).forEach((rec, idx) => {
-            lines.push(`  ${idx + 1}. ${rec}`);
-        });
-    }
-    return lines.join('\n');
-}
-function formatDimensionsSection(dimensions) {
-    const lines = [];
-    lines.push(chalk.bold.cyan('🎯 Dimension Analysis'));
-    lines.push('─'.repeat(70));
-    const dimensionDescriptions = {
-        technical: '⚙️  Technical',
-        contentQuality: '📝 Content Quality',
-        crawlability: '🕷️  Crawlability',
-        discoverability: '🔍 Discoverability',
-        knowledge: '🧠 Knowledge',
-        extractability: '🔄 Extractability',
-        comprehensibility: '💡 Comprehensibility',
-        trustworthiness: '✅ Trustworthiness',
-        accessibility: '♿ Accessibility',
-    };
-    Object.entries(dimensions).forEach(([key, dim]) => {
-        const name = dimensionDescriptions[key] || key;
-        const scoreColor = dim.score >= 90 ? chalk.green :
-            dim.score >= 75 ? chalk.yellow :
-                dim.score >= 60 ? chalk.hex('#FFA500') : chalk.red;
-        lines.push('');
-        lines.push(`${name}: ${scoreColor.bold(`${Math.round(dim.score)}/100`)} ${chalk.dim(`(${dim.status})`)}`);
-        if (dim.strengths && dim.strengths.length > 0) {
-            lines.push(`  ${chalk.green('Strengths:')} ${dim.strengths.join(', ')}`);
-        }
-        if (dim.weaknesses && dim.weaknesses.length > 0) {
-            lines.push(`  ${chalk.yellow('Weaknesses:')} ${dim.weaknesses.join(', ')}`);
-        }
-        if (dim.recommendation) {
-            lines.push(`  ${chalk.cyan('→')} ${dim.recommendation}`);
-        }
-    });
-    return lines.join('\n');
-}
-function formatQuickWinsSection(quickWins) {
-    const lines = [];
-    lines.push(chalk.bold.yellow('⚡ Quick Wins (High Impact, Low Effort)'));
-    lines.push('─'.repeat(70));
-    quickWins.slice(0, 5).forEach((win, idx) => {
-        lines.push('');
-        lines.push(`${chalk.bold(`${idx + 1}.`)} ${chalk.yellow(win.issue)}`);
-        lines.push(`   ${chalk.dim(`Impact: ${win.impact} · Effort: ${win.effort}`)}`);
-        lines.push(`   ${chalk.cyan('→')} ${win.fix}`);
-    });
-    return lines.join('\n');
-}
-export function formatDetailedIssues(issues) {
-    const lines = [];
-    lines.push(chalk.bold('⚠️  All Issues'));
-    lines.push('─'.repeat(70));
-    // Group by severity
-    const grouped = {
-        critical: issues.filter(i => i.severity === 'critical'),
-        high: issues.filter(i => i.severity === 'high'),
-        medium: issues.filter(i => i.severity === 'medium'),
-        low: issues.filter(i => i.severity === 'low'),
-    };
-    // Stats
-    lines.push('');
-    lines.push(chalk.bold('Issue Count by Severity:'));
-    lines.push(`  Critical: ${chalk.red.bold(grouped.critical.length)}`);
-    lines.push(`  High:     ${chalk.yellow.bold(grouped.high.length)}`);
-    lines.push(`  Medium:   ${chalk.blue.bold(grouped.medium.length)}`);
-    lines.push(`  Low:      ${chalk.dim(grouped.low.length)}`);
-    // Show all issues by severity
-    for (const [severity, severityIssues] of Object.entries(grouped)) {
-        if (severityIssues.length === 0)
-            continue;
-        lines.push('');
-        lines.push(chalk.bold(`${severity.toUpperCase()} Issues:`));
-        severityIssues.forEach((issue, idx) => {
-            const icon = severity === 'critical' ? '🔴' :
-                severity === 'high' ? '🟠' :
-                    severity === 'medium' ? '🟡' : '🔵';
-            lines.push('');
-            lines.push(`${icon} ${idx + 1}. ${chalk.bold(issue.message || issue.title)}`);
-            lines.push(`   ${chalk.dim(`Category: ${issue.category} · Impact: ${issue.impact}`)}`);
-            if (issue.evidence) {
-                const evidenceText = typeof issue.evidence === 'string' ? issue.evidence : issue.evidence.join(', ');
-                lines.push(`   ${chalk.dim(evidenceText.substring(0, 100))}${evidenceText.length > 100 ? '...' : ''}`);
-            }
-            if (issue.element) {
-                lines.push(`   ${chalk.dim(issue.element.substring(0, 100))}${issue.element.length > 100 ? '...' : ''}`);
-            }
-            lines.push(`   ${chalk.cyan('💡 Fix:')} ${issue.suggested_fix || issue.remediation}`);
-        });
-    }
-    return lines.join('\n');
-}