@ai-lighthouse/cli 1.0.2 → 1.0.3

package/README.md

@@ -9,30 +9,123 @@ pnpm install
 pnpm build
 ```
 
+## Quick Start
+
+The simplest way to audit a website:
+
+```bash
+# Interactive wizard (recommended for beginners)
+ai-lighthouse audit https://example.com
+
+# Using presets (recommended for most users)
+ai-lighthouse audit https://example.com --preset ai-optimized
+```
+
+## Interactive Features
+
+### Beautiful Terminal UI
+
+The CLI features a beautiful interactive terminal UI built with React (Ink) that includes:
+
+- **Animated Score Display** - Gradient text and grade badges
+- **Tab Navigation** - Navigate through 6 analysis sections using arrow keys (1-6)
+- **Real-time Loading** - Progress indicators for each analysis step
+- **Color-coded Data** - All severity levels and scores are color-coded
+- **Progress Bars** - Visual progress bars for dimension scores
+
+### Interactive Wizard
+
+When you run `ai-lighthouse audit <url>` without flags, the interactive wizard appears:
+
+1. **Feature Selection** - Choose which analyses to run (AI Understanding, Chunking, etc.)
+2. **LLM Configuration** - If AI features selected, configure your LLM provider
+3. **Confirmation** - Review settings before starting the audit
+4. **Results** - View results in the interactive terminal UI
+
+The wizard mode makes it easy to configure audits without memorizing command-line flags.
+
 ## Usage
 
-### Audit a single page
+### Audit with Presets (Recommended)
+
+Presets provide pre-configured scanning profiles for common use cases:
 
 ```bash
-ai-lighthouse audit https://example.com --output html
+# Fast scan with core rules only (~5-10 seconds)
+ai-lighthouse audit https://example.com --preset basic
+
+# Balanced scan with AI insights (~30-60 seconds) - Recommended
+ai-lighthouse audit https://example.com --preset ai-optimized
+
+# Comprehensive scan with all features (~2-5 minutes)
+ai-lighthouse audit https://example.com --preset full
+
+# Quick scan showing only critical issues (~3-5 seconds)
+ai-lighthouse audit https://example.com --preset minimal
 ```
 
-### Audit with specific rules
+### List Available Presets
 
 ```bash
-ai-lighthouse audit https://example.com --rules strict --enable-llm
+ai-lighthouse presets
 ```
 
-### Crawl multiple pages
+### Configure LLM Provider (for AI-powered presets)
 
 ```bash
-ai-lighthouse crawl https://example.com --depth 2 --sitemap
+# Using Ollama (local, free)
+ai-lighthouse audit https://example.com --preset ai-optimized \
+  --llm-provider ollama \
+  --llm-model qwen2.5:0.5b
+
+# Using OpenAI
+ai-lighthouse audit https://example.com --preset ai-optimized \
+  --llm-provider openai \
+  --llm-model gpt-4o-mini \
+  --llm-api-key sk-...
+
+# Using Anthropic
+ai-lighthouse audit https://example.com --preset full \
+  --llm-provider anthropic \
+  --llm-model claude-3-5-sonnet-20241022 \
+  --llm-api-key sk-ant-...
 ```
 
-### Generate report from saved results
+### Output Formats
 
 ```bash
-ai-lighthouse report ./.ai-lighthouse/last_run.json --open
+# Save as JSON
+ai-lighthouse audit https://example.com --preset basic --output json
+
+# Generate HTML report
+ai-lighthouse audit https://example.com --preset ai-optimized --output html
+
+# Generate PDF report
+ai-lighthouse audit https://example.com --preset full --output pdf
+
+# Interactive terminal UI (default)
+ai-lighthouse audit https://example.com --preset ai-optimized
+```
+
+### CI/CD Integration
+
+```bash
+# Exit with code 1 if score is below threshold
+ai-lighthouse audit https://example.com --preset minimal --threshold 80
+```
+
+### Advanced: Override Preset Defaults
+
+You can override any preset option:
+
+```bash
+# Use ai-optimized preset but enable hallucination detection
+ai-lighthouse audit https://example.com --preset ai-optimized \
+  --enable-hallucination
+
+# Use full preset but limit to 10 issues
+ai-lighthouse audit https://example.com --preset full \
+  --max-issues 10
 ```
 
 ## Commands
@@ -41,57 +134,37 @@ ai-lighthouse report ./.ai-lighthouse/last_run.json --open
 
 Audit a single webpage for AI readiness.
 
-**Options:**
-- `-o, --output <format>` - Output format: json, html, lhr, csv (default: json)
-- `-r, --rules <preset>` - Rule preset: default, strict, minimal (default: default)
-- `-d, --depth <number>` - Crawl depth for multi-page audits (default: 1)
-- `-p, --pages <urls>` - Comma-separated list of specific pages to audit
-- `--cache-ttl <seconds>` - Cache TTL in seconds to avoid re-fetching
-- `--threshold <score>` - Minimum score threshold (exit 1 if below)
-- `--max-chunk-tokens <number>` - Maximum tokens per content chunk (default: 1200)
-- `--chunking-strategy <strategy>` - Chunking strategy: auto, heading-based, paragraph-based (default: auto)
-- `--enable-chunking` - Enable detailed content chunking analysis
-- `--enable-extractability` - Enable extractability mapping
-- `--enable-hallucination` - Enable hallucination detection
-- `--enable-llm` - Enable LLM comprehension analysis
-- `--min-impact <number>` - Minimum impact score to include (default: 8)
-- `--min-confidence <number>` - Minimum confidence to include 0-1 (default: 0.7)
-- `--max-issues <number>` - Maximum issues to return (default: 20)
-- `--llm-provider <provider>` - LLM provider: openai, anthropic, ollama, local
-- `--llm-model <model>` - LLM model name
-- `--llm-base-url <url>` - LLM API base URL
-- `--llm-api-key <key>` - LLM API key
+**Primary Options:**
 
-**Examples:**
+- `-o, --output <format>` - Output format: json, html, pdf, interactive (default: interactive)
+- `-p, --preset <name>` - Preset configuration: basic, ai-optimized, full, minimal
 
-```bash
-# Basic audit
-ai-lighthouse audit https://example.com
+**LLM Configuration (for AI-powered presets):**
 
-# HTML report with all features enabled
-ai-lighthouse audit https://example.com \
-  --output html \
-  --enable-chunking \
-  --enable-extractability \
-  --enable-hallucination \
-  --enable-llm \
-  --llm-provider ollama \
-  --llm-model qwen2.5:0.5b
+- `--llm-provider <provider>` - LLM provider: openai, anthropic, ollama (default: ollama)
+- `--llm-model <model>` - LLM model name (e.g., qwen2.5:0.5b, gpt-4o-mini)
+- `--llm-api-key <key>` - LLM API key (for OpenAI, Anthropic, etc.)
+- `--llm-base-url <url>` - LLM API base URL (for custom endpoints)
 
-# Force paragraph-based chunking for consistent chunk sizes
-ai-lighthouse audit https://example.com \
-  --enable-chunking \
-  --chunking-strategy paragraph-based \
-  --max-chunk-tokens 1000
+**Advanced Overrides (for power users):**
 
-# Force heading-based chunking for semantic sections
-ai-lighthouse audit https://example.com \
-  --enable-chunking \
-  --chunking-strategy heading-based
+- `--enable-chunking` - Override: Enable chunking analysis
+- `--enable-extractability` - Override: Enable extractability mapping
+- `--enable-hallucination` - Override: Enable hallucination detection
+- `--enable-llm` - Override: Enable LLM comprehension
+- `--min-impact <number>` - Override: Minimum impact score to include
+- `--min-confidence <number>` - Override: Minimum confidence (0-1)
+- `--max-issues <number>` - Override: Maximum issues to show
+- `--max-chunk-tokens <number>` - Override: Max tokens per chunk
+- `--chunking-strategy <strategy>` - Override: Chunking strategy (auto, heading-based, paragraph-based)
 
-# CI/CD integration with score threshold
-ai-lighthouse audit https://example.com --threshold 80
-```
+**Utility Options:**
+
+- `--threshold <score>` - Exit with code 1 if score is below this threshold
+
+### `presets`
+
+List all available preset configurations with descriptions and estimated durations.
 
 ### `crawl <url>`
 

package/dist/index.js

@@ -1063,11 +1063,162 @@ var SetupWizard = ({ onComplete, initialUrl }) => {
   )), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "Press Enter to continue (leave empty for default)"))));
 };
 
+// src/presets.ts
+var BASIC_PRESET = {
+  name: "basic",
+  description: "Fast scan with core rules only (no LLM)",
+  estimatedDuration: "5-10 seconds",
+  // Filtering
+  minImpactScore: 8,
+  minConfidence: 0.7,
+  maxIssues: 20,
+  // Features
+  enableLLM: false,
+  enableChunking: false,
+  enableExtractability: false,
+  enableHallucinationDetection: false,
+  // LLM config (disabled)
+  llmConfig: void 0
+};
+var AI_OPTIMIZED_PRESET = {
+  name: "ai-optimized",
+  description: "Balanced scan with AI comprehension and messaging alignment",
+  estimatedDuration: "30-60 seconds",
+  // Filtering
+  minImpactScore: 8,
+  minConfidence: 0.7,
+  maxIssues: 20,
+  // Features (balanced approach)
+  enableLLM: true,
+  enableChunking: false,
+  // Skip for speed
+  enableExtractability: false,
+  // Skip for speed
+  enableHallucinationDetection: false,
+  // Skip for speed
+  // LLM config (will be populated from CLI flags)
+  llmConfig: {
+    provider: "ollama",
+    // Default to local
+    model: "qwen2.5:0.5b",
+    maxTokens: 2e3,
+    temperature: 0.3
+  }
+};
+var FULL_PRESET = {
+  name: "full",
+  description: "Comprehensive scan with all features enabled",
+  estimatedDuration: "2-5 minutes",
+  // Filtering (show more)
+  minImpactScore: 5,
+  minConfidence: 0.6,
+  maxIssues: 50,
+  // Features (everything enabled)
+  enableLLM: true,
+  enableChunking: true,
+  enableExtractability: true,
+  enableHallucinationDetection: true,
+  // Chunking config
+  chunkingStrategy: "auto",
+  maxChunkTokens: 1200,
+  // LLM config (will be populated from CLI flags)
+  llmConfig: {
+    provider: "ollama",
+    model: "qwen2.5:0.5b",
+    maxTokens: 2e3,
+    temperature: 0.3
+  }
+};
+var MINIMAL_PRESET = {
+  name: "minimal",
+  description: "Quick scan showing only critical issues",
+  estimatedDuration: "3-5 seconds",
+  // Strict filtering
+  minImpactScore: 15,
+  minConfidence: 0.8,
+  maxIssues: 10,
+  // Features (minimal)
+  enableLLM: false,
+  enableChunking: false,
+  enableExtractability: false,
+  enableHallucinationDetection: false,
+  // LLM config (disabled)
+  llmConfig: void 0
+};
+var PRESETS = {
+  basic: BASIC_PRESET,
+  "ai-optimized": AI_OPTIMIZED_PRESET,
+  full: FULL_PRESET,
+  minimal: MINIMAL_PRESET
+};
+function getPreset(name) {
+  const preset = PRESETS[name];
+  if (!preset) {
+    throw new Error(`Unknown preset: ${name}. Available: ${Object.keys(PRESETS).join(", ")}`);
+  }
+  return { ...preset };
+}
+function listPresets() {
+  return Object.values(PRESETS).map((preset) => ({
+    name: preset.name,
+    description: preset.description,
+    duration: preset.estimatedDuration
+  }));
+}
+function mergePresetWithOptions(presetName, userOptions) {
+  const preset = getPreset(presetName);
+  const merged = {
+    minImpactScore: preset.minImpactScore,
+    minConfidence: preset.minConfidence,
+    maxIssues: preset.maxIssues,
+    enableLLM: preset.enableLLM,
+    enableChunking: preset.enableChunking,
+    enableExtractability: preset.enableExtractability,
+    enableHallucinationDetection: preset.enableHallucinationDetection,
+    chunkingStrategy: preset.chunkingStrategy,
+    maxChunkTokens: preset.maxChunkTokens
+  };
+  if (userOptions.minImpactScore !== void 0) merged.minImpactScore = userOptions.minImpactScore;
+  if (userOptions.minConfidence !== void 0) merged.minConfidence = userOptions.minConfidence;
+  if (userOptions.maxIssues !== void 0) merged.maxIssues = userOptions.maxIssues;
+  if (userOptions.enableLLM !== void 0) merged.enableLLM = userOptions.enableLLM;
+  if (userOptions.enableChunking !== void 0) merged.enableChunking = userOptions.enableChunking;
+  if (userOptions.enableExtractability !== void 0) merged.enableExtractability = userOptions.enableExtractability;
+  if (userOptions.enableHallucinationDetection !== void 0) merged.enableHallucinationDetection = userOptions.enableHallucinationDetection;
+  if (userOptions.chunkingStrategy !== void 0) merged.chunkingStrategy = userOptions.chunkingStrategy;
+  if (userOptions.maxChunkTokens !== void 0) merged.maxChunkTokens = userOptions.maxChunkTokens;
+  if (merged.enableLLM) {
+    merged.llmConfig = {
+      provider: userOptions.llmProvider || preset.llmConfig?.provider || "ollama",
+      model: userOptions.llmModel || preset.llmConfig?.model,
+      apiKey: userOptions.llmApiKey || preset.llmConfig?.apiKey,
+      baseUrl: userOptions.llmBaseUrl || preset.llmConfig?.baseUrl,
+      maxTokens: preset.llmConfig?.maxTokens,
+      temperature: preset.llmConfig?.temperature
+    };
+  }
+  return merged;
+}
+
 // src/commands/audit.ts
 function auditCommand(program2) {
-  program2.command("audit").description("Audit a website for AI readiness").argument("<url>", "URL to audit").option("-o, --output <format>", "Output format: json, html, pdf, lhr, csv, interactive", "interactive").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, options) => {
+  program2.command("audit").description("Audit a website for AI readiness").argument("<url>", "URL to audit").option("-o, --output <format>", "Output format: json, html, pdf, lhr, csv, interactive", "interactive").option("-p, --preset <name>", "Preset configuration: basic, ai-optimized, full, minimal").option("--llm-provider <provider>", "LLM provider: openai, anthropic, ollama (default: ollama)").option("--llm-model <model>", "LLM model name (e.g., qwen2.5:0.5b, gpt-4o-mini)").option("--llm-api-key <key>", "LLM API key (for OpenAI, Anthropic, etc.)").option("--llm-base-url <url>", "LLM API base URL (for custom endpoints)").option("--enable-chunking", "Override: Enable chunking analysis", false).option("--enable-extractability", "Override: Enable extractability mapping", false).option("--enable-hallucination", "Override: Enable hallucination detection", false).option("--enable-llm", "Override: Enable LLM comprehension", false).option("--min-impact <number>", "Override: Minimum impact score", parseInt).option("--min-confidence <number>", "Override: Minimum confidence (0-1)", parseFloat).option("--max-issues <number>", "Override: Maximum issues to show", parseInt).option("--max-chunk-tokens <number>", "Override: Max tokens per chunk", parseInt).option("--chunking-strategy <strategy>", "Override: Chunking strategy (auto, heading-based, paragraph-based)").option("--threshold <score>", "Exit with code 1 if score is below this threshold", parseInt).addHelpText("after", `
+Presets:
+  basic         Fast scan with core rules only (~5-10 seconds)
+  ai-optimized  Balanced scan with AI insights (~30-60 seconds) [Recommended]
+  full          Comprehensive scan with all features (~2-5 minutes)
+  minimal       Only critical issues (~3-5 seconds)
+
+Examples:
+  $ ai-lighthouse audit https://example.com
+  $ ai-lighthouse audit https://example.com --preset ai-optimized
+  $ ai-lighthouse audit https://example.com --preset full --llm-provider openai --llm-api-key sk-...
+  $ ai-lighthouse audit https://example.com --preset basic --output json
+  $ ai-lighthouse audit https://example.com --preset minimal --threshold 80
+    `).action(async (url, options) => {
+    const hasPreset = options.preset !== void 0;
     const hasFeatureFlags = options.enableChunking || options.enableExtractability || options.enableHallucination || options.enableLlm || options.llmProvider;
-    if (options.output === "interactive" && !hasFeatureFlags) {
+    if (options.output === "interactive" && !hasPreset && !hasFeatureFlags) {
       const originalConsoleError = console.error;
       const originalConsoleWarn = console.warn;
       console.error = () => {
@@ -1118,24 +1269,43 @@ function auditCommand(program2) {
       );
       try {
         const urlObj = new URL(url);
-        const 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
-        };
-        if (options.enableLlm && options.llmProvider) {
-          scanOptions.llmConfig = {
-            provider: options.llmProvider,
-            model: options.llmModel,
-            baseUrl: options.llmBaseUrl,
-            apiKey: options.llmApiKey
+        let scanOptions;
+        if (hasPreset) {
+          scanOptions = mergePresetWithOptions(options.preset, {
+            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,
+            llmProvider: options.llmProvider,
+            llmModel: options.llmModel,
+            llmApiKey: options.llmApiKey,
+            llmBaseUrl: options.llmBaseUrl
+          });
+        } else {
+          scanOptions = {
+            maxChunkTokens: options.maxChunkTokens || 1200,
+            chunkingStrategy: options.chunkingStrategy || "auto",
+            enableChunking: options.enableChunking || false,
+            enableExtractability: options.enableExtractability || false,
+            enableHallucinationDetection: options.enableHallucination || false,
+            enableLLM: options.enableLlm || false,
+            minImpactScore: options.minImpact ?? 8,
+            minConfidence: options.minConfidence ?? 0.7,
+            maxIssues: options.maxIssues ?? 20
           };
+          if (options.enableLlm && options.llmProvider) {
+            scanOptions.llmConfig = {
+              provider: options.llmProvider,
+              model: options.llmModel,
+              baseUrl: options.llmBaseUrl,
+              apiKey: options.llmApiKey
+            };
+          }
         }
         rerender(
           React10.createElement(AuditReportUI, {
@@ -1190,25 +1360,46 @@ function auditCommand(program2) {
     const spinner = ora("Starting audit...").start();
     try {
       const urlObj = new URL(url);
-      spinner.text = `Auditing ${chalk2.cyan(urlObj.href)}...`;
-      const 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
-      };
-      if (options.enableLlm && options.llmProvider) {
-        scanOptions.llmConfig = {
-          provider: options.llmProvider,
-          model: options.llmModel,
-          baseUrl: options.llmBaseUrl,
-          apiKey: options.llmApiKey
+      let scanOptions;
+      if (hasPreset) {
+        const presetConfig = getPreset(options.preset);
+        spinner.text = `Using ${chalk2.cyan(options.preset)} preset (${presetConfig.estimatedDuration})...`;
+        scanOptions = mergePresetWithOptions(options.preset, {
+          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,
+          llmProvider: options.llmProvider,
+          llmModel: options.llmModel,
+          llmApiKey: options.llmApiKey,
+          llmBaseUrl: options.llmBaseUrl
+        });
+      } else {
+        spinner.text = `Auditing ${chalk2.cyan(urlObj.href)}...`;
+        scanOptions = {
+          maxChunkTokens: options.maxChunkTokens || 1200,
+          chunkingStrategy: options.chunkingStrategy || "auto",
+          enableChunking: options.enableChunking || false,
+          enableExtractability: options.enableExtractability || false,
+          enableHallucinationDetection: options.enableHallucination || false,
+          enableLLM: options.enableLlm || false,
+          minImpactScore: options.minImpact ?? 8,
+          minConfidence: options.minConfidence ?? 0.7,
+          maxIssues: options.maxIssues ?? 20
         };
+        if (options.enableLlm && options.llmProvider) {
+          scanOptions.llmConfig = {
+            provider: options.llmProvider,
+            model: options.llmModel,
+            baseUrl: options.llmBaseUrl,
+            apiKey: options.llmApiKey
+          };
+        }
       }
       spinner.text = "Scanning page...";
       const result = await analyzeUrlWithRules(url, scanOptions);
@@ -2567,6 +2758,29 @@ function auditWizardCommand(program2) {
   });
 }
 
+// src/commands/presets.ts
+import chalk5 from "chalk";
+function presetsCommand(program2) {
+  program2.command("presets").description("List available preset configurations").action(() => {
+    console.log("\n" + chalk5.bold.cyan("\u{1F3AF} Available Presets\n"));
+    const presets = listPresets();
+    presets.forEach((preset) => {
+      const badge = preset.name === "ai-optimized" ? chalk5.green("[Recommended]") : "";
+      console.log(chalk5.bold(preset.name) + " " + badge);
+      console.log(chalk5.dim(`  ${preset.description}`));
+      console.log(chalk5.dim(`  Duration: ${preset.duration}`));
+      console.log("");
+    });
+    console.log(chalk5.dim("Usage:"));
+    console.log(chalk5.dim("  ai-lighthouse audit <url> --preset <name>"));
+    console.log("");
+    console.log(chalk5.dim("Examples:"));
+    console.log(chalk5.dim("  ai-lighthouse audit https://example.com --preset basic"));
+    console.log(chalk5.dim("  ai-lighthouse audit https://example.com --preset ai-optimized"));
+    console.log("");
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("ai-lighthouse").description("AI Lighthouse - Audit websites for AI readiness and SEO optimization").version("1.0.0");
@@ -2574,4 +2788,5 @@ auditWizardCommand(program);
 auditCommand(program);
 crawlCommand(program);
 reportCommand(program);
+presetsCommand(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-lighthouse/cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "AI Lighthouse CLI - Audit websites for AI readiness",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@ai-lighthouse/scanner": "^1.0.2",
+    "@ai-lighthouse/scanner": "^1.0.3",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "html-pdf-node": "^1.0.8",