Zero-Click Visibility (AI)

1// Zero-Click Visibility (AI) Measurement System
2interface ZeroClickMeasurement {
3  query: string;
4  platform: string;
5  timestamp: Date;
6  mentionType: 'primary' | 'secondary' | 'comparison' | 'negative' | 'none';
7  sentiment: number; // -1 to 1
8  context: string;
9  competitorMentions: string[];
10}
11 
12interface VisibilityScore {
13  raw: number;
14  weighted: number;
15  value: number; // Estimated monetary value
16}
17 
18interface ZeroClickReport {
19  period: { start: Date; end: Date };
20  totalQueries: number;
21  mentionRate: number;
22  visibilityScore: VisibilityScore;
23  platformBreakdown: Record<string, VisibilityScore>;
24  competitivePosition: number;
25  trendDirection: 'improving' | 'declining' | 'stable';
26  estimatedImpressions: number;
27  estimatedValue: number;
28}
29 
30class ZeroClickVisibilityTracker {
31  private brand: string;
32  private competitors: string[];
33  private querySet: string[];
34  private platforms: string[];
35  private measurements: ZeroClickMeasurement[] = [];
36  
37  // Mention type weights for scoring
38  private readonly mentionWeights = {
39    primary: 1.0,    // Primary/first recommendation
40    secondary: 0.6,  // Mentioned alongside others
41    comparison: 0.4, // Mentioned in comparison
42    negative: -0.3,  // Mentioned negatively
43    none: 0,         // Not mentioned
44  };
45 
46  constructor(config: {
47    brand: string;
48    competitors: string[];
49    querySet: string[];
50    platforms: string[];
51  }) {
52    this.brand = config.brand;
53    this.competitors = config.competitors;
54    this.querySet = config.querySet;
55    this.platforms = config.platforms;
56  }
57 
58  // Record a visibility measurement
59  recordMeasurement(measurement: ZeroClickMeasurement): void {
60    this.measurements.push(measurement);
61  }
62 
63  // Calculate visibility score for a measurement
64  private scoreMeasurement(m: ZeroClickMeasurement): VisibilityScore {
65    const typeWeight = this.mentionWeights[m.mentionType];
66    const sentimentAdjustment = (m.sentiment + 1) / 2; // Normalize to 0-1
67    
68    const raw = m.mentionType !== 'none' ? 1 : 0;
69    const weighted = typeWeight * sentimentAdjustment;
70    
71    // Estimate value based on query volume and category CPM
72    // These would be configured per-query in production
73    const estimatedQueryVolume = 10000; // Placeholder
74    const aiUsageRate = 0.35; // 35% of queries go to AI
75    const categoryCPM = 15; // $15 CPM equivalent
76    
77    const impressions = estimatedQueryVolume * aiUsageRate * (raw > 0 ? 1 : 0);
78    const value = (impressions / 1000) * categoryCPM * weighted;
79 
80    return { raw, weighted, value };
81  }
82 
83  // Generate comprehensive visibility report
84  generateReport(startDate: Date, endDate: Date): ZeroClickReport {
85    const periodMeasurements = this.measurements.filter(
86      m => m.timestamp >= startDate && m.timestamp <= endDate
87    );
88 
89    // Calculate overall metrics
90    const mentionedMeasurements = periodMeasurements.filter(
91      m => m.mentionType !== 'none'
92    );
93    const mentionRate = mentionedMeasurements.length / periodMeasurements.length;
94 
95    // Calculate aggregate visibility score
96    let totalRaw = 0;
97    let totalWeighted = 0;
98    let totalValue = 0;
99 
100    periodMeasurements.forEach(m => {
101      const score = this.scoreMeasurement(m);
102      totalRaw += score.raw;
103      totalWeighted += score.weighted;
104      totalValue += score.value;
105    });
106 
107    const visibilityScore: VisibilityScore = {
108      raw: totalRaw / periodMeasurements.length,
109      weighted: totalWeighted / periodMeasurements.length,
110      value: totalValue,
111    };
112 
113    // Platform breakdown
114    const platformBreakdown: Record<string, VisibilityScore> = {};
115    this.platforms.forEach(platform => {
116      const platformMeasurements = periodMeasurements.filter(
117        m => m.platform === platform
118      );
119      
120      let pRaw = 0, pWeighted = 0, pValue = 0;
121      platformMeasurements.forEach(m => {
122        const score = this.scoreMeasurement(m);
123        pRaw += score.raw;
124        pWeighted += score.weighted;
125        pValue += score.value;
126      });
127 
128      platformBreakdown[platform] = {
129        raw: platformMeasurements.length > 0 ? pRaw / platformMeasurements.length : 0,
130        weighted: platformMeasurements.length > 0 ? pWeighted / platformMeasurements.length : 0,
131        value: pValue,
132      };
133    });
134 
135    // Competitive position (share of mentions vs competitors)
136    let brandMentions = mentionedMeasurements.length;
137    let competitorMentions = 0;
138    periodMeasurements.forEach(m => {
139      competitorMentions += m.competitorMentions.length;
140    });
141    const competitivePosition = brandMentions / (brandMentions + competitorMentions) || 0;
142 
143    // Trend analysis
144    const trendDirection = this.calculateTrend(startDate, endDate);
145 
146    // Estimated impressions
147    const avgQueryVolume = 10000; // Would be per-query in production
148    const aiUsageRate = 0.35;
149    const estimatedImpressions = periodMeasurements.length * avgQueryVolume * aiUsageRate * mentionRate;
150 
151    return {
152      period: { start: startDate, end: endDate },
153      totalQueries: periodMeasurements.length,
154      mentionRate,
155      visibilityScore,
156      platformBreakdown,
157      competitivePosition,
158      trendDirection,
159      estimatedImpressions,
160      estimatedValue: totalValue,
161    };
162  }
163 
164  // Calculate trend direction
165  private calculateTrend(
166    startDate: Date, 
167    endDate: Date
168  ): 'improving' | 'declining' | 'stable' {
169    const midPoint = new Date((startDate.getTime() + endDate.getTime()) / 2);
170    
171    const firstHalf = this.measurements.filter(
172      m => m.timestamp >= startDate && m.timestamp < midPoint
173    );
174    const secondHalf = this.measurements.filter(
175      m => m.timestamp >= midPoint && m.timestamp <= endDate
176    );
177 
178    const firstRate = firstHalf.filter(m => m.mentionType !== 'none').length / firstHalf.length;
179    const secondRate = secondHalf.filter(m => m.mentionType !== 'none').length / secondHalf.length;
180 
181    if (secondRate > firstRate + 0.05) return 'improving';
182    if (secondRate < firstRate - 0.05) return 'declining';
183    return 'stable';
184  }
185 
186  // Compare against previous period
187  comparePeriods(
188    currentStart: Date,
189    currentEnd: Date,
190    previousStart: Date,
191    previousEnd: Date
192  ): {
193    mentionRateChange: number;
194    visibilityScoreChange: number;
195    valueChange: number;
196    competitivePositionChange: number;
197  } {
198    const current = this.generateReport(currentStart, currentEnd);
199    const previous = this.generateReport(previousStart, previousEnd);
200 
201    return {
202      mentionRateChange: ((current.mentionRate - previous.mentionRate) / previous.mentionRate) * 100,
203      visibilityScoreChange: ((current.visibilityScore.weighted - previous.visibilityScore.weighted) / previous.visibilityScore.weighted) * 100,
204      valueChange: ((current.estimatedValue - previous.estimatedValue) / previous.estimatedValue) * 100,
205      competitivePositionChange: ((current.competitivePosition - previous.competitivePosition) / previous.competitivePosition) * 100,
206    };
207  }
208 
209  // Identify optimization opportunities
210  identifyOpportunities(): {
211    type: string;
212    description: string;
213    priority: 'high' | 'medium' | 'low';
214    potentialValueIncrease: number;
215  }[] {
216    const opportunities: {
217      type: string;
218      description: string;
219      priority: 'high' | 'medium' | 'low';
220      potentialValueIncrease: number;
221    }[] = [];
222 
223    // Analyze by platform
224    const report = this.generateReport(
225      new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
226      new Date()
227    );
228 
229    // Find underperforming platforms
230    const avgScore = report.visibilityScore.weighted;
231    Object.entries(report.platformBreakdown).forEach(([platform, score]) => {
232      if (score.weighted < avgScore * 0.5) {
233        opportunities.push({
234          type: 'platform_gap',
235          description: `Low visibility on ${platform} (${(score.weighted * 100).toFixed(1)}% vs ${(avgScore * 100).toFixed(1)}% average)`,
236          priority: 'high',
237          potentialValueIncrease: (avgScore - score.weighted) * 10000, // Simplified estimate
238        });
239      }
240    });
241 
242    // Check competitive position
243    if (report.competitivePosition < 0.3) {
244      opportunities.push({
245        type: 'competitive_gap',
246        description: 'Competitors dominating AI mentions for target queries',
247        priority: 'high',
248        potentialValueIncrease: report.estimatedValue * 0.5,
249      });
250    }
251 
252    // Check for negative mentions
253    const negativeMentions = this.measurements.filter(
254      m => m.mentionType === 'negative'
255    );
256    if (negativeMentions.length > this.measurements.length * 0.1) {
257      opportunities.push({
258        type: 'reputation_issue',
259        description: `${((negativeMentions.length / this.measurements.length) * 100).toFixed(1)}% of mentions are negative`,
260        priority: 'high',
261        potentialValueIncrease: report.estimatedValue * 0.3,
262      });
263    }
264 
265    return opportunities.sort((a, b) => b.potentialValueIncrease - a.potentialValueIncrease);
266  }
267}
268 
269// Usage example
270const tracker = new ZeroClickVisibilityTracker({
271  brand: 'Acme Software',
272  competitors: ['Competitor A', 'Competitor B', 'Competitor C'],
273  querySet: [
274    'best project management software',
275    'project management tools comparison',
276    'how to manage remote teams',
277  ],
278  platforms: ['chatgpt', 'claude', 'gemini', 'perplexity'],
279});
280 
281// Simulate measurements
282tracker.recordMeasurement({
283  query: 'best project management software',
284  platform: 'chatgpt',
285  timestamp: new Date(),
286  mentionType: 'primary',
287  sentiment: 0.8,
288  context: 'Acme Software is recommended for teams looking for intuitive project management',
289  competitorMentions: ['Competitor A'],
290});
291 
292// Generate report
293const report = tracker.generateReport(
294  new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
295  new Date()
296);
297 
298console.log('Zero-Click Visibility Report:', {
299  'Mention Rate': `${(report.mentionRate * 100).toFixed(1)}%`,
300  'Visibility Score': report.visibilityScore.weighted.toFixed(3),
301  'Competitive Position': `${(report.competitivePosition * 100).toFixed(1)}%`,
302  'Estimated Impressions': report.estimatedImpressions.toLocaleString(),
303  'Estimated Value': `$${report.estimatedValue.toLocaleString()}`,
304  'Trend': report.trendDirection,
305});
306 
307// Identify opportunities
308const opportunities = tracker.identifyOpportunities();
309console.log('\nOptimization Opportunities:');
310opportunities.forEach(opp => {
311  console.log(`[${opp.priority.toUpperCase()}] ${opp.type}: ${opp.description}`);
312  console.log(`  Potential value increase: $${opp.potentialValueIncrease.toLocaleString()}`);
313});