@ai-lighthouse/cli 1.0.0

package/dist/ui/components/MessageAlignmentSection.js

@@ -0,0 +1,108 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const MessageAlignmentSection = ({ mirrorReport }) => {
+    if (!mirrorReport || Object.keys(mirrorReport).length === 0) {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1 },
+                React.createElement(Text, { bold: true, color: "yellow" }, "\uD83D\uDCA1 Enable Message Alignment Analysis"),
+                React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                    React.createElement(Text, null, "Message alignment analysis is not available. To see what AI understands, run:"),
+                    React.createElement(Box, { marginTop: 1, borderStyle: "single", paddingX: 1 },
+                        React.createElement(Text, { color: "cyan" }, "ai-lighthouse audit [URL] --enable-llm --llm-provider openai --llm-api-key YOUR_KEY")),
+                    React.createElement(Box, { marginTop: 1 },
+                        React.createElement(Text, { dimColor: true }, "This requires LLM analysis to compare AI understanding with your intended message"))))));
+    }
+    const getScoreColor = (score) => {
+        if (score >= 80)
+            return 'green';
+        if (score >= 60)
+            return 'yellow';
+        return 'red';
+    };
+    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "magenta" }, "\uD83D\uDD0D AI Misunderstanding Check"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Alignment Score:"),
+                        ' ',
+                        React.createElement(Text, { bold: true, color: getScoreColor(mirrorReport.summary.alignmentScore) },
+                            mirrorReport.summary.alignmentScore,
+                            "/100"))),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Clarity Score:"),
+                        ' ',
+                        React.createElement(Text, { bold: true, color: getScoreColor(mirrorReport.summary.clarityScore) },
+                            mirrorReport.summary.clarityScore,
+                            "/100"))),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Critical Issues:"),
+                        ' ',
+                        React.createElement(Text, { color: "red" }, mirrorReport.summary.critical))),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Major Issues:"),
+                        ' ',
+                        React.createElement(Text, { color: "yellow" }, mirrorReport.summary.major))))),
+        mirrorReport.llmInterpretation && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "blue" }, "\uD83E\uDD16 What AI Actually Understood"),
+            React.createElement(Text, { dimColor: true },
+                "(",
+                Math.round(mirrorReport.llmInterpretation.confidence * 100),
+                "% confident)"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                mirrorReport.llmInterpretation.productName && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Product:"),
+                    " ",
+                    mirrorReport.llmInterpretation.productName)),
+                mirrorReport.llmInterpretation.purpose && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Purpose:"),
+                    " ",
+                    mirrorReport.llmInterpretation.purpose)),
+                mirrorReport.llmInterpretation.valueProposition && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true, color: "magenta" }, "\uD83D\uDC8E Value:"),
+                    " ",
+                    mirrorReport.llmInterpretation.valueProposition))),
+            mirrorReport.llmInterpretation.keyBenefits && mirrorReport.llmInterpretation.keyBenefits.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { bold: true }, "Benefits:"),
+                mirrorReport.llmInterpretation.keyBenefits.map((benefit, idx) => (React.createElement(Text, { key: idx },
+                    "\u2022 ",
+                    benefit))))),
+            mirrorReport.llmInterpretation.keyFeatures && mirrorReport.llmInterpretation.keyFeatures.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { bold: true }, "Features:"),
+                mirrorReport.llmInterpretation.keyFeatures.slice(0, 3).map((feature, idx) => (React.createElement(Text, { key: idx },
+                    "\u2022 ",
+                    feature))))),
+            mirrorReport.llmInterpretation.targetAudience && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Audience:"),
+                    " ",
+                    mirrorReport.llmInterpretation.targetAudience))))),
+        mirrorReport.mismatches && mirrorReport.mismatches.length > 0 && (React.createElement(React.Fragment, null, mirrorReport.mismatches.filter((m) => m.severity === 'critical' || m.severity === 'major').length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "Priority Mismatches"),
+            mirrorReport.mismatches
+                .filter((m) => m.severity === 'critical' || m.severity === 'major')
+                .slice(0, 5)
+                .map((mismatch, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", borderStyle: "single", borderColor: mismatch.severity === 'critical' ? 'red' : 'yellow', paddingX: 1, paddingY: 0.5, marginTop: 1 },
+                React.createElement(Text, null,
+                    mismatch.severity === 'critical' ? '🔴' : '🟡',
+                    " ",
+                    idx + 1,
+                    ". ",
+                    React.createElement(Text, { bold: true }, mismatch.field)),
+                React.createElement(Text, { dimColor: true }, mismatch.description),
+                React.createElement(Box, { marginTop: 0.5 },
+                    React.createElement(Text, { color: "cyan" },
+                        "\u2192 ",
+                        mismatch.recommendation))))))))),
+        mirrorReport.recommendations && mirrorReport.recommendations.length > 0 && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, underline: true, color: "cyan" }, "\uD83D\uDCA1 Top Recommendations"),
+            mirrorReport.recommendations.slice(0, 3).map((rec, idx) => (React.createElement(Box, { key: idx, marginTop: 0.5 },
+                React.createElement(Text, { color: "cyan" },
+                    idx + 1,
+                    ". ",
+                    rec))))))));
+};

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

@@ -0,0 +1,6 @@
+import React from 'react';
+interface OverviewSectionProps {
+    aiReadiness: any;
+}
+export declare const OverviewSection: React.FC<OverviewSectionProps>;
+export {};

package/dist/ui/components/OverviewSection.js

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,41 @@
+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

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

package/dist/ui/components/TechnicalSection.js

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,5 @@
+/**
+ * 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;