AI Visibility

1// AI Visibility Framework Implementation
2interface VisibilityComponent {
3  id: string;
4  name: string;
5  weight: number;
6  score: number; // 0-100
7  trend: 'improving' | 'declining' | 'stable';
8}
9 
10interface AIVisibilityScore {
11  index: number; // 0-100 composite score
12  components: VisibilityComponent[];
13  competitiveShare: number;
14  qualityScore: number;
15  timestamp: Date;
16  confidence: number;
17}
18 
19interface CompetitorVisibility {
20  competitor: string;
21  index: number;
22  share: number;
23}
24 
25interface AIVisibilityReport {
26  current: AIVisibilityScore;
27  historical: AIVisibilityScore[];
28  competitors: CompetitorVisibility[];
29  opportunities: OptimizationOpportunity[];
30  businessCorrelations: BusinessCorrelation[];
31}
32 
33interface OptimizationOpportunity {
34  type: string;
35  description: string;
36  potentialImpact: number;
37  priority: 'high' | 'medium' | 'low';
38  affectedComponents: string[];
39}
40 
41interface BusinessCorrelation {
42  metric: string;
43  correlation: number;
44  lag: number; // days between visibility change and metric impact
45  significance: number;
46}
47 
48class AIVisibilityFramework {
49  private queryUniverse: string[];
50  private brand: string;
51  private competitors: string[];
52  private platforms: string[];
53  private componentWeights: Record<string, number>;
54  private historicalScores: AIVisibilityScore[] = [];
55 
56  constructor(config: {
57    queryUniverse: string[];
58    brand: string;
59    competitors: string[];
60    platforms: string[];
61    componentWeights?: Record<string, number>;
62  }) {
63    this.queryUniverse = config.queryUniverse;
64    this.brand = config.brand;
65    this.competitors = config.competitors;
66    this.platforms = config.platforms;
67    
68    // Default component weights (customize for your business)
69    this.componentWeights = config.componentWeights || {
70      citationShare: 0.25,
71      queryCoverage: 0.20,
72      mentionQuality: 0.20,
73      accuracy: 0.15,
74      platformConsistency: 0.10,
75      competitivePosition: 0.10,
76    };
77  }
78 
79  // Calculate comprehensive AI Visibility score
80  async calculateVisibility(): Promise<AIVisibilityScore> {
81    const components: VisibilityComponent[] = [];
82 
83    // 1. Citation Share - how often you're cited in AI responses
84    const citationShare = await this.measureCitationShare();
85    components.push({
86      id: 'citationShare',
87      name: 'Citation Share',
88      weight: this.componentWeights.citationShare,
89      score: citationShare.score,
90      trend: this.calculateTrend('citationShare', citationShare.score),
91    });
92 
93    // 2. Query Coverage - what % of target queries include you
94    const queryCoverage = await this.measureQueryCoverage();
95    components.push({
96      id: 'queryCoverage',
97      name: 'Query Coverage',
98      weight: this.componentWeights.queryCoverage,
99      score: queryCoverage.score,
100      trend: this.calculateTrend('queryCoverage', queryCoverage.score),
101    });
102 
103    // 3. Mention Quality - sentiment and prominence of mentions
104    const mentionQuality = await this.measureMentionQuality();
105    components.push({
106      id: 'mentionQuality',
107      name: 'Mention Quality',
108      weight: this.componentWeights.mentionQuality,
109      score: mentionQuality.score,
110      trend: this.calculateTrend('mentionQuality', mentionQuality.score),
111    });
112 
113    // 4. Accuracy - how accurately AI represents your content
114    const accuracy = await this.measureAccuracy();
115    components.push({
116      id: 'accuracy',
117      name: 'Content Accuracy',
118      weight: this.componentWeights.accuracy,
119      score: accuracy.score,
120      trend: this.calculateTrend('accuracy', accuracy.score),
121    });
122 
123    // 5. Platform Consistency - visibility across all platforms
124    const platformConsistency = await this.measurePlatformConsistency();
125    components.push({
126      id: 'platformConsistency',
127      name: 'Platform Consistency',
128      weight: this.componentWeights.platformConsistency,
129      score: platformConsistency.score,
130      trend: this.calculateTrend('platformConsistency', platformConsistency.score),
131    });
132 
133    // 6. Competitive Position - share vs competitors
134    const competitivePosition = await this.measureCompetitivePosition();
135    components.push({
136      id: 'competitivePosition',
137      name: 'Competitive Position',
138      weight: this.componentWeights.competitivePosition,
139      score: competitivePosition.score,
140      trend: this.calculateTrend('competitivePosition', competitivePosition.score),
141    });
142 
143    // Calculate weighted index
144    const index = components.reduce(
145      (sum, c) => sum + c.score * c.weight, 0
146    );
147 
148    // Calculate quality score (subset of components)
149    const qualityScore = (
150      mentionQuality.score + accuracy.score
151    ) / 2;
152 
153    const visibilityScore: AIVisibilityScore = {
154      index,
155      components,
156      competitiveShare: competitivePosition.share,
157      qualityScore,
158      timestamp: new Date(),
159      confidence: this.calculateConfidence(components),
160    };
161 
162    this.historicalScores.push(visibilityScore);
163    return visibilityScore;
164  }
165 
166  // Measure citation share across AI platforms
167  private async measureCitationShare(): Promise<{ score: number; details: any }> {
168    // Implementation would query AI platforms and count citations
169    // Normalize to 0-100 based on maximum possible citations
170    return {
171      score: 62, // Placeholder
172      details: {
173        totalCitations: 156,
174        possibleCitations: 252,
175        byPlatform: {
176          chatgpt: 45,
177          perplexity: 58,
178          claude: 32,
179          gemini: 21,
180        },
181      },
182    };
183  }
184 
185  // Measure query coverage
186  private async measureQueryCoverage(): Promise<{ score: number; details: any }> {
187    // Implementation would test presence across query universe
188    return {
189      score: 48,
190      details: {
191        queriesWithPresence: 241,
192        totalQueries: this.queryUniverse.length,
193      },
194    };
195  }
196 
197  // Measure mention quality (sentiment, prominence, recommendation strength)
198  private async measureMentionQuality(): Promise<{ score: number; details: any }> {
199    return {
200      score: 71,
201      details: {
202        avgSentiment: 0.68,
203        primaryRecommendationRate: 0.23,
204        positiveContextRate: 0.82,
205      },
206    };
207  }
208 
209  // Measure accuracy of AI representation
210  private async measureAccuracy(): Promise<{ score: number; details: any }> {
211    return {
212      score: 84,
213      details: {
214        factuallyAccurate: 0.91,
215        currentInformation: 0.78,
216        completeRepresentation: 0.82,
217      },
218    };
219  }
220 
221  // Measure consistency across platforms
222  private async measurePlatformConsistency(): Promise<{ score: number; details: any }> {
223    const platformScores = {
224      chatgpt: 72,
225      perplexity: 58,
226      claude: 64,
227      gemini: 51,
228    };
229    
230    const scores = Object.values(platformScores);
231    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
232    const stdDev = Math.sqrt(
233      scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length
234    );
235    
236    // Consistency score: 100 = perfectly consistent, 0 = highly variable
237    const consistency = Math.max(0, 100 - (stdDev * 2));
238 
239    return {
240      score: consistency,
241      details: { platformScores, mean, stdDev },
242    };
243  }
244 
245  // Measure competitive position
246  private async measureCompetitivePosition(): Promise<{ score: number; share: number; details: any }> {
247    // Implementation would compare visibility vs competitors
248    const yourVisibility = 62;
249    const competitorVisibilities = [71, 58, 45, 39];
250    const totalVisibility = yourVisibility + competitorVisibilities.reduce((a, b) => a + b, 0);
251    const share = (yourVisibility / totalVisibility) * 100;
252    
253    // Score based on relative position (being #1 = 100, being last = 20)
254    const allVisibilities = [yourVisibility, ...competitorVisibilities].sort((a, b) => b - a);
255    const position = allVisibilities.indexOf(yourVisibility);
256    const positionScore = 100 - (position * 20);
257 
258    return {
259      score: positionScore,
260      share,
261      details: {
262        yourVisibility,
263        competitorVisibilities,
264        rank: position + 1,
265      },
266    };
267  }
268 
269  // Calculate trend for a component
270  private calculateTrend(
271    componentId: string, 
272    currentScore: number
273  ): 'improving' | 'declining' | 'stable' {
274    const previousScores = this.historicalScores
275      .slice(-5)
276      .map(s => s.components.find(c => c.id === componentId)?.score || 0);
277    
278    if (previousScores.length < 2) return 'stable';
279    
280    const avgPrevious = previousScores.reduce((a, b) => a + b, 0) / previousScores.length;
281    
282    if (currentScore > avgPrevious + 3) return 'improving';
283    if (currentScore < avgPrevious - 3) return 'declining';
284    return 'stable';
285  }
286 
287  // Calculate confidence in the visibility score
288  private calculateConfidence(components: VisibilityComponent[]): number {
289    // Higher confidence with more data points and consistent measurements
290    const baseConfidence = 0.7;
291    const dataPointBonus = Math.min(0.2, this.historicalScores.length * 0.02);
292    const consistencyBonus = 0.1; // Would calculate based on measurement variance
293    
294    return Math.min(0.95, baseConfidence + dataPointBonus + consistencyBonus);
295  }
296 
297  // Generate comprehensive visibility report
298  async generateReport(): Promise<AIVisibilityReport> {
299    const current = await this.calculateVisibility();
300    
301    // Competitor visibility
302    const competitorVis: CompetitorVisibility[] = this.competitors.map((comp, i) => ({
303      competitor: comp,
304      index: [71, 58, 45, 39][i] || 50, // Placeholder - would measure
305      share: [26, 21, 16, 14][i] || 10,
306    }));
307 
308    // Identify opportunities
309    const opportunities = this.identifyOpportunities(current);
310 
311    // Business correlations (would be calculated from historical data)
312    const correlations: BusinessCorrelation[] = [
313      {
314        metric: 'Branded Search Volume',
315        correlation: 0.72,
316        lag: 14,
317        significance: 0.95,
318      },
319      {
320        metric: 'Direct Traffic',
321        correlation: 0.58,
322        lag: 21,
323        significance: 0.88,
324      },
325      {
326        metric: 'Demo Requests',
327        correlation: 0.64,
328        lag: 30,
329        significance: 0.91,
330      },
331    ];
332 
333    return {
334      current,
335      historical: this.historicalScores.slice(-12), // Last 12 periods
336      competitors: competitorVis,
337      opportunities,
338      businessCorrelations: correlations,
339    };
340  }
341 
342  // Identify optimization opportunities
343  private identifyOpportunities(
344    visibility: AIVisibilityScore
345  ): OptimizationOpportunity[] {
346    const opportunities: OptimizationOpportunity[] = [];
347 
348    visibility.components.forEach(component => {
349      if (component.score < 50) {
350        opportunities.push({
351          type: 'low_score',
352          description: `${component.name} score (${component.score.toFixed(0)}) is below target. Focus on improving this dimension.`,
353          potentialImpact: (50 - component.score) * component.weight,
354          priority: component.score < 30 ? 'high' : 'medium',
355          affectedComponents: [component.id],
356        });
357      }
358      
359      if (component.trend === 'declining') {
360        opportunities.push({
361          type: 'declining_trend',
362          description: `${component.name} is showing a declining trend. Investigate and address root causes.`,
363          potentialImpact: 5 * component.weight,
364          priority: 'high',
365          affectedComponents: [component.id],
366        });
367      }
368    });
369 
370    // Competitive gap opportunities
371    if (visibility.competitiveShare < 25) {
372      opportunities.push({
373        type: 'competitive_gap',
374        description: 'Competitive share is below 25%. Focus on differentiating content and authority building.',
375        potentialImpact: 15,
376        priority: 'high',
377        affectedComponents: ['competitivePosition', 'citationShare'],
378      });
379    }
380 
381    return opportunities.sort((a, b) => b.potentialImpact - a.potentialImpact);
382  }
383}
384 
385// Usage example
386const framework = new AIVisibilityFramework({
387  queryUniverse: [
388    'best project management software',
389    'how to manage remote teams',
390    'project management vs task management',
391    // ... 500+ queries
392  ],
393  brand: 'Acme Software',
394  competitors: ['Competitor A', 'Competitor B', 'Competitor C', 'Competitor D'],
395  platforms: ['chatgpt', 'perplexity', 'claude', 'gemini'],
396  componentWeights: {
397    citationShare: 0.25,
398    queryCoverage: 0.20,
399    mentionQuality: 0.20,
400    accuracy: 0.15,
401    platformConsistency: 0.10,
402    competitivePosition: 0.10,
403  },
404});
405 
406// Generate visibility report
407framework.generateReport().then(report => {
408  console.log('=== AI VISIBILITY REPORT ===\n');
409  
410  console.log(`AI Visibility Index: ${report.current.index.toFixed(1)}/100`);
411  console.log(`Competitive Share: ${report.current.competitiveShare.toFixed(1)}%`);
412  console.log(`Quality Score: ${report.current.qualityScore.toFixed(1)}/100`);
413  console.log(`Confidence: ${(report.current.confidence * 100).toFixed(0)}%\n`);
414 
415  console.log('Component Breakdown:');
416  report.current.components.forEach(c => {
417    const trendIcon = c.trend === 'improving' ? '↑' : c.trend === 'declining' ? '↓' : '→';
418    console.log(`  ${c.name}: ${c.score.toFixed(0)} ${trendIcon} (weight: ${(c.weight * 100).toFixed(0)}%)`);
419  });
420 
421  console.log('\nCompetitive Landscape:');
422  report.competitors.forEach(c => {
423    console.log(`  ${c.competitor}: Index ${c.index}, Share ${c.share.toFixed(1)}%`);
424  });
425 
426  console.log('\nOptimization Opportunities:');
427  report.opportunities.slice(0, 5).forEach(opp => {
428    console.log(`  [${opp.priority.toUpperCase()}] ${opp.description}`);
429  });
430 
431  console.log('\nBusiness Correlations:');
432  report.businessCorrelations.forEach(corr => {
433    console.log(`  ${corr.metric}: r=${corr.correlation.toFixed(2)} (lag: ${corr.lag} days)`);
434  });
435});