aidevops 2.52.1

package/.agent/scripts/eeat-score-helper.sh

@@ -0,0 +1,1242 @@
+#!/bin/bash
+# shellcheck disable=SC2034,SC2155,SC2317,SC2329,SC2016,SC2181,SC1091,SC2154,SC2015,SC2086,SC2129,SC2030,SC2031,SC2119,SC2120,SC2001,SC2162,SC2088,SC2089,SC2090,SC2029,SC2006,SC2153
+
+# E-E-A-T Score Helper Script
+# Content quality scoring using Google's E-E-A-T framework
+#
+# Usage: ./eeat-score-helper.sh [command] [input] [options]
+# Commands:
+#   analyze     - Analyze crawled pages from site-crawler output
+#   score       - Score a single URL
+#   batch       - Batch analyze URLs from a file
+#   report      - Generate spreadsheet from existing scores
+#   status      - Check dependencies and configuration
+#   help        - Show this help message
+#
+# Author: AI DevOps Framework
+# Version: 1.0.0
+# License: MIT
+
+set -euo pipefail
+
+# Colors for output
+readonly GREEN='\033[0;32m'
+readonly BLUE='\033[0;34m'
+readonly YELLOW='\033[1;33m'
+readonly RED='\033[0;31m'
+readonly PURPLE='\033[0;35m'
+readonly NC='\033[0m'
+
+# Constants
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" || exit
+readonly SCRIPT_DIR
+readonly CONFIG_DIR="${HOME}/.config/aidevops"
+readonly CONFIG_FILE="${CONFIG_DIR}/eeat-score.json"
+readonly DEFAULT_OUTPUT_DIR="${HOME}/Downloads"
+
+# Default configuration
+LLM_PROVIDER="openai"
+LLM_MODEL="gpt-4o"
+TEMPERATURE="0.3"
+MAX_TOKENS="500"
+CONCURRENT_REQUESTS=3
+OUTPUT_FORMAT="xlsx"
+INCLUDE_REASONING=true
+
+# Weights for overall score calculation
+WEIGHT_AUTHORSHIP=0.15
+WEIGHT_CITATION=0.15
+WEIGHT_EFFORT=0.15
+WEIGHT_ORIGINALITY=0.15
+WEIGHT_INTENT=0.15
+WEIGHT_SUBJECTIVE=0.15
+WEIGHT_WRITING=0.10
+
+# Print functions
+print_success() {
+    local message="$1"
+    echo -e "${GREEN}[OK] $message${NC}"
+    return 0
+}
+
+print_info() {
+    local message="$1"
+    echo -e "${BLUE}[INFO] $message${NC}"
+    return 0
+}
+
+print_warning() {
+    local message="$1"
+    echo -e "${YELLOW}[WARN] $message${NC}"
+    return 0
+}
+
+print_error() {
+    local message="$1"
+    echo -e "${RED}[ERROR] $message${NC}"
+    return 0
+}
+
+print_header() {
+    local message="$1"
+    echo -e "${PURPLE}=== $message ===${NC}"
+    return 0
+}
+
+# Load configuration
+load_config() {
+    if [[ -f "$CONFIG_FILE" ]]; then
+        if command -v jq &> /dev/null; then
+            LLM_PROVIDER=$(jq -r '.llm_provider // "openai"' "$CONFIG_FILE")
+            LLM_MODEL=$(jq -r '.llm_model // "gpt-4o"' "$CONFIG_FILE")
+            TEMPERATURE=$(jq -r '.temperature // 0.3' "$CONFIG_FILE")
+            MAX_TOKENS=$(jq -r '.max_tokens // 500' "$CONFIG_FILE")
+            CONCURRENT_REQUESTS=$(jq -r '.concurrent_requests // 3' "$CONFIG_FILE")
+            OUTPUT_FORMAT=$(jq -r '.output_format // "xlsx"' "$CONFIG_FILE")
+            INCLUDE_REASONING=$(jq -r '.include_reasoning // true' "$CONFIG_FILE")
+            
+            # Load weights
+            WEIGHT_AUTHORSHIP=$(jq -r '.weights.authorship // 0.15' "$CONFIG_FILE")
+            WEIGHT_CITATION=$(jq -r '.weights.citation // 0.15' "$CONFIG_FILE")
+            WEIGHT_EFFORT=$(jq -r '.weights.effort // 0.15' "$CONFIG_FILE")
+            WEIGHT_ORIGINALITY=$(jq -r '.weights.originality // 0.15' "$CONFIG_FILE")
+            WEIGHT_INTENT=$(jq -r '.weights.intent // 0.15' "$CONFIG_FILE")
+            WEIGHT_SUBJECTIVE=$(jq -r '.weights.subjective // 0.15' "$CONFIG_FILE")
+            WEIGHT_WRITING=$(jq -r '.weights.writing // 0.10' "$CONFIG_FILE")
+        fi
+    fi
+    return 0
+}
+
+# Check dependencies
+check_dependencies() {
+    local missing=()
+    
+    if ! command -v curl &> /dev/null; then
+        missing+=("curl")
+    fi
+    
+    if ! command -v jq &> /dev/null; then
+        missing+=("jq")
+    fi
+    
+    if ! command -v python3 &> /dev/null; then
+        missing+=("python3")
+    fi
+    
+    if [[ ${#missing[@]} -gt 0 ]]; then
+        print_error "Missing dependencies: ${missing[*]}"
+        print_info "Install with: brew install ${missing[*]}"
+        return 1
+    fi
+    
+    return 0
+}
+
+# Check API key
+check_api_key() {
+    if [[ "$LLM_PROVIDER" == "openai" ]]; then
+        if [[ -z "${OPENAI_API_KEY:-}" ]]; then
+            print_error "OPENAI_API_KEY environment variable not set"
+            print_info "Set with: export OPENAI_API_KEY='sk-...'"
+            return 1
+        fi
+    elif [[ "$LLM_PROVIDER" == "anthropic" ]]; then
+        if [[ -z "${ANTHROPIC_API_KEY:-}" ]]; then
+            print_error "ANTHROPIC_API_KEY environment variable not set"
+            return 1
+        fi
+    fi
+    return 0
+}
+
+# Extract domain from URL
+get_domain() {
+    local url="$1"
+    echo "$url" | sed -E 's|^https?://||' | sed -E 's|/.*||' | sed -E 's|:.*||'
+}
+
+# Create output directory structure
+create_output_dir() {
+    local domain="$1"
+    local output_base="${2:-$DEFAULT_OUTPUT_DIR}"
+    local timestamp
+    timestamp=$(date +%Y-%m-%d_%H%M%S)
+    
+    local output_dir="${output_base}/${domain}/${timestamp}"
+    mkdir -p "$output_dir"
+    
+    # Update _latest symlink
+    local latest_link="${output_base}/${domain}/_latest"
+    rm -f "$latest_link"
+    ln -sf "$timestamp" "$latest_link"
+    
+    echo "$output_dir"
+    return 0
+}
+
+# Generate Python E-E-A-T analyzer script
+generate_analyzer_script() {
+    cat << 'PYTHON_SCRIPT'
+#!/usr/bin/env python3
+"""
+E-E-A-T Score Analyzer
+Evaluates content quality using Google's E-E-A-T framework
+"""
+
+import asyncio
+import json
+import csv
+import sys
+import os
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass, field, asdict
+from typing import Optional, List, Dict
+import aiohttp
+from bs4 import BeautifulSoup
+
+try:
+    import openpyxl
+    from openpyxl.styles import Font, PatternFill, Alignment
+    HAS_OPENPYXL = True
+except ImportError:
+    HAS_OPENPYXL = False
+
+# E-E-A-T Prompts
+PROMPTS = {
+    "authorship_reasoning": """You are evaluating Authorship & Expertise for this page. Analyze and explain in 3-4 sentences:
+- Is there a clear AUTHOR? If yes, who and what credentials?
+- Can you identify the PUBLISHER (who owns/operates the site)?
+- Is this a "Disconnected Entity" (anonymous, untraceable) or "Connected Entity" (verifiable)?
+- Do they demonstrate RELEVANT EXPERTISE for this topic?
+Be specific with names, credentials, evidence from the page.""",
+
+    "authorship_score": """You are evaluating Authorship & Expertise (isAuthor criterion).
+CRITICAL: A "Disconnected Entity" is one where you CANNOT find "who owns and operates" the site.
+Evaluate:
+- Is there a clear author byline linking to a detailed biography?
+- Does the About page clearly identify the company or person responsible?
+- Is this entity VERIFIABLE and ACCOUNTABLE?
+- Do they demonstrate RELEVANT EXPERTISE for this topic?
+Score 1-10:
+1-3 = DISCONNECTED ENTITY: No clear author, anonymous, untraceable
+4-6 = Partial attribution, but weak verifiability or unclear credentials
+7-10 = CONNECTED ENTITY: Clear author with detailed bio, verifiable expertise
+Return ONLY the number.""",
+
+    "citation_reasoning": """You are evaluating Citation Quality for this page. Analyze and explain in 3-4 sentences:
+- Does the page make SPECIFIC FACTUAL CLAIMS?
+- Are those claims SUBSTANTIATED with citations?
+- QUALITY assessment: Primary sources (studies, official docs) or secondary/low-quality?
+- Or are claims unsupported?
+Be specific with examples of claims and their (lack of) citations.""",
+
+    "citation_score": """You are evaluating Citation Quality & Substantiation.
+Does this content BACK UP its claims with high-quality sources?
+Analyze:
+- Does the page make SPECIFIC FACTUAL CLAIMS?
+- Are those claims SUBSTANTIATED with citations/links?
+- QUALITY of sources: Primary sources (studies, legal docs, official data)?
+Score 1-10:
+1-3 = LOW: Bold claims with NO citations, or only low-quality links
+4-6 = MODERATE: Some citations but mediocre quality
+7-10 = HIGH: Core claims substantiated with primary sources
+Return ONLY the number.""",
+
+    "effort_reasoning": """You are evaluating Content Effort for this page. Analyze and explain in 3-4 sentences:
+- How DIFFICULT would it be to REPLICATE this content? (time, cost, expertise)
+- Does the page "SHOW ITS WORK"? Is the creation process transparent?
+- What evidence of high/low effort? (original research, data, multimedia, depth)
+- Any unique elements that required significant resources?
+Be specific with examples from the page.""",
+
+    "effort_score": """You are evaluating Content Effort.
+Assess the DEMONSTRABLE effort, expertise, and resources invested.
+Key questions:
+1. REPLICABILITY: How difficult would it be for a competitor to create equal content?
+2. CREATION PROCESS: Does the page "show its work"?
+Look for: In-depth analysis, original data, unique multimedia, transparent methodology
+Score 1-10:
+1-3 = LOW EFFORT: Generic, formulaic, easily replicated in hours
+7-8 = HIGH EFFORT: Significant investment, hard to replicate
+9-10 = EXCEPTIONAL: Original research, proprietary data, unique tools
+Return ONLY the number.""",
+
+    "originality_reasoning": """You are evaluating Content Originality for this page. Analyze and explain in 3-4 sentences:
+- Does this page introduce NEW INFORMATION or a UNIQUE PERSPECTIVE?
+- Or does it just REPHRASE existing knowledge from other sources?
+- Is it substantively unique in phrasing, data, angle, or presentation?
+- What makes it original or generic?
+Be specific with examples.""",
+
+    "originality_score": """You are evaluating Content Originality.
+Does this content ADD NEW INFORMATION to the web, or just rephrase what exists?
+Evaluate:
+- Is the content SUBSTANTIVELY UNIQUE in phrasing, perspective, data?
+- Does it introduce NEW INFORMATION or a UNIQUE ANGLE?
+Red flags: Templated content, spun/paraphrased, generic information
+Score 1-10:
+1-3 = LOW ORIGINALITY: Templated, duplicated, rehashes existing knowledge
+4-6 = MODERATE: Mix of original and generic elements
+7-10 = HIGH ORIGINALITY: Substantively unique, adds new information
+Return ONLY the number.""",
+
+    "intent_reasoning": """You are evaluating Page Intent for this page. Analyze and explain in 3-4 sentences:
+- What is this page's PRIMARY PURPOSE (the "WHY" it exists)?
+- Is it HELPFUL-FIRST (created to help users) or SEARCH-FIRST (created to rank)?
+- Is the intent TRANSPARENT and honest, or DECEPTIVE?
+- What evidence supports your assessment?
+Be specific with examples from the content.""",
+
+    "intent_score": """You are evaluating Page Intent.
+WHY was this page created? What is its PRIMARY PURPOSE?
+Determine if this is:
+- HELPFUL-FIRST: Created primarily to help users/solve problems
+- Or SEARCH-FIRST: Created primarily to rank in search
+Red flags: Thin content for keywords, disguised affiliate, keyword stuffing
+Green flags: Clear user problem solved, transparent purpose, genuine value
+Score 1-10:
+1-3 = DECEPTIVE/SEARCH-FIRST: Created for search traffic, deceptive intent
+4-6 = UNCLEAR: Mixed signals
+7-10 = TRANSPARENT/HELPFUL-FIRST: Created to help people, honest purpose
+Return ONLY the number.""",
+
+    "subjective_reasoning": """You are a brutally honest content critic. Be direct, not nice. Evaluate this content for:
+boring sections, confusing parts, unbelievable claims, unclear audience pain point,
+missing culprit identification, sections that could be condensed, lack of proprietary insights.
+CRITICAL: Provide EXACTLY 2-3 sentences summarizing the main weaknesses.
+NO bullet points. NO lists. NO section headers. NO more than 3 sentences.""",
+
+    "subjective_score": """You are a brutally honest content critic evaluating subjective quality.
+CRITICAL: Put on your most critical hat. Don't be nice. High standards only.
+Evaluate: ENGAGEMENT (boring or compelling?), CLARITY (confusing?), CREDIBILITY (believable?),
+AUDIENCE TARGETING (pain point addressed?), VALUE DENSITY (fluff or substance?)
+Score 1-10:
+1-3 = LOW QUALITY: Boring, confusing, unbelievable, generic advice
+4-6 = MEDIOCRE: Some good parts but significant issues
+7-10 = HIGH QUALITY: Compelling, clear, credible, dense value
+Return ONLY the number.""",
+
+    "writing_reasoning": """You are a writing quality analyst. Evaluate this text's linguistic quality.
+Analyze: lexical diversity (vocabulary richness/repetition), readability (sentence length 15-20 words optimal),
+modal verbs balance, passive voice usage, and heavy adverbs.
+CRITICAL: Provide EXACTLY 2-3 sentences summarizing the main writing issues.
+NO bullet points. NO lists. Maximum 150 words total.""",
+
+    "writing_score": """You are a writing quality analyst evaluating objective linguistic metrics.
+Analyze:
+1. LEXICAL DIVERSITY: Rich vocabulary or repetitive?
+2. READABILITY: Sentence length 15-20 words optimal, mix of easy/medium sentences
+3. LINGUISTIC QUALITY: Modal verbs balanced, minimal passive voice, limited heavy adverbs
+Score 1-10:
+1-3 = POOR: Repetitive vocabulary, long complex sentences, excessive passive/adverbs
+4-6 = AVERAGE: Some issues with readability or linguistic quality
+7-10 = EXCELLENT: Rich vocabulary, optimal sentence length, active voice, concise
+Return ONLY the number."""
+}
+
+@dataclass
+class EEATScore:
+    url: str
+    authorship_score: int = 0
+    authorship_reasoning: str = ""
+    citation_score: int = 0
+    citation_reasoning: str = ""
+    effort_score: int = 0
+    effort_reasoning: str = ""
+    originality_score: int = 0
+    originality_reasoning: str = ""
+    intent_score: int = 0
+    intent_reasoning: str = ""
+    subjective_score: int = 0
+    subjective_reasoning: str = ""
+    writing_score: int = 0
+    writing_reasoning: str = ""
+    overall_score: float = 0.0
+    grade: str = ""
+    analyzed_at: str = ""
+
+class EEATAnalyzer:
+    def __init__(self, output_dir: str, provider: str = "openai", 
+                 model: str = "gpt-4o", temperature: float = 0.3,
+                 weights: Dict[str, float] = None):
+        self.output_dir = Path(output_dir)
+        self.provider = provider
+        self.model = model
+        self.temperature = temperature
+        self.weights = weights or {
+            "authorship": 0.15,
+            "citation": 0.15,
+            "effort": 0.15,
+            "originality": 0.15,
+            "intent": 0.15,
+            "subjective": 0.15,
+            "writing": 0.10
+        }
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.scores: List[EEATScore] = []
+    
+    async def fetch_page_content(self, url: str) -> str:
+        """Fetch page content for analysis"""
+        try:
+            async with self.session.get(url, timeout=30) as response:
+                if response.status == 200:
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+                    
+                    # Remove script and style elements
+                    for element in soup(['script', 'style', 'nav', 'footer', 'header']):
+                        element.decompose()
+                    
+                    # Get text content
+                    text = soup.get_text(separator='\n', strip=True)
+                    
+                    # Truncate to reasonable length for LLM
+                    if len(text) > 15000:
+                        text = text[:15000] + "\n[Content truncated...]"
+                    
+                    return text
+        except Exception as e:
+            print(f"Error fetching {url}: {e}")
+        return ""
+    
+    async def call_llm(self, prompt: str, content: str) -> str:
+        """Call LLM API for analysis"""
+        if self.provider == "openai":
+            return await self._call_openai(prompt, content)
+        elif self.provider == "anthropic":
+            return await self._call_anthropic(prompt, content)
+        return ""
+    
+    async def _call_openai(self, prompt: str, content: str) -> str:
+        """Call OpenAI API"""
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY not set")
+        
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": f"Analyze this content:\n\n{content}"}
+            ],
+            "temperature": self.temperature,
+            "max_tokens": 500
+        }
+        
+        try:
+            async with self.session.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=60
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return data["choices"][0]["message"]["content"].strip()
+                else:
+                    error = await response.text()
+                    print(f"OpenAI API error: {error}")
+        except Exception as e:
+            print(f"OpenAI API call failed: {e}")
+        return ""
+    
+    async def _call_anthropic(self, prompt: str, content: str) -> str:
+        """Call Anthropic API"""
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY not set")
+        
+        headers = {
+            "x-api-key": api_key,
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        }
+        
+        payload = {
+            "model": self.model if "claude" in self.model else "claude-3-sonnet-20240229",
+            "max_tokens": 500,
+            "messages": [
+                {"role": "user", "content": f"{prompt}\n\nAnalyze this content:\n\n{content}"}
+            ]
+        }
+        
+        try:
+            async with self.session.post(
+                "https://api.anthropic.com/v1/messages",
+                headers=headers,
+                json=payload,
+                timeout=60
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return data["content"][0]["text"].strip()
+        except Exception as e:
+            print(f"Anthropic API call failed: {e}")
+        return ""
+    
+    def parse_score(self, response: str) -> int:
+        """Extract numeric score from LLM response"""
+        # Try to find a number 1-10
+        import re
+        numbers = re.findall(r'\b([1-9]|10)\b', response)
+        if numbers:
+            return int(numbers[0])
+        return 5  # Default to middle score
+    
+    def calculate_overall_score(self, score: EEATScore) -> float:
+        """Calculate weighted overall score"""
+        total = (
+            score.authorship_score * self.weights["authorship"] +
+            score.citation_score * self.weights["citation"] +
+            score.effort_score * self.weights["effort"] +
+            score.originality_score * self.weights["originality"] +
+            score.intent_score * self.weights["intent"] +
+            score.subjective_score * self.weights["subjective"] +
+            score.writing_score * self.weights["writing"]
+        )
+        return round(total, 2)
+    
+    def calculate_grade(self, overall_score: float) -> str:
+        """Convert score to letter grade"""
+        if overall_score >= 8.0:
+            return "A"
+        elif overall_score >= 6.5:
+            return "B"
+        elif overall_score >= 5.0:
+            return "C"
+        elif overall_score >= 3.5:
+            return "D"
+        else:
+            return "F"
+    
+    async def analyze_url(self, url: str) -> EEATScore:
+        """Analyze a single URL for E-E-A-T"""
+        print(f"Analyzing: {url}")
+        
+        score = EEATScore(url=url, analyzed_at=datetime.now().isoformat())
+        
+        # Fetch content
+        content = await self.fetch_page_content(url)
+        if not content:
+            print(f"  Could not fetch content for {url}")
+            return score
+        
+        # Analyze each criterion
+        criteria = [
+            ("authorship", "authorship_score", "authorship_reasoning"),
+            ("citation", "citation_score", "citation_reasoning"),
+            ("effort", "effort_score", "effort_reasoning"),
+            ("originality", "originality_score", "originality_reasoning"),
+            ("intent", "intent_score", "intent_reasoning"),
+            ("subjective", "subjective_score", "subjective_reasoning"),
+            ("writing", "writing_score", "writing_reasoning"),
+        ]
+        
+        for criterion, score_attr, reasoning_attr in criteria:
+            print(f"  Evaluating {criterion}...")
+            
+            # Get reasoning
+            reasoning_prompt = PROMPTS[f"{criterion}_reasoning"]
+            reasoning = await self.call_llm(reasoning_prompt, content)
+            setattr(score, reasoning_attr, reasoning)
+            
+            # Get score
+            score_prompt = PROMPTS[f"{criterion}_score"]
+            score_response = await self.call_llm(score_prompt, content)
+            numeric_score = self.parse_score(score_response)
+            setattr(score, score_attr, numeric_score)
+            
+            print(f"    Score: {numeric_score}/10")
+            
+            # Small delay to avoid rate limits
+            await asyncio.sleep(0.5)
+        
+        # Calculate overall score and grade
+        score.overall_score = self.calculate_overall_score(score)
+        score.grade = self.calculate_grade(score.overall_score)
+        
+        print(f"  Overall: {score.overall_score}/10 (Grade: {score.grade})")
+        
+        return score
+    
+    async def analyze_urls(self, urls: List[str]):
+        """Analyze multiple URLs"""
+        headers = {
+            'User-Agent': 'AIDevOps-EEATAnalyzer/1.0'
+        }
+        
+        connector = aiohttp.TCPConnector(limit=5)
+        timeout = aiohttp.ClientTimeout(total=120)
+        
+        async with aiohttp.ClientSession(
+            headers=headers,
+            connector=connector,
+            timeout=timeout
+        ) as session:
+            self.session = session
+            
+            for url in urls:
+                score = await self.analyze_url(url)
+                self.scores.append(score)
+        
+        return self.scores
+    
+    def export_csv(self, filename: str):
+        """Export scores to CSV"""
+        filepath = self.output_dir / filename
+        
+        fieldnames = [
+            'url', 'overall_score', 'grade',
+            'authorship_score', 'authorship_reasoning',
+            'citation_score', 'citation_reasoning',
+            'effort_score', 'effort_reasoning',
+            'originality_score', 'originality_reasoning',
+            'intent_score', 'intent_reasoning',
+            'subjective_score', 'subjective_reasoning',
+            'writing_score', 'writing_reasoning',
+            'analyzed_at'
+        ]
+        
+        with open(filepath, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            for score in self.scores:
+                writer.writerow(asdict(score))
+        
+        print(f"Exported: {filepath}")
+    
+    def export_xlsx(self, filename: str):
+        """Export scores to Excel with formatting"""
+        if not HAS_OPENPYXL:
+            print("openpyxl not installed, skipping XLSX export")
+            return
+        
+        filepath = self.output_dir / filename
+        wb = openpyxl.Workbook()
+        ws = wb.active
+        ws.title = "E-E-A-T Scores"
+        
+        # Headers
+        headers = [
+            'URL', 'Overall Score', 'Grade',
+            'Authorship', 'Authorship Notes',
+            'Citation', 'Citation Notes',
+            'Effort', 'Effort Notes',
+            'Originality', 'Originality Notes',
+            'Intent', 'Intent Notes',
+            'Subjective', 'Subjective Notes',
+            'Writing', 'Writing Notes',
+            'Analyzed At'
+        ]
+        
+        # Header styling
+        header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")
+        header_font = Font(color="FFFFFF", bold=True)
+        
+        for col, header in enumerate(headers, 1):
+            cell = ws.cell(row=1, column=col, value=header)
+            cell.fill = header_fill
+            cell.font = header_font
+            cell.alignment = Alignment(horizontal='center')
+        
+        # Grade colors
+        grade_colors = {
+            'A': '00B050',  # Green
+            'B': '92D050',  # Light green
+            'C': 'FFEB9C',  # Yellow
+            'D': 'FFC7CE',  # Light red
+            'F': 'FF0000',  # Red
+        }
+        
+        # Data rows
+        for row_num, score in enumerate(self.scores, 2):
+            ws.cell(row=row_num, column=1, value=score.url)
+            ws.cell(row=row_num, column=2, value=score.overall_score)
+            
+            grade_cell = ws.cell(row=row_num, column=3, value=score.grade)
+            if score.grade in grade_colors:
+                grade_cell.fill = PatternFill(
+                    start_color=grade_colors[score.grade],
+                    end_color=grade_colors[score.grade],
+                    fill_type="solid"
+                )
+            
+            ws.cell(row=row_num, column=4, value=score.authorship_score)
+            ws.cell(row=row_num, column=5, value=score.authorship_reasoning)
+            ws.cell(row=row_num, column=6, value=score.citation_score)
+            ws.cell(row=row_num, column=7, value=score.citation_reasoning)
+            ws.cell(row=row_num, column=8, value=score.effort_score)
+            ws.cell(row=row_num, column=9, value=score.effort_reasoning)
+            ws.cell(row=row_num, column=10, value=score.originality_score)
+            ws.cell(row=row_num, column=11, value=score.originality_reasoning)
+            ws.cell(row=row_num, column=12, value=score.intent_score)
+            ws.cell(row=row_num, column=13, value=score.intent_reasoning)
+            ws.cell(row=row_num, column=14, value=score.subjective_score)
+            ws.cell(row=row_num, column=15, value=score.subjective_reasoning)
+            ws.cell(row=row_num, column=16, value=score.writing_score)
+            ws.cell(row=row_num, column=17, value=score.writing_reasoning)
+            ws.cell(row=row_num, column=18, value=score.analyzed_at)
+        
+        # Adjust column widths
+        ws.column_dimensions['A'].width = 50
+        ws.column_dimensions['B'].width = 12
+        ws.column_dimensions['C'].width = 8
+        for col in ['D', 'F', 'H', 'J', 'L', 'N', 'P']:
+            ws.column_dimensions[col].width = 10
+        for col in ['E', 'G', 'I', 'K', 'M', 'O', 'Q']:
+            ws.column_dimensions[col].width = 40
+        ws.column_dimensions['R'].width = 20
+        
+        # Freeze header row
+        ws.freeze_panes = 'A2'
+        
+        wb.save(filepath)
+        print(f"Exported: {filepath}")
+    
+    def export_summary(self, filename: str = "eeat-summary.json"):
+        """Export summary statistics"""
+        if not self.scores:
+            return
+        
+        summary = {
+            "analyzed_at": datetime.now().isoformat(),
+            "total_pages": len(self.scores),
+            "average_scores": {
+                "overall": round(sum(s.overall_score for s in self.scores) / len(self.scores), 2),
+                "authorship": round(sum(s.authorship_score for s in self.scores) / len(self.scores), 2),
+                "citation": round(sum(s.citation_score for s in self.scores) / len(self.scores), 2),
+                "effort": round(sum(s.effort_score for s in self.scores) / len(self.scores), 2),
+                "originality": round(sum(s.originality_score for s in self.scores) / len(self.scores), 2),
+                "intent": round(sum(s.intent_score for s in self.scores) / len(self.scores), 2),
+                "subjective": round(sum(s.subjective_score for s in self.scores) / len(self.scores), 2),
+                "writing": round(sum(s.writing_score for s in self.scores) / len(self.scores), 2),
+            },
+            "grade_distribution": {
+                "A": sum(1 for s in self.scores if s.grade == "A"),
+                "B": sum(1 for s in self.scores if s.grade == "B"),
+                "C": sum(1 for s in self.scores if s.grade == "C"),
+                "D": sum(1 for s in self.scores if s.grade == "D"),
+                "F": sum(1 for s in self.scores if s.grade == "F"),
+            },
+            "weakest_areas": [],
+            "strongest_areas": []
+        }
+        
+        # Find weakest and strongest areas
+        avg_scores = summary["average_scores"]
+        sorted_areas = sorted(
+            [(k, v) for k, v in avg_scores.items() if k != "overall"],
+            key=lambda x: x[1]
+        )
+        summary["weakest_areas"] = [a[0] for a in sorted_areas[:2]]
+        summary["strongest_areas"] = [a[0] for a in sorted_areas[-2:]]
+        
+        filepath = self.output_dir / filename
+        with open(filepath, 'w') as f:
+            json.dump(summary, f, indent=2)
+        
+        print(f"Exported: {filepath}")
+        return summary
+
+
+async def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='E-E-A-T Score Analyzer')
+    parser.add_argument('urls', nargs='+', help='URLs to analyze')
+    parser.add_argument('--output', '-o', required=True, help='Output directory')
+    parser.add_argument('--provider', default='openai', choices=['openai', 'anthropic'])
+    parser.add_argument('--model', default='gpt-4o', help='LLM model to use')
+    parser.add_argument('--format', '-f', choices=['csv', 'xlsx', 'all'], default='xlsx')
+    parser.add_argument('--domain', help='Domain name for output files')
+    
+    args = parser.parse_args()
+    
+    # Create output directory
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    analyzer = EEATAnalyzer(
+        output_dir=str(output_dir),
+        provider=args.provider,
+        model=args.model
+    )
+    
+    await analyzer.analyze_urls(args.urls)
+    
+    # Generate filename
+    domain = args.domain or "eeat-analysis"
+    timestamp = datetime.now().strftime("%Y-%m-%d")
+    
+    if args.format in ("xlsx", "all"):
+        analyzer.export_xlsx(f"{domain}-eeat-score-{timestamp}.xlsx")
+    if args.format in ("csv", "all"):
+        analyzer.export_csv(f"{domain}-eeat-score-{timestamp}.csv")
+    
+    summary = analyzer.export_summary()
+    
+    print(f"\n=== E-E-A-T Analysis Summary ===")
+    print(f"Pages analyzed: {summary['total_pages']}")
+    print(f"Average overall score: {summary['average_scores']['overall']}/10")
+    print(f"Grade distribution: A={summary['grade_distribution']['A']}, "
+          f"B={summary['grade_distribution']['B']}, C={summary['grade_distribution']['C']}, "
+          f"D={summary['grade_distribution']['D']}, F={summary['grade_distribution']['F']}")
+    print(f"Weakest areas: {', '.join(summary['weakest_areas'])}")
+    print(f"Strongest areas: {', '.join(summary['strongest_areas'])}")
+    print(f"\nResults saved to: {output_dir}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+PYTHON_SCRIPT
+}
+
+# Analyze crawled pages
+do_analyze() {
+    local input_file="$1"
+    shift
+    
+    if [[ ! -f "$input_file" ]]; then
+        print_error "Input file not found: $input_file"
+        return 1
+    fi
+    
+    # Parse options
+    local output_base="$DEFAULT_OUTPUT_DIR"
+    local format="$OUTPUT_FORMAT"
+    local provider="$LLM_PROVIDER"
+    local model="$LLM_MODEL"
+    
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --output)
+                output_base="$2"
+                shift 2
+                ;;
+            --format)
+                format="$2"
+                shift 2
+                ;;
+            --provider)
+                provider="$2"
+                shift 2
+                ;;
+            --model)
+                model="$2"
+                shift 2
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+    
+    # Extract URLs from crawl data
+    local urls=()
+    if [[ "$input_file" == *.json ]]; then
+        # JSON format - extract URLs with status 200
+        mapfile -t urls < <(jq -r '.[] | select(.status_code == 200) | .url' "$input_file" 2>/dev/null || echo "")
+    elif [[ "$input_file" == *.csv ]]; then
+        # CSV format - extract URLs from first column where status is 200
+        mapfile -t urls < <(tail -n +2 "$input_file" | awk -F',' '$2 == "200" || $2 == 200 {gsub(/"/, "", $1); print $1}')
+    fi
+    
+    if [[ ${#urls[@]} -eq 0 ]]; then
+        print_error "No valid URLs found in input file"
+        return 1
+    fi
+    
+    print_header "E-E-A-T Score Analysis"
+    print_info "Input: $input_file"
+    print_info "URLs to analyze: ${#urls[@]}"
+    
+    # Determine domain from first URL
+    local domain
+    domain=$(get_domain "${urls[0]}")
+    
+    # Get output directory (use same as crawl data if in domain folder)
+    local input_dir
+    input_dir=$(dirname "$input_file")
+    local output_dir
+    
+    if [[ "$input_dir" == *"$domain"* ]]; then
+        output_dir="$input_dir"
+    else
+        output_dir=$(create_output_dir "$domain" "$output_base")
+    fi
+    
+    print_info "Output: $output_dir"
+    
+    # Check Python dependencies
+    if ! python3 -c "import aiohttp, bs4" 2>/dev/null; then
+        print_warning "Installing Python dependencies..."
+        pip3 install aiohttp beautifulsoup4 openpyxl --quiet
+    fi
+    
+    # Generate and run analyzer
+    local analyzer_script="/tmp/eeat_analyzer_$$.py"
+    generate_analyzer_script > "$analyzer_script"
+    
+    # Limit to reasonable number for API costs
+    local max_urls=50
+    if [[ ${#urls[@]} -gt $max_urls ]]; then
+        print_warning "Limiting analysis to first $max_urls URLs (of ${#urls[@]})"
+        urls=("${urls[@]:0:$max_urls}")
+    fi
+    
+    python3 "$analyzer_script" "${urls[@]}" \
+        --output "$output_dir" \
+        --provider "$provider" \
+        --model "$model" \
+        --format "$format" \
+        --domain "$domain"
+    
+    rm -f "$analyzer_script"
+    
+    print_success "E-E-A-T analysis complete!"
+    print_info "Results: $output_dir"
+    
+    return 0
+}
+
+# Score single URL
+do_score() {
+    local url="$1"
+    shift
+    
+    local verbose=false
+    local output_base="$DEFAULT_OUTPUT_DIR"
+    
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --verbose|-v)
+                verbose=true
+                shift
+                ;;
+            --output)
+                output_base="$2"
+                shift 2
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+    
+    local domain
+    domain=$(get_domain "$url")
+    local output_dir
+    output_dir=$(create_output_dir "$domain" "$output_base")
+    
+    print_header "E-E-A-T Score Analysis"
+    print_info "URL: $url"
+    
+    # Check Python dependencies
+    if ! python3 -c "import aiohttp, bs4" 2>/dev/null; then
+        print_warning "Installing Python dependencies..."
+        pip3 install aiohttp beautifulsoup4 openpyxl --quiet
+    fi
+    
+    local analyzer_script="/tmp/eeat_analyzer_$$.py"
+    generate_analyzer_script > "$analyzer_script"
+    
+    python3 "$analyzer_script" "$url" \
+        --output "$output_dir" \
+        --provider "$LLM_PROVIDER" \
+        --model "$LLM_MODEL" \
+        --format "all" \
+        --domain "$domain"
+    
+    rm -f "$analyzer_script"
+    
+    print_success "Analysis complete!"
+    print_info "Results: $output_dir"
+    
+    return 0
+}
+
+# Batch analyze URLs from file
+do_batch() {
+    local urls_file="$1"
+    shift
+    
+    if [[ ! -f "$urls_file" ]]; then
+        print_error "URLs file not found: $urls_file"
+        return 1
+    fi
+    
+    local urls=()
+    while IFS= read -r url; do
+        [[ -n "$url" && ! "$url" =~ ^# ]] && urls+=("$url")
+    done < "$urls_file"
+    
+    if [[ ${#urls[@]} -eq 0 ]]; then
+        print_error "No URLs found in file"
+        return 1
+    fi
+    
+    local output_base="$DEFAULT_OUTPUT_DIR"
+    local format="$OUTPUT_FORMAT"
+    
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --output)
+                output_base="$2"
+                shift 2
+                ;;
+            --format)
+                format="$2"
+                shift 2
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+    
+    local domain
+    domain=$(get_domain "${urls[0]}")
+    local output_dir
+    output_dir=$(create_output_dir "$domain" "$output_base")
+    
+    print_header "E-E-A-T Batch Analysis"
+    print_info "URLs: ${#urls[@]}"
+    print_info "Output: $output_dir"
+    
+    # Check Python dependencies
+    if ! python3 -c "import aiohttp, bs4" 2>/dev/null; then
+        print_warning "Installing Python dependencies..."
+        pip3 install aiohttp beautifulsoup4 openpyxl --quiet
+    fi
+    
+    local analyzer_script="/tmp/eeat_analyzer_$$.py"
+    generate_analyzer_script > "$analyzer_script"
+    
+    python3 "$analyzer_script" "${urls[@]}" \
+        --output "$output_dir" \
+        --provider "$LLM_PROVIDER" \
+        --model "$LLM_MODEL" \
+        --format "$format" \
+        --domain "$domain"
+    
+    rm -f "$analyzer_script"
+    
+    print_success "Batch analysis complete!"
+    print_info "Results: $output_dir"
+    
+    return 0
+}
+
+# Generate report from existing scores
+do_report() {
+    local scores_file="$1"
+    shift
+    
+    if [[ ! -f "$scores_file" ]]; then
+        print_error "Scores file not found: $scores_file"
+        return 1
+    fi
+    
+    print_header "Generating E-E-A-T Report"
+    print_info "Input: $scores_file"
+    
+    # For now, just display summary from JSON
+    if [[ "$scores_file" == *.json ]]; then
+        if command -v jq &> /dev/null; then
+            jq '.' "$scores_file"
+        else
+            cat "$scores_file"
+        fi
+    fi
+    
+    return 0
+}
+
+# Check status
+check_status() {
+    print_header "E-E-A-T Score Helper Status"
+    
+    # Check dependencies
+    print_info "Checking dependencies..."
+    
+    if command -v curl &> /dev/null; then
+        print_success "curl: installed"
+    else
+        print_error "curl: not installed"
+    fi
+    
+    if command -v jq &> /dev/null; then
+        print_success "jq: installed"
+    else
+        print_error "jq: not installed"
+    fi
+    
+    if command -v python3 &> /dev/null; then
+        print_success "python3: installed"
+        
+        if python3 -c "import aiohttp" 2>/dev/null; then
+            print_success "  aiohttp: installed"
+        else
+            print_warning "  aiohttp: not installed (pip3 install aiohttp)"
+        fi
+        
+        if python3 -c "import bs4" 2>/dev/null; then
+            print_success "  beautifulsoup4: installed"
+        else
+            print_warning "  beautifulsoup4: not installed"
+        fi
+        
+        if python3 -c "import openpyxl" 2>/dev/null; then
+            print_success "  openpyxl: installed"
+        else
+            print_warning "  openpyxl: not installed"
+        fi
+    else
+        print_error "python3: not installed"
+    fi
+    
+    # Check API keys
+    print_info "Checking API keys..."
+    
+    if [[ -n "${OPENAI_API_KEY:-}" ]]; then
+        print_success "OPENAI_API_KEY: set"
+    else
+        print_warning "OPENAI_API_KEY: not set"
+    fi
+    
+    if [[ -n "${ANTHROPIC_API_KEY:-}" ]]; then
+        print_success "ANTHROPIC_API_KEY: set"
+    else
+        print_info "ANTHROPIC_API_KEY: not set (optional)"
+    fi
+    
+    # Check config
+    if [[ -f "$CONFIG_FILE" ]]; then
+        print_success "Config: $CONFIG_FILE"
+    else
+        print_info "Config: using defaults"
+    fi
+    
+    return 0
+}
+
+# Show help
+show_help() {
+    cat << 'EOF'
+E-E-A-T Score Helper - Content Quality Analysis
+
+Usage: eeat-score-helper.sh [command] [input] [options]
+
+Commands:
+  analyze <crawl-data>  Analyze pages from site-crawler output
+  score <url>           Score a single URL
+  batch <urls-file>     Batch analyze URLs from a file
+  report <scores-file>  Generate report from existing scores
+  status                Check dependencies and configuration
+  help                  Show this help message
+
+Options:
+  --output <dir>        Output directory (default: ~/Downloads)
+  --format <fmt>        Output format: csv, xlsx, all (default: xlsx)
+  --provider <name>     LLM provider: openai, anthropic (default: openai)
+  --model <name>        LLM model (default: gpt-4o)
+  --verbose             Show detailed output
+
+Examples:
+  # Analyze crawled pages
+  eeat-score-helper.sh analyze ~/Downloads/example.com/_latest/crawl-data.json
+
+  # Score single URL
+  eeat-score-helper.sh score https://example.com/blog/article
+
+  # Batch analyze
+  eeat-score-helper.sh batch urls.txt --format xlsx
+
+  # Check status
+  eeat-score-helper.sh status
+
+Output Structure:
+  ~/Downloads/{domain}/{timestamp}/
+    - {domain}-eeat-score-{date}.xlsx   E-E-A-T scores with reasoning
+    - {domain}-eeat-score-{date}.csv    Same data in CSV format
+    - eeat-summary.json                 Summary statistics
+
+  ~/Downloads/{domain}/_latest -> symlink to latest analysis
+
+Scoring Criteria (1-10 scale):
+  - Authorship & Expertise (15%): Author credentials, verifiable entity
+  - Citation Quality (15%): Source quality, substantiation
+  - Content Effort (15%): Replicability, depth, original research
+  - Original Content (15%): Unique perspective, new information
+  - Page Intent (15%): Helpful-first vs search-first
+  - Subjective Quality (15%): Engagement, clarity, credibility
+  - Writing Quality (10%): Lexical diversity, readability
+
+Grades:
+  A (8.0-10.0): Excellent E-E-A-T
+  B (6.5-7.9):  Good E-E-A-T
+  C (5.0-6.4):  Average E-E-A-T
+  D (3.5-4.9):  Poor E-E-A-T
+  F (1.0-3.4):  Very poor E-E-A-T
+
+Environment Variables:
+  OPENAI_API_KEY      Required for OpenAI provider
+  ANTHROPIC_API_KEY   Required for Anthropic provider
+
+Related:
+  - Site crawler: site-crawler-helper.sh
+  - Crawl4AI: crawl4ai-helper.sh
+EOF
+    return 0
+}
+
+# Main function
+main() {
+    load_config
+    
+    local command="${1:-help}"
+    shift || true
+    
+    case "$command" in
+        analyze)
+            check_dependencies || exit 1
+            check_api_key || exit 1
+            do_analyze "$@"
+            ;;
+        score)
+            check_dependencies || exit 1
+            check_api_key || exit 1
+            do_score "$@"
+            ;;
+        batch)
+            check_dependencies || exit 1
+            check_api_key || exit 1
+            do_batch "$@"
+            ;;
+        report)
+            do_report "$@"
+            ;;
+        status)
+            check_status
+            ;;
+        help|-h|--help|"")
+            show_help
+            ;;
+        *)
+            print_error "Unknown command: $command"
+            show_help
+            exit 1
+            ;;
+    esac
+    
+    return 0
+}
+
+main "$@"