@ai-lighthouse/cli 1.0.0

package/dist/utils/comprehensive-formatter.js

@@ -0,0 +1,370 @@
+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');
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ai-lighthouse/cli",
+  "version": "1.0.0",
+  "description": "AI Lighthouse CLI - Audit websites for AI readiness",
+  "type": "module",
+  "bin": {
+    "ai-lighthouse": "./bin/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "echo 'Build skipped - using tsx runtime'",
+    "check-types": "tsc --noEmit",
+    "cli": "node --loader tsx src/index.ts"
+  },
+  "keywords": [
+    "ai",
+    "lighthouse",
+    "audit",
+    "seo",
+    "accessibility",
+    "llm"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-lighthouse/scanner": "workspace:*",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "html-pdf-node": "^1.0.8",
+    "ink": "^6.6.0",
+    "ink-big-text": "^2.0.0",
+    "ink-box": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-link": "^5.0.0",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-table": "^3.1.0",
+    "ink-text-input": "^6.0.0",
+    "open": "^10.1.0",
+    "ora": "^8.1.1",
+    "react": "19.2.0",
+    "react-devtools": "^7.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "tsx": "^4.21.0",
+    "typescript": "5.9.2"
+  }
+}

package/src/commands/audit-interactive.ts

@@ -0,0 +1,149 @@
+import { Command } from 'commander';
+import { analyzeUrlWithRules } from '@ai-lighthouse/scanner';
+import { calculateAIReadiness, exportAuditReport } from '@ai-lighthouse/scanner';
+import type { ScanOptions } from '@ai-lighthouse/scanner';
+import { render } from 'ink';
+import React from 'react';
+import { AuditReportUI } from '../ui/AuditReportUI.js';
+
+interface AuditOptions {
+  output?: string;
+  rules?: string;
+  depth?: number;
+  pages?: string;
+  cacheTtl?: number;
+  threshold?: number;
+  maxChunkTokens?: number;
+  chunkingStrategy?: 'auto' | 'heading-based' | 'paragraph-based';
+  enableChunking?: boolean;
+  enableExtractability?: boolean;
+  enableHallucination?: boolean;
+  enableLlm?: boolean;
+  minImpact?: number;
+  minConfidence?: number;
+  maxIssues?: number;
+  llmProvider?: string;
+  llmModel?: string;
+  llmBaseUrl?: string;
+  llmApiKey?: string;
+  interactive?: boolean;
+}
+
+export function auditInteractiveCommand(program: Command) {
+  program
+    .command('audit-interactive')
+    .description('Audit a website for AI readiness with interactive UI')
+    .argument('<url>', 'URL to audit')
+    .option('-r, --rules <preset>', 'Rule preset: default, strict, minimal', 'default')
+    .option('-d, --depth <number>', 'Crawl depth (for multi-page audits)', parseInt, 1)
+    .option('-p, --pages <urls>', 'Comma-separated list of specific pages to audit')
+    .option('--cache-ttl <seconds>', 'Cache TTL in seconds to avoid re-fetching', parseInt)
+    .option('--threshold <score>', 'Minimum score threshold (exit 1 if below)', parseInt)
+    .option('--max-chunk-tokens <number>', 'Maximum tokens per content chunk', parseInt, 1200)
+    .option('--chunking-strategy <strategy>', 'Chunking strategy: auto, heading-based, paragraph-based', 'auto')
+    .option('--enable-chunking', 'Enable detailed content chunking analysis', false)
+    .option('--enable-extractability', 'Enable extractability mapping', false)
+    .option('--enable-hallucination', 'Enable hallucination detection', false)
+    .option('--enable-llm', 'Enable LLM comprehension analysis', false)
+    .option('--min-impact <number>', 'Minimum impact score to include', parseInt, 8)
+    .option('--min-confidence <number>', 'Minimum confidence to include (0-1)', parseFloat, 0.7)
+    .option('--max-issues <number>', 'Maximum issues to return', parseInt, 20)
+    .option('--llm-provider <provider>', 'LLM provider: openai, anthropic, ollama, local')
+    .option('--llm-model <model>', 'LLM model name')
+    .option('--llm-base-url <url>', 'LLM API base URL')
+    .option('--llm-api-key <key>', 'LLM API key')
+    .action(async (url: string, options: AuditOptions) => {
+      // Show loading UI
+      const { waitUntilExit, clear, rerender } = render(
+        React.createElement(AuditReportUI, {
+          url,
+          result: {},
+          aiReadiness: {},
+          loading: true,
+          currentStep: 'Starting audit...',
+        })
+      );
+
+      try {
+        // Validate URL
+        const urlObj = new URL(url);
+
+        // Build scan options
+        const scanOptions: ScanOptions = {
+          maxChunkTokens: options.maxChunkTokens,
+          chunkingStrategy: options.chunkingStrategy,
+          enableChunking: options.enableChunking,
+          enableExtractability: options.enableExtractability,
+          enableHallucinationDetection: options.enableHallucination,
+          enableLLM: options.enableLlm,
+          minImpactScore: options.minImpact,
+          minConfidence: options.minConfidence,
+          maxIssues: options.maxIssues,
+        };
+
+        // Configure LLM if enabled
+        if (options.enableLlm && options.llmProvider) {
+          scanOptions.llmConfig = {
+            provider: options.llmProvider as any,
+            model: options.llmModel,
+            baseUrl: options.llmBaseUrl,
+            apiKey: options.llmApiKey,
+          };
+        }
+
+        // Update loading step
+        rerender(
+          React.createElement(AuditReportUI, {
+            url: urlObj.href,
+            result: {},
+            aiReadiness: {},
+            loading: true,
+            currentStep: 'Scanning page...',
+          })
+        );
+
+        // Run the audit
+        const result = await analyzeUrlWithRules(url, scanOptions);
+
+        // Update loading step
+        rerender(
+          React.createElement(AuditReportUI, {
+            url: urlObj.href,
+            result,
+            aiReadiness: {},
+            loading: true,
+            currentStep: 'Calculating AI readiness scores...',
+          })
+        );
+
+        // Calculate AI readiness
+        const aiReadiness = calculateAIReadiness(result);
+
+        // Clear loading and show results
+        clear();
+        const finalRender = render(
+          React.createElement(AuditReportUI, {
+            url: urlObj.href,
+            result,
+            aiReadiness,
+            loading: false,
+          })
+        );
+
+        // Wait for user to exit
+        await finalRender.waitUntilExit();
+
+        // Check threshold
+        if (options.threshold !== undefined) {
+          const overallScore = aiReadiness.overall;
+          if (overallScore !== undefined && overallScore < options.threshold) {
+            process.exit(1);
+          }
+        }
+      } catch (error) {
+        clear();
+        console.error('Audit failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}