@ai-lighthouse/cli 1.0.0

package/dist/ui/AuditReportUI.js

@@ -0,0 +1,76 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { ScoreDisplay } from './components/ScoreDisplay.js';
+import { OverviewSection } from './components/OverviewSection.js';
+import { IssuesSection } from './components/IssuesSection.js';
+import { AIUnderstandingSection } from './components/AIUnderstandingSection.js';
+import { HallucinationSection } from './components/HallucinationSection.js';
+import { MessageAlignmentSection } from './components/MessageAlignmentSection.js';
+import { TechnicalSection } from './components/TechnicalSection.js';
+export const AuditReportUI = ({ url, result, aiReadiness, loading = false, currentStep = '', }) => {
+    const [currentTab, setCurrentTab] = useState('overview');
+    const tabs = [
+        { key: 'overview', label: 'Overview', icon: '📊' },
+        { key: 'issues', label: 'Issues', icon: '⚠️' },
+        { key: 'ai-understanding', label: 'AI Understanding', icon: '🧠' },
+        { key: 'hallucination', label: 'Hallucination Risk', icon: '⚠️' },
+        { key: 'message-alignment', label: 'Message Alignment', icon: '🔍' },
+        { key: 'technical', label: 'Technical', icon: '⚙️' },
+    ];
+    useInput((input, key) => {
+        if (loading)
+            return;
+        if (key.leftArrow) {
+            const currentIndex = tabs.findIndex(t => t.key === currentTab);
+            const prevIndex = currentIndex > 0 ? currentIndex - 1 : tabs.length - 1;
+            setCurrentTab(tabs[prevIndex].key);
+        }
+        if (key.rightArrow) {
+            const currentIndex = tabs.findIndex(t => t.key === currentTab);
+            const nextIndex = currentIndex < tabs.length - 1 ? currentIndex + 1 : 0;
+            setCurrentTab(tabs[nextIndex].key);
+        }
+        // Number keys for quick tab switching
+        const num = parseInt(input);
+        if (num >= 1 && num <= tabs.length) {
+            setCurrentTab(tabs[num - 1].key);
+        }
+    });
+    if (loading) {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "green" },
+                    React.createElement(Spinner, { type: "dots" })),
+                React.createElement(Text, null,
+                    " ",
+                    currentStep || 'Loading...'))));
+    }
+    const overallScore = aiReadiness?.overall || 0;
+    const grade = aiReadiness?.grade || 'N/A';
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "\uD83D\uDEA8 AI Lighthouse Report")),
+        React.createElement(ScoreDisplay, { score: overallScore, grade: grade, url: url }),
+        React.createElement(Box, { flexDirection: "row", borderStyle: "single", borderColor: "blue", paddingX: 1, marginTop: 1 }, tabs.map((tab, index) => {
+            const isActive = tab.key === currentTab;
+            return (React.createElement(Box, { key: tab.key, marginRight: 1 },
+                React.createElement(Text, { bold: isActive, color: isActive ? 'cyan' : 'gray', backgroundColor: isActive ? 'blue' : undefined }, ` ${index + 1}. ${tab.icon} ${tab.label} `)));
+        })),
+        React.createElement(Box, { marginTop: 1, marginBottom: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Use \u2190 \u2192 arrow keys or numbers (1-",
+                tabs.length,
+                ") to navigate tabs")),
+        React.createElement(Box, { flexDirection: "column" },
+            currentTab === 'overview' && React.createElement(OverviewSection, { aiReadiness: aiReadiness }),
+            currentTab === 'issues' && React.createElement(IssuesSection, { issues: result.issues || [] }),
+            currentTab === 'ai-understanding' && React.createElement(AIUnderstandingSection, { llm: result.llm }),
+            currentTab === 'hallucination' && React.createElement(HallucinationSection, { hallucinationReport: result.hallucinationReport }),
+            currentTab === 'message-alignment' && React.createElement(MessageAlignmentSection, { mirrorReport: result.mirrorReport }),
+            currentTab === 'technical' && React.createElement(TechnicalSection, { result: result, scoring: result.scoring })),
+        React.createElement(Box, { marginTop: 2, borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press Ctrl+C to exit \u2022 Report generated at ",
+                new Date().toLocaleString()))));
+};

package/dist/ui/SetupWizard.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface SetupWizardProps {
+    onComplete: (config: AuditConfig) => void;
+    initialUrl?: string;
+}
+export interface AuditConfig {
+    url: string;
+    enableLlm: boolean;
+    enableChunking: boolean;
+    enableExtractability: boolean;
+    enableHallucination: boolean;
+    llmProvider?: string;
+    llmModel?: string;
+    llmApiKey?: string;
+    llmBaseUrl?: string;
+}
+export declare const SetupWizard: React.FC<SetupWizardProps>;
+export {};

package/dist/ui/SetupWizard.js

@@ -0,0 +1,179 @@
+import React, { useState } from 'react';
+import { Box, Text, useApp } from 'ink';
+import TextInput from 'ink-text-input';
+import SelectInput from 'ink-select-input';
+export const SetupWizard = ({ onComplete, initialUrl }) => {
+    const { exit } = useApp();
+    const [step, setStep] = useState(initialUrl ? 'features' : 'url');
+    const [url, setUrl] = useState(initialUrl || '');
+    const [selectedFeatures, setSelectedFeatures] = useState([]);
+    const [llmProvider, setLlmProvider] = useState('');
+    const [llmModel, setLlmModel] = useState('');
+    const [llmApiKey, setLlmApiKey] = useState('');
+    const [llmBaseUrl, setLlmBaseUrl] = useState('');
+    const featureOptions = [
+        { label: '🧠 AI Understanding (LLM Analysis)', value: 'llm' },
+        { label: '📄 Content Chunking Analysis', value: 'chunking' },
+        { label: '🔄 Extractability Analysis', value: 'extractability' },
+        { label: '⚠️  Hallucination Detection', value: 'hallucination' },
+        { label: '✅ Continue with selected features', value: 'done' },
+    ];
+    const llmProviderOptions = [
+        { label: 'OpenAI (GPT-4, GPT-3.5)', value: 'openai' },
+        { label: 'Anthropic (Claude)', value: 'anthropic' },
+        { label: 'Ollama (Local)', value: 'ollama' },
+        { label: 'Custom/Local Provider', value: 'local' },
+    ];
+    const handleUrlSubmit = (value) => {
+        setUrl(value);
+        setStep('features');
+    };
+    const handleFeatureSelect = (item) => {
+        if (item.value === 'done') {
+            // Check if LLM is needed
+            if (selectedFeatures.includes('llm') || selectedFeatures.includes('hallucination')) {
+                setStep('llm-provider');
+            }
+            else {
+                completeSetup();
+            }
+        }
+        else {
+            // Toggle feature selection
+            if (selectedFeatures.includes(item.value)) {
+                setSelectedFeatures(selectedFeatures.filter(f => f !== item.value));
+            }
+            else {
+                setSelectedFeatures([...selectedFeatures, item.value]);
+            }
+        }
+    };
+    const handleLlmProviderSelect = (item) => {
+        setLlmProvider(item.value);
+        // Set default base URL for ollama
+        if (item.value === 'ollama') {
+            setLlmBaseUrl('http://localhost:11434');
+        }
+        setStep('llm-model');
+    };
+    const handleLlmModelSubmit = (value) => {
+        setLlmModel(value);
+        // If ollama, skip API key and go to base URL
+        if (llmProvider === 'ollama') {
+            setStep('llm-base-url');
+        }
+        else {
+            setStep('llm-api-key');
+        }
+    };
+    const handleLlmApiKeySubmit = (value) => {
+        setLlmApiKey(value);
+        // If provider needs base URL, go there, otherwise complete
+        if (llmProvider === 'local' || llmProvider === 'anthropic') {
+            setStep('llm-base-url');
+        }
+        else {
+            completeSetup();
+        }
+    };
+    const handleLlmBaseUrlSubmit = (value) => {
+        setLlmBaseUrl(value);
+        completeSetup();
+    };
+    const completeSetup = () => {
+        const config = {
+            url,
+            enableLlm: selectedFeatures.includes('llm') || selectedFeatures.includes('hallucination'),
+            enableChunking: selectedFeatures.includes('chunking'),
+            enableExtractability: selectedFeatures.includes('extractability'),
+            enableHallucination: selectedFeatures.includes('hallucination'),
+        };
+        if (config.enableLlm) {
+            config.llmProvider = llmProvider;
+            config.llmModel = llmModel;
+            config.llmApiKey = llmApiKey || undefined;
+            config.llmBaseUrl = llmBaseUrl || undefined;
+        }
+        onComplete(config);
+        // Exit the wizard app
+        exit();
+    };
+    const getModelPlaceholder = () => {
+        switch (llmProvider) {
+            case 'openai':
+                return 'gpt-4o-mini (default)';
+            case 'anthropic':
+                return 'claude-3-5-sonnet-20241022 (default)';
+            case 'ollama':
+                return 'qwen2.5:0.5b';
+            default:
+                return 'model-name';
+        }
+    };
+    const getApiKeyPlaceholder = () => {
+        switch (llmProvider) {
+            case 'openai':
+                return 'sk-...';
+            case 'anthropic':
+                return 'sk-ant-...';
+            default:
+                return 'your-api-key';
+        }
+    };
+    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" }, "\uD83D\uDEA8 AI Lighthouse Setup Wizard"),
+            React.createElement(Text, { dimColor: true }, "Configure your audit settings")),
+        step === 'url' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Enter the URL to audit:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "cyan" }, "URL: "),
+                React.createElement(TextInput, { value: url, onChange: setUrl, onSubmit: handleUrlSubmit, placeholder: "https://example.com" })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to continue")))),
+        step === 'features' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Select features to enable:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Selected: ",
+                    selectedFeatures.length === 0 ? 'None (basic audit only)' : selectedFeatures.map(f => {
+                        const feature = featureOptions.find(opt => opt.value === f);
+                        return feature?.label.split(' ')[0];
+                    }).join(', '))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: featureOptions.map(opt => ({
+                        ...opt,
+                        label: selectedFeatures.includes(opt.value) && opt.value !== 'done'
+                            ? `✓ ${opt.label}`
+                            : opt.label,
+                    })), onSelect: handleFeatureSelect })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Use \u2191\u2193 to navigate, Enter to toggle/continue")))),
+        step === 'llm-provider' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Select LLM provider:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: llmProviderOptions, onSelect: handleLlmProviderSelect })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Use \u2191\u2193 to navigate, Enter to select")))),
+        step === 'llm-model' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Enter LLM model name:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "cyan" }, "Model: "),
+                React.createElement(TextInput, { value: llmModel, onChange: setLlmModel, onSubmit: handleLlmModelSubmit, placeholder: getModelPlaceholder() })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Leave empty for default, or press Enter to continue")))),
+        step === 'llm-api-key' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Enter API key:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "cyan" }, "API Key: "),
+                React.createElement(TextInput, { value: llmApiKey, onChange: setLlmApiKey, onSubmit: handleLlmApiKeySubmit, placeholder: getApiKeyPlaceholder(), mask: "*" })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Your API key will not be stored")))),
+        step === 'llm-base-url' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Enter API base URL (optional):"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "cyan" }, "Base URL: "),
+                React.createElement(TextInput, { value: llmBaseUrl, onChange: setLlmBaseUrl, onSubmit: handleLlmBaseUrlSubmit, placeholder: llmProvider === 'ollama' ? 'http://localhost:11434' : 'https://api.example.com' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to continue (leave empty for default)"))))));
+};

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

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

package/dist/ui/components/AIUnderstandingSection.js

@@ -0,0 +1,87 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const AIUnderstandingSection = ({ llm }) => {
+    if (!llm || Object.keys(llm).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 AI Understanding Analysis"),
+                React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                    React.createElement(Text, null, "LLM analysis is not enabled. To see AI understanding insights, 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 }, "Supported providers: openai, anthropic, ollama, local"))))));
+    }
+    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+        llm.pageType && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "magenta" }, "\uD83D\uDCC4 Inferred Page Type"),
+            React.createElement(Text, { color: "cyan" }, llm.pageType))),
+        llm.pageTypeInsights && llm.pageTypeInsights.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true, color: "blue" }, "\uD83D\uDCA1 AI-Generated Insights"),
+            llm.pageTypeInsights.map((insight, idx) => (React.createElement(Box, { key: idx, marginTop: 0.5 },
+                React.createElement(Text, { color: "cyan" },
+                    "\u2022 ",
+                    insight)))))),
+        llm.summary && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "Summary"),
+            React.createElement(Box, { marginTop: 0.5 },
+                React.createElement(Text, null, llm.summary)))),
+        llm.keyTopics && llm.keyTopics.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "\uD83C\uDFF7\uFE0F  Key Topics"),
+            React.createElement(Box, { marginTop: 0.5 },
+                React.createElement(Text, null, llm.keyTopics.map((t) => `[${t}]`).join(' '))))),
+        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "Metadata"),
+            React.createElement(Box, { marginTop: 0.5, flexDirection: "column" },
+                llm.readingLevel && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Reading Level:"),
+                    " ",
+                    llm.readingLevel.description)),
+                llm.sentiment && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Sentiment:"),
+                    " ",
+                    llm.sentiment)),
+                llm.technicalDepth && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Technical Depth:"),
+                    " ",
+                    llm.technicalDepth)))),
+        llm.topEntities && llm.topEntities.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "\uD83D\uDD0D Key Entities"),
+            llm.topEntities.slice(0, 5).map((entity, idx) => (React.createElement(Box, { key: idx, marginTop: 0.5 },
+                React.createElement(Text, null,
+                    "\u2022 ",
+                    React.createElement(Text, { bold: true }, entity.name),
+                    ' ',
+                    React.createElement(Text, { dimColor: true },
+                        "(",
+                        entity.type,
+                        ") - ",
+                        Math.round((entity.relevance || 0) * 100),
+                        "% relevance"))))))),
+        llm.questions && llm.questions.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "\u2753 Questions AI Can Answer"),
+            llm.questions.slice(0, 5).map((q, idx) => (React.createElement(Box, { key: idx, marginTop: 0.5 },
+                React.createElement(Text, null,
+                    idx + 1,
+                    ". ",
+                    React.createElement(Text, { dimColor: true },
+                        "[",
+                        q.difficulty.toUpperCase(),
+                        "]"),
+                    " ",
+                    q.question)))))),
+        llm.suggestedFAQ && llm.suggestedFAQ.length > 0 && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "\uD83D\uDCA1 Suggested FAQs"),
+            llm.suggestedFAQ
+                .filter((f) => f.importance === 'high')
+                .slice(0, 3)
+                .map((faq, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Q:"),
+                    " ",
+                    faq.question),
+                React.createElement(Text, { dimColor: true },
+                    React.createElement(Text, { bold: true }, "A:"),
+                    " ",
+                    faq.suggestedAnswer))))))));
+};

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

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

package/dist/ui/components/HallucinationSection.js

@@ -0,0 +1,84 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const HallucinationSection = ({ hallucinationReport }) => {
+    if (!hallucinationReport || Object.keys(hallucinationReport).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 Hallucination Detection"),
+                React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                    React.createElement(Text, null, "Hallucination detection is not enabled. To see risk assessment, run:"),
+                    React.createElement(Box, { marginTop: 1, borderStyle: "single", paddingX: 1 },
+                        React.createElement(Text, { color: "cyan" }, "ai-lighthouse audit [URL] --enable-hallucination --enable-llm --llm-provider openai --llm-api-key YOUR_KEY")),
+                    React.createElement(Box, { marginTop: 1 },
+                        React.createElement(Text, { dimColor: true }, "Note: Hallucination detection requires LLM analysis to be enabled"))))));
+    }
+    const riskScore = hallucinationReport.hallucinationRiskScore;
+    const getRiskColor = (score) => {
+        if (score >= 70)
+            return 'red';
+        if (score >= 40)
+            return 'yellow';
+        return 'green';
+    };
+    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: getRiskColor(riskScore), paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: getRiskColor(riskScore) }, "\u26A0\uFE0F  Hallucination Risk Assessment"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Risk Score: "),
+                    React.createElement(Text, { bold: true, color: getRiskColor(riskScore) },
+                        riskScore,
+                        "/100")))),
+        hallucinationReport.factCheckSummary && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "blue" }, "\uD83D\uDCCA Fact Check Summary"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true }, "Total Facts:"),
+                    " ",
+                    hallucinationReport.factCheckSummary.totalFacts),
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true, color: "green" }, "Verified:"),
+                    " ",
+                    hallucinationReport.factCheckSummary.verifiedFacts),
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true, color: "yellow" }, "Unverified:"),
+                    " ",
+                    hallucinationReport.factCheckSummary.unverifiedFacts),
+                React.createElement(Text, null,
+                    React.createElement(Text, { bold: true, color: "red" }, "Contradictions:"),
+                    " ",
+                    hallucinationReport.factCheckSummary.contradictions),
+                hallucinationReport.factCheckSummary.ambiguities !== undefined && (React.createElement(Text, null,
+                    React.createElement(Text, { bold: true, color: "yellow" }, "Ambiguities:"),
+                    " ",
+                    hallucinationReport.factCheckSummary.ambiguities))))),
+        hallucinationReport.factCheckSummary?.unverifiedFacts > 0 && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, marginBottom: 1 },
+            React.createElement(Text, { color: "yellow" }, "\uD83D\uDCA1 Tip: Add citations and links to verify claims and reduce AI hallucination risk"))),
+        hallucinationReport.triggers && hallucinationReport.triggers.length > 0 && (React.createElement(React.Fragment, null, hallucinationReport.triggers.filter((t) => t.severity === 'high' || t.severity === 'critical').length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true, underline: true, color: "red" }, "\uD83D\uDEA8 High-Risk Triggers"),
+            hallucinationReport.triggers
+                .filter((t) => t.severity === 'high' || t.severity === 'critical')
+                .slice(0, 5)
+                .map((trigger, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", borderStyle: "single", borderColor: "red", paddingX: 1, paddingY: 0.5, marginTop: 1 },
+                React.createElement(Text, null,
+                    idx + 1,
+                    ". ",
+                    React.createElement(Text, { bold: true, color: "red" },
+                        "[",
+                        trigger.severity.toUpperCase(),
+                        "]"),
+                    " ",
+                    trigger.type),
+                React.createElement(Text, { dimColor: true }, trigger.description),
+                trigger.confidence && (React.createElement(Text, { dimColor: true },
+                    "Confidence: ",
+                    Math.round(trigger.confidence * 100),
+                    "%"))))))))),
+        hallucinationReport.recommendations && hallucinationReport.recommendations.length > 0 && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, underline: true, color: "cyan" }, "\uD83D\uDCA1 Recommendations"),
+            hallucinationReport.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/IssuesSection.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface IssuesSectionProps {
+    issues: any[];
+}
+export declare const IssuesSection: React.FC<IssuesSectionProps>;
+export {};

package/dist/ui/components/IssuesSection.js

@@ -0,0 +1,84 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+export const IssuesSection = ({ issues }) => {
+    const [selectedSeverity, setSelectedSeverity] = useState('all');
+    const [expandedIssue, setExpandedIssue] = useState(null);
+    const getSeverityColor = (severity) => {
+        if (severity === 'critical')
+            return 'red';
+        if (severity === 'high')
+            return 'magenta';
+        if (severity === 'medium')
+            return 'yellow';
+        return 'blue';
+    };
+    const getSeverityIcon = (severity) => {
+        if (severity === 'critical')
+            return '🔴';
+        if (severity === 'high')
+            return '🟠';
+        if (severity === 'medium')
+            return '🟡';
+        return '🔵';
+    };
+    // Group issues 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'),
+    };
+    const filteredIssues = selectedSeverity === 'all' ? issues : grouped[selectedSeverity] || [];
+    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" }, "\u26A0\uFE0F  Issues Summary"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Box, { flexDirection: "column", width: "50%" },
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "red", bold: true }, "Critical:"),
+                        ' ',
+                        grouped.critical.length),
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "magenta", bold: true }, "High:"),
+                        ' ',
+                        grouped.high.length)),
+                React.createElement(Box, { flexDirection: "column", width: "50%" },
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "yellow", bold: true }, "Medium:"),
+                        ' ',
+                        grouped.medium.length),
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "blue", bold: true }, "Low:"),
+                        ' ',
+                        grouped.low.length)))),
+        React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, underline: true },
+                selectedSeverity === 'all' ? 'All Issues' : `${selectedSeverity.toUpperCase()} Issues`,
+                " (",
+                filteredIssues.length,
+                ")"),
+            filteredIssues.map((issue, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", borderStyle: "round", borderColor: getSeverityColor(issue.severity), paddingX: 2, paddingY: 1, marginTop: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        getSeverityIcon(issue.severity),
+                        ' ',
+                        React.createElement(Text, { bold: true, color: getSeverityColor(issue.severity) }, issue.message || issue.title))),
+                React.createElement(Box, { marginTop: 0.5 },
+                    React.createElement(Text, { dimColor: true },
+                        "Category: ",
+                        issue.category,
+                        " \u2022 Impact: ",
+                        issue.impact)),
+                issue.evidence && (React.createElement(Box, { marginTop: 0.5 },
+                    React.createElement(Text, { dimColor: true },
+                        typeof issue.evidence === 'string'
+                            ? issue.evidence.substring(0, 100)
+                            : Array.isArray(issue.evidence)
+                                ? issue.evidence.join(', ').substring(0, 100)
+                                : '',
+                        (typeof issue.evidence === 'string' ? issue.evidence : issue.evidence?.join(', ') || '').length > 100 ? '...' : ''))),
+                React.createElement(Box, { marginTop: 1, borderStyle: "single", borderColor: "cyan", paddingX: 1, paddingY: 0.5 },
+                    React.createElement(Text, { color: "cyan" },
+                        "\uD83D\uDCA1 Fix: ",
+                        issue.suggested_fix || issue.remediation))))))));
+};

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

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