# seomachine.yaml
project:
  name: "my-seo-project"
  url: "https://example.com"
  
providers:
  default: "openai"
  openai:
    model: "gpt-4"
    temperature: 0.7
  anthropic:
    model: "claude-sonnet-4"
    
crawlers:
  default: "firecrawl"
  firecrawl:
    api-key: "${FIRECRAWL_API_KEY}"
  crawl4ai:
    api-url: "http://localhost:3000"
    
tasks:
  serp-analysis: true
  keyword-research: true
  competitor-analysis: true
  content-generation: true

// src/tasks/serp-analysis.ts
interface SERPResult {
  position: number;
  title: string;
  url: string;
  snippet: string;
  domain: string;
  cached: boolean;
  similar: string[];
}

async function analyzeSERP(query: string): Promise<SERPResult[]> {
  // 爬取 SERP
  const results = await crawler.search(query, { limit: 20 });
  
  // 提取关键信息
  return results.map(r => ({
    position: r.position,
    title: r.title,
    url: r.url,
    snippet: r.snippet,
    domain: extractDomain(r.url),
    cached: r.cached ?? false,
    similar: r.similar ?? []
  }));
}

{
  "query": "best SEO tools 2026",
  "totalResults": 1250000000,
  "results": [
    {
      "position": 1,
      "title": "Semrush - All-in-one SEO Tool",
      "url": "https://www.semrush.com",
      "domain": "semrush.com",
      "wordCount": 1500,
      "headings": ["Features", "Pricing", "FAQ"],
      "links": 45000
    }
  ],
  "featuredSnippet": {...},
  "peopleAlsoAsk": [...]
}

// src/tasks/keyword-research.ts
interface KeywordData {
  keyword: string;
  searchVolume: number;
  difficulty: number;
  cpc: number;
  competition: 'low' | 'medium' | 'high';
  relatedKeywords: string[];
}

async function researchKeywords(seed: string): Promise<KeywordData[]> {
  // 获取关键词数据
  const keywords = await aiProvider.expandKeywords(seed);
  
  // 获取搜索量/竞争度
  const enriched = await Promise.all(
    keywords.map(async (kw) => ({
      ...kw,
      ...await getKeywordMetrics(kw.keyword)
    }))
  );
  
  return enriched
    .sort((a, b) => b.searchVolume - a.searchVolume)
    .slice(0, 50);
}

// src/tasks/competitor-analysis.ts
interface CompetitorAnalysis {
  url: string;
  domain: string;
  daMoz: number;
  paMoz: number;
  backlinks: number;
  topKeywords: KeywordPosition[];
  contentAnalysis: ContentMetrics;
}

async function analyzeCompetitor(url: string): Promise<CompetitorAnalysis> {
  // 爬取竞品页面
  const page = await crawler.crawl(url);
  
  // 分析页面 SEO
  const onPage = analyzeOnPage(page);
  
  // 获取外链数据
  const backlinks = await backlinkApi.getBacklinks(url);
  
  // 获取排名数据
  const rankings = await serpApi.getRankings(url);
  
  return {
    url,
    domain: extractDomain(url),
    daMoz: backlinks.domainAuthority,
    paMoz: backlinks.pageAuthority,
    backlinks: backlinks.total,
    topKeywords: rankings.keywords.slice(0, 10),
    contentAnalysis: onPage
  };
}

// src/agents/content-agent.ts
interface ContentRequest {
  targetKeyword: string;
  competitorUrls: string[];
  wordCount: number;
  tone: 'professional' | 'casual' | 'technical';
}

async function generateSEOContent(req: ContentRequest): Promise<string> {
  // 1. 获取竞品内容摘要
  const competitorSummaries = await Promise.all(
    req.competitorUrls.map(url => summarizeContent(url))
  );
  
  // 2. 构建提示词
  const prompt = buildPrompt({
    keyword: req.targetKeyword,
    summaries: competitorSummaries,
    wordCount: req.wordCount,
    tone: req.tone
  });
  
  // 3. 调用 AI 生成
  const content = await aiProvider.generate(prompt);
  
  // 4. SEO 检查
  const optimized = await optimizeForSEO(content, {
    keyword: req.targetKeyword,
    minWordCount: req.wordCount
  });
  
  return optimized;
}

// src/providers/index.ts
const PROVIDERS = {
  openai: {
    client: OpenAIClient,
    models: ['gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo']
  },
  anthropic: {
    client: AnthropicClient,
    models: ['claude-3-opus-4', 'claude-3-sonnet-4', 'claude-3-haiku']
  },
  azure: {
    client: AzureOpenAIClient,
    models: ['gpt-4', 'gpt-35-turbo']
  },
  ollama: {
    client: OllamaClient,
    models: ['llama2', 'mistral', 'codellama']
  },
  groq: {
    client: GroqClient,
    models: ['mixtral-8x7b', 'llama2-70b']
  },
  deepseek: {
    client: DeepSeekClient,
    models: ['deepseek-chat']
  }
};

// 根据任务选择最优提供商
async function selectProvider(task: SEOTask): Promise<AIProvider> {
  const provider = PROVIDERS[task.preferredProvider] 
    ?? PROVIDERS.openai;
  
  // 检查 API 配额
  if (await provider.isRateLimited()) {
    // 切换到备用提供商
    return selectAlternateProvider(task);
  }
  
  return provider;
}

// src/crawlers/index.ts
const CRAWLERS = {
  firecrawl: {
    class: FirecrawlCrawler,
    features: ['javascript-rendering', 'screenshots', 'links']
  },
  crawl4ai: {
    class: Crawl4AICrawler,
    features: ['fast', 'markdown', 'html']
  },
  playwright: {
    class: PlaywrightCrawler,
    features: ['full-control', 'cookies', 'stealth']
  }
};

// 多提供商负载均衡
class ProviderPool {
  private providers: AIProvider[];
  
  async generate(prompt: string): Promise<string> {
    // 轮询可用提供商
    for (const provider of this.providers) {
      if (!await provider.isRateLimited()) {
        return provider.generate(prompt);
      }
    }
    // 全部限流，等待后重试
    await this.waitForQuota();
    return this.generate(prompt);
  }
}

// SERP 结果缓存
const serpCache = new LRUCache<string, SERPResult[]>({
  max: 1000,
  ttl: 1000 * 60 * 60 * 24 // 24小时
});

async function getSERPWithCache(query: string): Promise<SERPResult[]> {
  const cached = serpCache.get(query);
  if (cached) return cached;
  
  const result = await crawler.search(query);
  serpCache.set(query, result);
  return result;
}

try {
  await seomachine.run(project);
} catch (error) {
  if (error instanceof RateLimitError) {
    console.log('API 限流，等待后重试...');
    await sleep(60000);
    return seomachine.run(project);
  }
  if (error instanceof CrawlError) {
    console.log('爬取失败，切换爬虫...');
    return seomachine.run(project, { crawler: 'playwright' });
  }
  throw error;
}