工具与插件

// 要点先行：Surfer SEO API 集成示例

class SurferSEOIntegration {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.surferseo.com/v1';
  }
  
  async analyzeContent(url, keyword) {
    const response = await fetch(`${this.baseUrl}/analyze`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        url: url,
        keyword: keyword,
        country: 'cn',
        language: 'zh'
      })
    });
    
    const data = await response.json();
    return this.processAnalysisResults(data);
  }
  
  processAnalysisResults(data) {
    return {
      contentScore: data.score,
      wordCount: data.word_count,
      keywordDensity: data.keyword_density,
      recommendations: data.recommendations,
      competitorAnalysis: data.competitors,
      missingKeywords: data.missing_keywords,
      structureAnalysis: data.structure
    };
  }
  
  async generateContentBrief(keyword, competitors = []) {
    const response = await fetch(`${this.baseUrl}/content-brief`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        keyword: keyword,
        competitors: competitors,
        country: 'cn'
      })
    });
    
    return await response.json();
  }
}

// 要点先行：GEO检测扩展示例

// manifest.json
{
  "manifest_version": 3,
  "name": "GEO Optimizer",
  "version": "1.0",
  "description": "检测和优化页面的GEO友好性",
  "permissions": ["activeTab", "storage"],
  "action": {
    "default_popup": "popup.html",
    "default_title": "GEO Optimizer"
  },
  "content_scripts": [{
    "matches": ["<all_urls>"],
    "js": ["content.js"]
  }]
}

// content.js
class GEOAnalyzer {
  constructor() {
    this.results = {
      structuredData: this.checkStructuredData(),
      semanticMarkup: this.checkSemanticMarkup(),
      contentQuality: this.analyzeContentQuality(),
      technicalSEO: this.checkTechnicalSEO()
    };
  }
  
  checkStructuredData() {
    const scripts = document.querySelectorAll('script[type="application/ld+json"]');
    const structuredData = [];
    
    scripts.forEach(script => {
      try {
        const data = JSON.parse(script.textContent);
        structuredData.push({
          type: data['@type'],
          valid: this.validateSchema(data),
          data: data
        });
      } catch (e) {
        structuredData.push({
          type: 'Invalid JSON',
          valid: false,
          error: e.message
        });
      }
    });
    
    return {
      count: structuredData.length,
      items: structuredData,
      score: this.calculateStructuredDataScore(structuredData)
    };
  }
  
  checkSemanticMarkup() {
    const semanticElements = {
      'article': document.querySelectorAll('article').length,
      'section': document.querySelectorAll('section').length,
      'header': document.querySelectorAll('header').length,
      'footer': document.querySelectorAll('footer').length,
      'nav': document.querySelectorAll('nav').length,
      'aside': document.querySelectorAll('aside').length
    };
    
    const headings = {
      'h1': document.querySelectorAll('h1').length,
      'h2': document.querySelectorAll('h2').length,
      'h3': document.querySelectorAll('h3').length,
      'h4': document.querySelectorAll('h4').length,
      'h5': document.querySelectorAll('h5').length,
      'h6': document.querySelectorAll('h6').length
    };
    
    return {
      semanticElements,
      headings,
      score: this.calculateSemanticScore(semanticElements, headings)
    };
  }
  
  analyzeContentQuality() {
    const textContent = document.body.innerText;
    const wordCount = textContent.split(/\s+/).length;
    const sentences = textContent.split(/[.!?]+/).length;
    const avgWordsPerSentence = wordCount / sentences;
    
    // 简单的可读性评估
    const readabilityScore = this.calculateReadabilityScore(
      wordCount, sentences, avgWordsPerSentence
    );
    
    return {
      wordCount,
      sentences,
      avgWordsPerSentence,
      readabilityScore,
      hasImages: document.querySelectorAll('img').length > 0,
      hasLists: document.querySelectorAll('ul, ol').length > 0
    };
  }
  
  generateReport() {
    return {
      url: window.location.href,
      timestamp: new Date().toISOString(),
      results: this.results,
      overallScore: this.calculateOverallScore(),
      recommendations: this.generateRecommendations()
    };
  }
}

// 在页面加载完成后运行分析
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', runAnalysis);
} else {
  runAnalysis();
}

function runAnalysis() {
  const analyzer = new GEOAnalyzer();
  const report = analyzer.generateReport();
  
  // 发送结果到popup
  chrome.runtime.sendMessage({
    action: 'analysisComplete',
    report: report
  });
}

// 要点先行：GEO优化WordPress插件

<?php
/**
 * Plugin Name: GEO Optimizer
 * Description: 专业的生成引擎优化插件
 * Version: 1.0.0
 */

class GEOOptimizer {
    
    public function __construct() {
        add_action('wp_head', array($this, 'add_structured_data'));
        add_action('save_post', array($this, 'analyze_content_geo_score'));
        add_action('admin_menu', array($this, 'add_admin_menu'));
    }
    
    public function add_structured_data() {
        if (is_single()) {
            global $post;
            $schema = $this->generate_article_schema($post);
            echo '<script type="application/ld+json">' . 
                 json_encode($schema, JSON_UNESCAPED_UNICODE) . 
                 '</script>';
        }
    }
    
    private function generate_article_schema($post) {
        $author = get_the_author_meta('display_name', $post->post_author);
        $author_url = get_author_posts_url($post->post_author);
        
        $schema = array(
            '@context' => 'https://schema.org',
            '@type' => 'Article',
            'headline' => get_the_title($post->ID),
            'description' => get_the_excerpt($post->ID),
            'author' => array(
                '@type' => 'Person',
                'name' => $author,
                'url' => $author_url
            ),
            'publisher' => array(
                '@type' => 'Organization',
                'name' => get_bloginfo('name'),
                'url' => home_url()
            ),
            'datePublished' => get_the_date('c', $post->ID),
            'dateModified' => get_the_modified_date('c', $post->ID),
            'mainEntityOfPage' => get_permalink($post->ID)
        );
        
        // 添加特色图片
        if (has_post_thumbnail($post->ID)) {
            $image = wp_get_attachment_image_src(
                get_post_thumbnail_id($post->ID), 'full'
            );
            $schema['image'] = array(
                '@type' => 'ImageObject',
                'url' => $image[0],
                'width' => $image[1],
                'height' => $image[2]
            );
        }
        
        return $schema;
    }
    
    public function analyze_content_geo_score($post_id) {
        if (wp_is_post_revision($post_id)) return;
        
        $content = get_post_field('post_content', $post_id);
        $title = get_post_field('post_title', $post_id);
        
        $geo_score = $this->calculate_geo_score($content, $title);
        update_post_meta($post_id, '_geo_score', $geo_score);
        
        // 生成优化建议
        $recommendations = $this->generate_recommendations($content, $geo_score);
        update_post_meta($post_id, '_geo_recommendations', $recommendations);
    }
    
    private function calculate_geo_score($content, $title) {
        $score = 0;
        
        // 内容长度评分 (0-25分)
        $word_count = str_word_count(strip_tags($content));
        if ($word_count >= 300) $score += 25;
        else $score += ($word_count / 300) * 25;
        
        // 标题质量评分 (0-25分)
        $title_length = mb_strlen($title);
        if ($title_length >= 30 && $title_length <= 60) $score += 25;
        else $score += max(0, 25 - abs($title_length - 45));
        
        // 结构化内容评分 (0-25分)
        $headings = substr_count($content, '<h');
        $lists = substr_count($content, '<ul>') + substr_count($content, '<ol>');
        $structure_score = min(25, ($headings * 5) + ($lists * 3));
        $score += $structure_score;
        
        // 语义丰富度评分 (0-25分)
        $semantic_score = $this->analyze_semantic_richness($content);
        $score += $semantic_score;
        
        return min(100, $score);
    }
    
    private function analyze_semantic_richness($content) {
        // 简化的语义分析
        $semantic_indicators = array(
            '因为', '所以', '然而', '此外', '例如', '总之',
            '首先', '其次', '最后', '重要的是', '值得注意的是'
        );
        
        $score = 0;
        foreach ($semantic_indicators as $indicator) {
            if (strpos($content, $indicator) !== false) {
                $score += 2;
            }
        }
        
        return min(25, $score);
    }
    
    public function add_admin_menu() {
        add_menu_page(
            'GEO优化',
            'GEO优化',
            'manage_options',
            'geo-optimizer',
            array($this, 'admin_page'),
            'dashicons-search',
            30
        );
    }
    
    public function admin_page() {
        // 管理页面HTML
        echo '<div class="wrap">';
        echo '<h1>GEO优化分析</h1>';
        
        // 显示网站整体GEO得分
        $this->display_site_geo_overview();
        
        echo '</div>';
    }
}

new GEOOptimizer();
?>

// 要点先行：Python GEO分析库

# requirements.txt
requests==2.31.0
beautifulsoup4==4.12.2
spacy==3.7.2
textstat==0.7.3
nltk==3.8.1
pandas==2.1.4
matplotlib==3.8.2

# geo_analyzer.py
import requests
from bs4 import BeautifulSoup
import spacy
import textstat
import json
from urllib.parse import urljoin, urlparse

class GEOAnalyzer:
    def __init__(self):
        # 加载中文语言模型
        try:
            self.nlp = spacy.load("zh_core_web_sm")
        except OSError:
            print("请安装中文语言模型: python -m spacy download zh_core_web_sm")
            self.nlp = None
    
    def analyze_url(self, url):
        """分析指定URL的GEO友好性"""
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            
            soup = BeautifulSoup(response.content, 'html.parser')
            
            analysis = {
                'url': url,
                'title': self.analyze_title(soup),
                'meta_description': self.analyze_meta_description(soup),
                'headings': self.analyze_headings(soup),
                'content': self.analyze_content(soup),
                'structured_data': self.analyze_structured_data(soup),
                'images': self.analyze_images(soup),
                'links': self.analyze_links(soup, url),
                'technical': self.analyze_technical_seo(soup),
                'geo_score': 0
            }
            
            analysis['geo_score'] = self.calculate_geo_score(analysis)
            return analysis
            
        except Exception as e:
            return {'error': str(e), 'url': url}
    
    def analyze_content(self, soup):
        """分析内容质量"""
        # 提取主要内容
        content_text = soup.get_text()
        
        # 基础统计
        word_count = len(content_text.split())
        char_count = len(content_text)
        
        # 可读性分析
        readability = {
            'flesch_reading_ease': textstat.flesch_reading_ease(content_text),
            'flesch_kincaid_grade': textstat.flesch_kincaid_grade(content_text),
            'automated_readability_index': textstat.automated_readability_index(content_text)
        }
        
        # 语义分析（如果有spaCy模型）
        semantic_analysis = {}
        if self.nlp:
            doc = self.nlp(content_text[:1000000])  # 限制长度
            entities = [(ent.text, ent.label_) for ent in doc.ents]
            semantic_analysis = {
                'entities': entities[:20],  # 前20个实体
                'entity_count': len(entities)
            }
        
        return {
            'word_count': word_count,
            'char_count': char_count,
            'readability': readability,
            'semantic_analysis': semantic_analysis
        }
    
    def analyze_structured_data(self, soup):
        """分析结构化数据"""
        structured_data = []
        
        # 查找JSON-LD
        json_ld_scripts = soup.find_all('script', type='application/ld+json')
        for script in json_ld_scripts:
            try:
                data = json.loads(script.string)
                structured_data.append({
                    'type': 'JSON-LD',
                    'schema_type': data.get('@type', 'Unknown'),
                    'valid': True,
                    'data': data
                })
            except json.JSONDecodeError:
                structured_data.append({
                    'type': 'JSON-LD',
                    'valid': False,
                    'error': 'Invalid JSON'
                })
        
        # 查找Microdata
        microdata_items = soup.find_all(attrs={'itemscope': True})
        for item in microdata_items:
            item_type = item.get('itemtype', '')
            structured_data.append({
                'type': 'Microdata',
                'schema_type': item_type.split('/')[-1] if item_type else 'Unknown',
                'valid': True
            })
        
        return {
            'count': len(structured_data),
            'items': structured_data
        }
    
    def calculate_geo_score(self, analysis):
        """计算GEO综合得分"""
        score = 0
        
        # 标题得分 (0-20分)
        if analysis['title']['exists']:
            title_len = len(analysis['title']['text'])
            if 30 <= title_len <= 60:
                score += 20
            else:
                score += max(0, 20 - abs(title_len - 45) / 2)
        
        # 内容得分 (0-30分)
        word_count = analysis['content']['word_count']
        if word_count >= 300:
            score += 30
        else:
            score += (word_count / 300) * 30
        
        # 结构化数据得分 (0-25分)
        if analysis['structured_data']['count'] > 0:
            score += 25
        
        # 标题结构得分 (0-15分)
        headings = analysis['headings']
        if headings['h1_count'] == 1:
            score += 5
        if headings['total_count'] >= 3:
            score += 10
        
        # 图片优化得分 (0-10分)
        images = analysis['images']
        if images['total'] > 0:
            alt_ratio = images['with_alt'] / images['total']
            score += alt_ratio * 10
        
        return min(100, score)

# 使用示例
if __name__ == "__main__":
    analyzer = GEOAnalyzer()
    result = analyzer.analyze_url("https://geo.fan")
    print(f"GEO得分: {result['geo_score']}")
    print(json.dumps(result, ensure_ascii=False, indent=2))