AI SERP Layer Analysis

1// AI SERP Layer Analysis implementation
2interface AISerpResult {
3  query: string;
4  platform: 'google_ai_overview' | 'bing_copilot' | 'perplexity' | 'other';
5  timestamp: Date;
6  aiResponse: {
7    content: string;
8    citations: Citation[];
9    format: 'paragraph' | 'list' | 'table' | 'mixed';
10  };
11  traditionalResults: {
12    position: number;
13    url: string;
14    title: string;
15  }[];
16}
17 
18interface Citation {
19  source: string;
20  domain: string;
21  position: number; // Order in AI response
22  context: string; // Surrounding text
23  isAttributed: boolean;
24  contentUsed: string; // Extracted/paraphrased content
25}
26 
27interface AISerpAnalytics {
28  citationShare: number;
29  averagePosition: number;
30  attributionRate: number;
31  contentFidelity: number;
32  competitiveIndex: number;
33}
34 
35class AISerpAnalyzer {
36  private querySet: string[];
37  private domain: string;
38  private competitors: string[];
39  private results: Map<string, AISerpResult[]> = new Map();
40 
41  constructor(config: {
42    querySet: string[];
43    domain: string;
44    competitors: string[];
45  }) {
46    this.querySet = config.querySet;
47    this.domain = config.domain;
48    this.competitors = config.competitors;
49  }
50 
51  // Capture AI SERP results for analysis
52  async captureAISerp(query: string): Promise<AISerpResult> {
53    // Implementation would use browser automation or SERP APIs
54    // to capture AI-generated content from search results
55    
56    const result: AISerpResult = {
57      query,
58      platform: 'google_ai_overview',
59      timestamp: new Date(),
60      aiResponse: {
61        content: '', // Captured AI Overview content
62        citations: [],
63        format: 'mixed',
64      },
65      traditionalResults: [],
66    };
67 
68    // Extract citations from AI response
69    result.aiResponse.citations = this.extractCitations(
70      result.aiResponse.content
71    );
72 
73    return result;
74  }
75 
76  // Extract and parse citations from AI-generated content
77  private extractCitations(content: string): Citation[] {
78    const citations: Citation[] = [];
79    
80    // Parse citation markers, linked sources, and attributed content
81    // Implementation varies by platform
82    
83    return citations;
84  }
85 
86  // Calculate presence metrics for your domain
87  calculatePresenceMetrics(): AISerpAnalytics {
88    let totalQueries = 0;
89    let queriesWithPresence = 0;
90    let totalCitations = 0;
91    let attributedCitations = 0;
92    let positionSum = 0;
93    let fidelitySum = 0;
94 
95    this.results.forEach((results, query) => {
96      totalQueries++;
97      
98      const latestResult = results[results.length - 1];
99      const domainCitations = latestResult.aiResponse.citations
100        .filter(c => c.domain === this.domain);
101 
102      if (domainCitations.length > 0) {
103        queriesWithPresence++;
104        
105        domainCitations.forEach(citation => {
106          totalCitations++;
107          positionSum += citation.position;
108          
109          if (citation.isAttributed) {
110            attributedCitations++;
111          }
112          
113          // Calculate content fidelity (semantic similarity)
114          fidelitySum += this.calculateFidelity(citation);
115        });
116      }
117    });
118 
119    // Calculate competitive index
120    const competitiveIndex = this.calculateCompetitiveIndex();
121 
122    return {
123      citationShare: (queriesWithPresence / totalQueries) * 100,
124      averagePosition: totalCitations > 0 ? positionSum / totalCitations : 0,
125      attributionRate: totalCitations > 0 
126        ? (attributedCitations / totalCitations) * 100 
127        : 0,
128      contentFidelity: totalCitations > 0 
129        ? (fidelitySum / totalCitations) * 100 
130        : 0,
131      competitiveIndex,
132    };
133  }
134 
135  // Compare your AI SERP presence against competitors
136  private calculateCompetitiveIndex(): number {
137    let yourCitations = 0;
138    let competitorCitations = 0;
139 
140    this.results.forEach((results) => {
141      const latestResult = results[results.length - 1];
142      
143      latestResult.aiResponse.citations.forEach(citation => {
144        if (citation.domain === this.domain) {
145          yourCitations++;
146        } else if (this.competitors.includes(citation.domain)) {
147          competitorCitations++;
148        }
149      });
150    });
151 
152    const totalCompetitiveCitations = yourCitations + competitorCitations;
153    return totalCompetitiveCitations > 0
154      ? (yourCitations / totalCompetitiveCitations) * 100
155      : 0;
156  }
157 
158  // Calculate semantic similarity between original and AI-used content
159  private calculateFidelity(citation: Citation): number {
160    // Would use embedding similarity or other NLP techniques
161    // to measure how accurately AI represented source content
162    return 0.85; // Placeholder
163  }
164 
165  // Analyze AI SERP changes over time
166  analyzeTemporalPatterns(query: string): {
167    volatility: number;
168    refreshCycle: number;
169    trendDirection: 'improving' | 'declining' | 'stable';
170  } {
171    const results = this.results.get(query) || [];
172    
173    if (results.length < 2) {
174      return { volatility: 0, refreshCycle: 0, trendDirection: 'stable' };
175    }
176 
177    // Calculate how often AI response changes
178    let changes = 0;
179    let presenceHistory: boolean[] = [];
180 
181    for (let i = 1; i < results.length; i++) {
182      const prev = results[i - 1];
183      const curr = results[i];
184      
185      const prevPresent = prev.aiResponse.citations
186        .some(c => c.domain === this.domain);
187      const currPresent = curr.aiResponse.citations
188        .some(c => c.domain === this.domain);
189      
190      presenceHistory.push(currPresent);
191      
192      if (prevPresent !== currPresent) {
193        changes++;
194      }
195    }
196 
197    // Determine trend direction
198    const recentPresence = presenceHistory.slice(-5);
199    const olderPresence = presenceHistory.slice(-10, -5);
200    
201    const recentRate = recentPresence.filter(Boolean).length / recentPresence.length;
202    const olderRate = olderPresence.length > 0 
203      ? olderPresence.filter(Boolean).length / olderPresence.length 
204      : recentRate;
205 
206    let trendDirection: 'improving' | 'declining' | 'stable' = 'stable';
207    if (recentRate > olderRate + 0.1) trendDirection = 'improving';
208    if (recentRate < olderRate - 0.1) trendDirection = 'declining';
209 
210    return {
211      volatility: changes / (results.length - 1),
212      refreshCycle: this.estimateRefreshCycle(results),
213      trendDirection,
214    };
215  }
216 
217  private estimateRefreshCycle(results: AISerpResult[]): number {
218    // Estimate days between significant AI response changes
219    return 7; // Placeholder
220  }
221 
222  // Generate optimization recommendations
223  generateRecommendations(): {
224    priority: 'high' | 'medium' | 'low';
225    opportunity: string;
226    action: string;
227  }[] {
228    const metrics = this.calculatePresenceMetrics();
229    const recommendations: {
230      priority: 'high' | 'medium' | 'low';
231      opportunity: string;
232      action: string;
233    }[] = [];
234 
235    if (metrics.citationShare < 20) {
236      recommendations.push({
237        priority: 'high',
238        opportunity: 'Low AI SERP presence across target queries',
239        action: 'Audit content structure and authority signals. Implement comprehensive schema markup and improve content comprehensiveness.',
240      });
241    }
242 
243    if (metrics.attributionRate < 50) {
244      recommendations.push({
245        priority: 'medium',
246        opportunity: 'Content being used without attribution',
247        action: 'Add unique data, statistics, and quotable insights that require attribution. Strengthen brand entity signals.',
248      });
249    }
250 
251    if (metrics.contentFidelity < 80) {
252      recommendations.push({
253        priority: 'high',
254        opportunity: 'AI misrepresenting your content',
255        action: 'Simplify key messages, add explicit summaries, and structure content for accurate extraction.',
256      });
257    }
258 
259    if (metrics.competitiveIndex < 30) {
260      recommendations.push({
261        priority: 'high',
262        opportunity: 'Competitors dominating AI SERP citations',
263        action: 'Analyze competitor citation patterns. Identify content gaps and authority differentiators to address.',
264      });
265    }
266 
267    return recommendations;
268  }
269}
270 
271// Usage example
272const analyzer = new AISerpAnalyzer({
273  querySet: [
274    'best project management software',
275    'how to manage remote teams',
276    'project management best practices',
277    'agile vs waterfall methodology',
278  ],
279  domain: 'example.com',
280  competitors: ['competitor1.com', 'competitor2.com', 'competitor3.com'],
281});
282 
283// Run analysis
284const metrics = analyzer.calculatePresenceMetrics();
285console.log('AI SERP Analytics:', {
286  'Citation Share': `${metrics.citationShare.toFixed(1)}%`,
287  'Average Position': metrics.averagePosition.toFixed(2),
288  'Attribution Rate': `${metrics.attributionRate.toFixed(1)}%`,
289  'Content Fidelity': `${metrics.contentFidelity.toFixed(1)}%`,
290  'Competitive Index': `${metrics.competitiveIndex.toFixed(1)}%`,
291});
292 
293// Get recommendations
294const recommendations = analyzer.generateRecommendations();
295recommendations.forEach(rec => {
296  console.log(`[${rec.priority.toUpperCase()}] ${rec.opportunity}`);
297  console.log(`  Action: ${rec.action}`);
298});