dearsky/wifi-densepose
1
0
Fork 0
Code Issues 20 Pull Requests 5 Actions Packages Projects Releases 1 Wiki Activity

Squashed 'vendor/ruvector/' content from commit b64c2172

Browse Source 
git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
This commit is contained in:
ruv
2026-02-28 14:39:40 -05:00
commit d803bfe2b1
7854 changed files with 3522914 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

510
npm/packages/agentic-synth/examples/ad-roas/campaign-data.js Normal file
View File

@@ -0,0 +1,510 @@
"use strict";
/**
* Ad Campaign Performance Data Generation
*
* Generates realistic ad campaign data including:
* - Campaign metrics (impressions, clicks, conversions, spend)
* - Multi-channel attribution data
* - Customer journey tracking
* - A/B test results
* - Cohort analysis data
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.runCampaignDataExamples = runCampaignDataExamples;
exports.generateGoogleAdsCampaign = generateGoogleAdsCampaign;
exports.generateFacebookAdsCampaign = generateFacebookAdsCampaign;
exports.generateTikTokAdsCampaign = generateTikTokAdsCampaign;
exports.generateAttributionData = generateAttributionData;
exports.generateCustomerJourneys = generateCustomerJourneys;
exports.generateABTestResults = generateABTestResults;
exports.generateCohortAnalysis = generateCohortAnalysis;
exports.generateTimeSeriesCampaignData = generateTimeSeriesCampaignData;
exports.streamCampaignData = streamCampaignData;
exports.generateMultiPlatformBatch = generateMultiPlatformBatch;
const index_js_1 = require("../../src/index.js");
// Example 1: Google Ads campaign metrics
async function generateGoogleAdsCampaign() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini',
apiKey: process.env.GEMINI_API_KEY
});
const campaignSchema = {
campaignId: { type: 'string', required: true },
campaignName: { type: 'string', required: true },
date: { type: 'string', required: true },
platform: { type: 'string', required: true },
adGroup: { type: 'string', required: true },
keyword: { type: 'string', required: true },
impressions: { type: 'number', required: true },
clicks: { type: 'number', required: true },
conversions: { type: 'number', required: true },
cost: { type: 'number', required: true },
revenue: { type: 'number', required: true },
ctr: { type: 'number', required: true },
cpc: { type: 'number', required: true },
cpa: { type: 'number', required: true },
roas: { type: 'number', required: true },
qualityScore: { type: 'number', required: true },
avgPosition: { type: 'number', required: true }
};
const result = await synth.generateStructured({
count: 100,
schema: campaignSchema,
constraints: {
platform: 'Google Ads',
impressions: { min: 1000, max: 100000 },
ctr: { min: 0.01, max: 0.15 },
cpc: { min: 0.50, max: 10.00 },
roas: { min: 0.5, max: 8.0 },
qualityScore: { min: 1, max: 10 },
avgPosition: { min: 1.0, max: 5.0 }
},
format: 'json'
});
console.log('Google Ads Campaign Data:');
console.log(result.data.slice(0, 3));
console.log('Metadata:', result.metadata);
return result;
}
// Example 2: Facebook/Meta Ads campaign performance
async function generateFacebookAdsCampaign() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const facebookSchema = {
adSetId: { type: 'string', required: true },
adSetName: { type: 'string', required: true },
adId: { type: 'string', required: true },
adName: { type: 'string', required: true },
date: { type: 'string', required: true },
platform: { type: 'string', required: true },
objective: { type: 'string', required: true },
impressions: { type: 'number', required: true },
reach: { type: 'number', required: true },
frequency: { type: 'number', required: true },
clicks: { type: 'number', required: true },
linkClicks: { type: 'number', required: true },
ctr: { type: 'number', required: true },
spend: { type: 'number', required: true },
purchases: { type: 'number', required: true },
revenue: { type: 'number', required: true },
cpc: { type: 'number', required: true },
cpm: { type: 'number', required: true },
costPerPurchase: { type: 'number', required: true },
roas: { type: 'number', required: true },
addToCarts: { type: 'number', required: true },
initiateCheckout: { type: 'number', required: true },
relevanceScore: { type: 'number', required: true }
};
const result = await synth.generateStructured({
count: 150,
schema: facebookSchema,
constraints: {
platform: 'Facebook Ads',
objective: ['conversions', 'traffic', 'brand_awareness', 'video_views'],
impressions: { min: 5000, max: 500000 },
frequency: { min: 1.0, max: 5.0 },
cpm: { min: 5.00, max: 50.00 },
roas: { min: 0.8, max: 6.0 },
relevanceScore: { min: 1, max: 10 }
}
});
console.log('Facebook Ads Campaign Data:');
console.log(result.data.slice(0, 3));
return result;
}
// Example 3: TikTok Ads campaign performance
async function generateTikTokAdsCampaign() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const tiktokSchema = {
campaignId: { type: 'string', required: true },
campaignName: { type: 'string', required: true },
adGroupId: { type: 'string', required: true },
adId: { type: 'string', required: true },
date: { type: 'string', required: true },
platform: { type: 'string', required: true },
objective: { type: 'string', required: true },
impressions: { type: 'number', required: true },
clicks: { type: 'number', required: true },
spend: { type: 'number', required: true },
conversions: { type: 'number', required: true },
revenue: { type: 'number', required: true },
videoViews: { type: 'number', required: true },
videoWatchTime: { type: 'number', required: true },
videoCompletionRate: { type: 'number', required: true },
engagement: { type: 'number', required: true },
shares: { type: 'number', required: true },
comments: { type: 'number', required: true },
likes: { type: 'number', required: true },
follows: { type: 'number', required: true },
ctr: { type: 'number', required: true },
cpc: { type: 'number', required: true },
cpm: { type: 'number', required: true },
cpa: { type: 'number', required: true },
roas: { type: 'number', required: true }
};
const result = await synth.generateStructured({
count: 120,
schema: tiktokSchema,
constraints: {
platform: 'TikTok Ads',
objective: ['app_promotion', 'conversions', 'traffic', 'video_views'],
impressions: { min: 10000, max: 1000000 },
videoCompletionRate: { min: 0.1, max: 0.8 },
cpm: { min: 3.00, max: 30.00 },
roas: { min: 0.6, max: 7.0 }
}
});
console.log('TikTok Ads Campaign Data:');
console.log(result.data.slice(0, 3));
return result;
}
// Example 4: Multi-channel attribution data
async function generateAttributionData() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const attributionSchema = {
userId: { type: 'string', required: true },
conversionId: { type: 'string', required: true },
conversionDate: { type: 'string', required: true },
conversionValue: { type: 'number', required: true },
touchpoints: {
type: 'array',
required: true,
items: {
type: 'object',
properties: {
channel: { type: 'string' },
campaign: { type: 'string' },
timestamp: { type: 'string' },
touchpointPosition: { type: 'number' },
attributionWeight: { type: 'number' }
}
}
},
attributionModel: { type: 'string', required: true },
firstTouch: {
type: 'object',
properties: {
channel: { type: 'string' },
value: { type: 'number' }
}
},
lastTouch: {
type: 'object',
properties: {
channel: { type: 'string' },
value: { type: 'number' }
}
},
linearAttribution: { type: 'object', required: false },
timeDecayAttribution: { type: 'object', required: false },
positionBasedAttribution: { type: 'object', required: false }
};
const result = await synth.generateStructured({
count: 80,
schema: attributionSchema,
constraints: {
attributionModel: ['first_touch', 'last_touch', 'linear', 'time_decay', 'position_based'],
touchpoints: { minLength: 2, maxLength: 8 },
conversionValue: { min: 10, max: 5000 }
}
});
console.log('Multi-Channel Attribution Data:');
console.log(result.data.slice(0, 2));
return result;
}
// Example 5: Customer journey tracking
async function generateCustomerJourneys() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const journeySchema = {
journeyId: { type: 'string', required: true },
userId: { type: 'string', required: true },
startDate: { type: 'string', required: true },
endDate: { type: 'string', required: true },
journeyLength: { type: 'number', required: true },
touchpointCount: { type: 'number', required: true },
events: {
type: 'array',
required: true,
items: {
type: 'object',
properties: {
timestamp: { type: 'string' },
eventType: { type: 'string' },
channel: { type: 'string' },
campaign: { type: 'string' },
device: { type: 'string' },
location: { type: 'string' },
pageUrl: { type: 'string' },
duration: { type: 'number' }
}
}
},
converted: { type: 'boolean', required: true },
conversionValue: { type: 'number', required: false },
conversionType: { type: 'string', required: false },
totalAdSpend: { type: 'number', required: true },
roi: { type: 'number', required: false }
};
const result = await synth.generateStructured({
count: 60,
schema: journeySchema,
constraints: {
journeyLength: { min: 1, max: 30 },
touchpointCount: { min: 1, max: 15 },
channel: ['google_ads', 'facebook_ads', 'tiktok_ads', 'email', 'organic_search', 'direct'],
device: ['mobile', 'desktop', 'tablet'],
conversionType: ['purchase', 'signup', 'download', 'lead']
}
});
console.log('Customer Journey Data:');
console.log(result.data.slice(0, 2));
return result;
}
// Example 6: A/B test results
async function generateABTestResults() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const abTestSchema = {
testId: { type: 'string', required: true },
testName: { type: 'string', required: true },
startDate: { type: 'string', required: true },
endDate: { type: 'string', required: true },
platform: { type: 'string', required: true },
testType: { type: 'string', required: true },
variants: {
type: 'array',
required: true,
items: {
type: 'object',
properties: {
variantId: { type: 'string' },
variantName: { type: 'string' },
trafficAllocation: { type: 'number' },
impressions: { type: 'number' },
clicks: { type: 'number' },
conversions: { type: 'number' },
spend: { type: 'number' },
revenue: { type: 'number' },
ctr: { type: 'number' },
cvr: { type: 'number' },
cpa: { type: 'number' },
roas: { type: 'number' }
}
}
},
winner: { type: 'string', required: false },
confidenceLevel: { type: 'number', required: true },
statistically_significant: { type: 'boolean', required: true },
liftPercent: { type: 'number', required: false }
};
const result = await synth.generateStructured({
count: 40,
schema: abTestSchema,
constraints: {
platform: ['Google Ads', 'Facebook Ads', 'TikTok Ads'],
testType: ['creative', 'audience', 'bidding', 'landing_page', 'headline', 'cta'],
variants: { minLength: 2, maxLength: 4 },
confidenceLevel: { min: 0.5, max: 0.99 }
}
});
console.log('A/B Test Results:');
console.log(result.data.slice(0, 2));
return result;
}
// Example 7: Cohort analysis data
async function generateCohortAnalysis() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const cohortSchema = {
cohortId: { type: 'string', required: true },
cohortName: { type: 'string', required: true },
acquisitionDate: { type: 'string', required: true },
channel: { type: 'string', required: true },
campaign: { type: 'string', required: true },
initialUsers: { type: 'number', required: true },
retentionData: {
type: 'array',
required: true,
items: {
type: 'object',
properties: {
period: { type: 'number' },
activeUsers: { type: 'number' },
retentionRate: { type: 'number' },
revenue: { type: 'number' },
avgOrderValue: { type: 'number' },
purchaseFrequency: { type: 'number' }
}
}
},
totalSpend: { type: 'number', required: true },
totalRevenue: { type: 'number', required: true },
ltv: { type: 'number', required: true },
cac: { type: 'number', required: true },
ltvCacRatio: { type: 'number', required: true },
paybackPeriod: { type: 'number', required: true }
};
const result = await synth.generateStructured({
count: 30,
schema: cohortSchema,
constraints: {
channel: ['google_ads', 'facebook_ads', 'tiktok_ads', 'email', 'organic'],
initialUsers: { min: 100, max: 10000 },
retentionData: { minLength: 6, maxLength: 12 },
ltvCacRatio: { min: 0.5, max: 10.0 },
paybackPeriod: { min: 1, max: 24 }
}
});
console.log('Cohort Analysis Data:');
console.log(result.data.slice(0, 2));
return result;
}
// Example 8: Time-series campaign performance
async function generateTimeSeriesCampaignData() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const result = await synth.generateTimeSeries({
count: 90,
startDate: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000),
endDate: new Date(),
interval: '1d',
metrics: [
'impressions',
'clicks',
'conversions',
'spend',
'revenue',
'roas',
'ctr',
'cvr'
],
trend: 'up',
seasonality: true,
noise: 0.15,
constraints: {
impressions: { min: 10000, max: 100000 },
clicks: { min: 100, max: 5000 },
conversions: { min: 10, max: 500 },
spend: { min: 100, max: 5000 },
revenue: { min: 0, max: 25000 },
roas: { min: 0.5, max: 8.0 },
ctr: { min: 0.01, max: 0.1 },
cvr: { min: 0.01, max: 0.15 }
}
});
console.log('Time-Series Campaign Data:');
console.log(result.data.slice(0, 7));
console.log('Metadata:', result.metadata);
return result;
}
// Example 9: Streaming real-time campaign data
async function streamCampaignData() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini',
streaming: true
});
console.log('Streaming campaign data:');
let count = 0;
for await (const dataPoint of synth.generateStream('structured', {
count: 20,
schema: {
timestamp: { type: 'string', required: true },
campaignId: { type: 'string', required: true },
impressions: { type: 'number', required: true },
clicks: { type: 'number', required: true },
conversions: { type: 'number', required: true },
spend: { type: 'number', required: true },
revenue: { type: 'number', required: true },
roas: { type: 'number', required: true }
}
})) {
count++;
console.log(`[${count}] Received:`, dataPoint);
}
}
// Example 10: Batch generation for multiple platforms
async function generateMultiPlatformBatch() {
const synth = (0, index_js_1.createSynth)({
provider: 'gemini'
});
const platformConfigs = [
{
count: 50,
schema: {
platform: { type: 'string' },
impressions: { type: 'number' },
clicks: { type: 'number' },
spend: { type: 'number' },
revenue: { type: 'number' },
roas: { type: 'number' }
},
constraints: { platform: 'Google Ads' }
},
{
count: 50,
schema: {
platform: { type: 'string' },
impressions: { type: 'number' },
clicks: { type: 'number' },
spend: { type: 'number' },
revenue: { type: 'number' },
roas: { type: 'number' }
},
constraints: { platform: 'Facebook Ads' }
},
{
count: 50,
schema: {
platform: { type: 'string' },
impressions: { type: 'number' },
clicks: { type: 'number' },
spend: { type: 'number' },
revenue: { type: 'number' },
roas: { type: 'number' }
},
constraints: { platform: 'TikTok Ads' }
}
];
const results = await synth.generateBatch('structured', platformConfigs, 3);
console.log('Multi-Platform Batch Results:');
results.forEach((result, i) => {
const platforms = ['Google Ads', 'Facebook Ads', 'TikTok Ads'];
console.log(`${platforms[i]}: ${result.metadata.count} records in ${result.metadata.duration}ms`);
console.log('Sample:', result.data.slice(0, 2));
});
return results;
}
// Run all examples
async function runCampaignDataExamples() {
console.log('=== Example 1: Google Ads Campaign ===');
await generateGoogleAdsCampaign();
console.log('\n=== Example 2: Facebook Ads Campaign ===');
await generateFacebookAdsCampaign();
console.log('\n=== Example 3: TikTok Ads Campaign ===');
await generateTikTokAdsCampaign();
console.log('\n=== Example 4: Multi-Channel Attribution ===');
await generateAttributionData();
console.log('\n=== Example 5: Customer Journeys ===');
await generateCustomerJourneys();
console.log('\n=== Example 6: A/B Test Results ===');
await generateABTestResults();
console.log('\n=== Example 7: Cohort Analysis ===');
await generateCohortAnalysis();
console.log('\n=== Example 8: Time-Series Campaign Data ===');
await generateTimeSeriesCampaignData();
console.log('\n=== Example 10: Multi-Platform Batch ===');
await generateMultiPlatformBatch();
}
// Uncomment to run
// runCampaignDataExamples().catch(console.error);
//# sourceMappingURL=campaign-data.js.map