@gurulu/cli 0.4.6 → 1.0.0

package/scripts/seed-test-data.mjs

@@ -1,391 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-const CLICKHOUSE_URL = process.env.CLICKHOUSE_URL || 'http://localhost:8123';
-const SITE_ID = 'cmnuiqwnt0003dfu9tqt81l9d';
-const NUM_USERS = 25;
-const DAYS_BACK = 7;
-
-// ---------------------------------------------------------------------------
-// Reference data
-// ---------------------------------------------------------------------------
-
-const PAGES = [
-  { url: '/', title: 'Gurulu - Analytics Platform' },
-  { url: '/pricing', title: 'Pricing - Gurulu' },
-  { url: '/blog', title: 'Blog - Gurulu' },
-  { url: '/blog/getting-started', title: 'Getting Started with Gurulu' },
-  { url: '/blog/privacy-first-analytics', title: 'Privacy-First Analytics' },
-  { url: '/docs', title: 'Documentation - Gurulu' },
-  { url: '/docs/installation', title: 'Installation Guide - Gurulu' },
-  { url: '/docs/api-reference', title: 'API Reference - Gurulu' },
-  { url: '/login', title: 'Login - Gurulu' },
-  { url: '/dashboard', title: 'Dashboard - Gurulu' },
-  { url: '/features', title: 'Features - Gurulu' },
-  { url: '/about', title: 'About Us - Gurulu' },
-  { url: '/contact', title: 'Contact - Gurulu' },
-];
-
-const EVENT_TYPES = ['pageview', 'click', 'scroll_depth', 'custom'];
-const CUSTOM_EVENT_NAMES = [
-  'signup',
-  'purchase',
-  'download',
-  'contact_form',
-  'newsletter_subscribe',
-];
-
-const UTM_SOURCES = [
-  { source: '', medium: '', campaign: '' }, // direct
-  { source: '', medium: '', campaign: '' }, // direct (weighted)
-  { source: 'google', medium: 'organic', campaign: '' },
-  { source: 'google', medium: 'cpc', campaign: 'spring_2026' },
-  { source: 'google', medium: 'cpc', campaign: 'brand_awareness' },
-  { source: 'twitter', medium: 'social', campaign: 'launch_tweet' },
-  { source: 'linkedin', medium: 'social', campaign: 'b2b_outreach' },
-  { source: 'newsletter', medium: 'email', campaign: 'weekly_digest' },
-  { source: 'newsletter', medium: 'email', campaign: 'product_update' },
-  { source: 'producthunt', medium: 'referral', campaign: '' },
-  { source: 'reddit', medium: 'social', campaign: '' },
-];
-
-const REFERRERS = [
-  '',
-  '',
-  'https://www.google.com/',
-  'https://www.google.com/search?q=analytics+platform',
-  'https://twitter.com/',
-  'https://www.linkedin.com/feed/',
-  'https://news.ycombinator.com/',
-  'https://www.reddit.com/r/analytics/',
-  'https://www.producthunt.com/',
-  'https://mail.google.com/',
-];
-
-const DEVICES = [
-  { type: 'desktop', width: 1920, height: 1080 },
-  { type: 'desktop', width: 2560, height: 1440 },
-  { type: 'desktop', width: 1440, height: 900 },
-  { type: 'mobile', width: 390, height: 844 },
-  { type: 'mobile', width: 412, height: 915 },
-  { type: 'mobile', width: 375, height: 812 },
-  { type: 'tablet', width: 820, height: 1180 },
-  { type: 'tablet', width: 1024, height: 1366 },
-];
-
-const BROWSERS = ['Chrome', 'Firefox', 'Safari', 'Edge', 'Arc'];
-const OSES = ['Windows', 'macOS', 'Linux', 'iOS', 'Android'];
-const COUNTRIES = ['US', 'TR', 'GB', 'DE', 'FR', 'NL', 'CA', 'AU', 'JP', 'BR'];
-const CITIES_BY_COUNTRY = {
-  US: ['New York', 'San Francisco', 'Chicago', 'Austin', 'Seattle'],
-  TR: ['Istanbul', 'Ankara', 'Izmir'],
-  GB: ['London', 'Manchester', 'Edinburgh'],
-  DE: ['Berlin', 'Munich', 'Hamburg'],
-  FR: ['Paris', 'Lyon', 'Marseille'],
-  NL: ['Amsterdam', 'Rotterdam'],
-  CA: ['Toronto', 'Vancouver'],
-  AU: ['Sydney', 'Melbourne'],
-  JP: ['Tokyo', 'Osaka'],
-  BR: ['Sao Paulo', 'Rio de Janeiro'],
-};
-const LANGUAGES = ['en-US', 'tr-TR', 'en-GB', 'de-DE', 'fr-FR', 'ja-JP', 'pt-BR'];
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function pick(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-
-function weightedPick(arr, weights) {
-  const total = weights.reduce((a, b) => a + b, 0);
-  let r = Math.random() * total;
-  for (let i = 0; i < arr.length; i++) {
-    r -= weights[i];
-    if (r <= 0) return arr[i];
-  }
-  return arr[arr.length - 1];
-}
-
-function randInt(min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-/** Format Date to ClickHouse DateTime64(3) — no T, no Z, space-separated. */
-function formatCH(date) {
-  const y = date.getUTCFullYear();
-  const mo = String(date.getUTCMonth() + 1).padStart(2, '0');
-  const d = String(date.getUTCDate()).padStart(2, '0');
-  const h = String(date.getUTCHours()).padStart(2, '0');
-  const mi = String(date.getUTCMinutes()).padStart(2, '0');
-  const s = String(date.getUTCSeconds()).padStart(2, '0');
-  const ms = String(date.getUTCMilliseconds()).padStart(3, '0');
-  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
-}
-
-// ---------------------------------------------------------------------------
-// User profile generation
-// ---------------------------------------------------------------------------
-
-function createUserProfile(index) {
-  const device = pick(DEVICES);
-  const country = pick(COUNTRIES);
-  const city = pick(CITIES_BY_COUNTRY[country]);
-  const os =
-    device.type === 'mobile'
-      ? pick(['iOS', 'Android'])
-      : device.type === 'tablet'
-        ? pick(['iOS', 'Android'])
-        : pick(['Windows', 'macOS', 'Linux']);
-  const browser =
-    os === 'iOS' || os === 'macOS'
-      ? pick(['Safari', 'Chrome', 'Arc'])
-      : pick(['Chrome', 'Firefox', 'Edge']);
-
-  return {
-    anonymous_id: randomUUID(),
-    canonical_id: index < 6 ? `user_${randomUUID().slice(0, 8)}` : '', // ~25% identified
-    device,
-    browser,
-    os,
-    country,
-    city,
-    language: pick(LANGUAGES),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Event generation
-// ---------------------------------------------------------------------------
-
-function generateSessionEvents(user, sessionStart) {
-  const events = [];
-  const session_id = randomUUID();
-  const utm = pick(UTM_SOURCES);
-  const referrer = utm.source
-    ? pick(REFERRERS.filter((r) => r !== '')) || ''
-    : pick(['', '']);
-
-  // Each session has 1–12 pageviews + some interactions
-  const pageCount = randInt(1, 12);
-  let cursor = new Date(sessionStart);
-
-  for (let p = 0; p < pageCount; p++) {
-    const page = p === 0 ? pick(PAGES.slice(0, 5)) : pick(PAGES); // entry pages biased to top-level
-
-    // Pageview event
-    events.push(makeEvent(user, session_id, 'pageview', 'pageview', page, cursor, utm, referrer));
-
-    // Advance time 5–60s
-    cursor = new Date(cursor.getTime() + randInt(5000, 60000));
-
-    // Possibly add scroll depth (60% chance)
-    if (Math.random() < 0.6) {
-      const depth = weightedPick([25, 50, 75, 100], [3, 4, 2, 1]);
-      events.push(
-        makeEvent(user, session_id, 'scroll_depth', 'scroll_depth', page, cursor, utm, referrer, {
-          depth,
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 10000));
-    }
-
-    // Possibly add a click (40% chance)
-    if (Math.random() < 0.4) {
-      const clickTargets = ['cta_button', 'nav_link', 'pricing_toggle', 'faq_accordion', 'hero_cta'];
-      events.push(
-        makeEvent(user, session_id, 'click', 'click', page, cursor, utm, referrer, {
-          target: pick(clickTargets),
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(1000, 5000));
-    }
-
-    // On certain pages, add custom events
-    if (page.url === '/contact' && Math.random() < 0.3) {
-      events.push(
-        makeEvent(user, session_id, 'custom', 'contact_form', page, cursor, utm, referrer, {
-          form_type: 'inquiry',
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 5000));
-    }
-
-    if (page.url === '/pricing' && Math.random() < 0.15) {
-      events.push(
-        makeEvent(user, session_id, 'custom', 'purchase', page, cursor, utm, referrer, {
-          plan: pick(['starter', 'pro', 'enterprise']),
-          value: pick([29, 79, 199]),
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 5000));
-    }
-
-    if (page.url === '/login' && Math.random() < 0.4) {
-      events.push(
-        makeEvent(user, session_id, 'custom', 'signup', page, cursor, utm, referrer, {
-          method: pick(['email', 'google', 'github']),
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 5000));
-    }
-
-    if (page.url === '/docs' && Math.random() < 0.25) {
-      events.push(
-        makeEvent(user, session_id, 'custom', 'download', page, cursor, utm, referrer, {
-          asset: pick(['sdk_js', 'sdk_react', 'whitepaper']),
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 5000));
-    }
-
-    if (page.url === '/blog' && Math.random() < 0.2) {
-      events.push(
-        makeEvent(user, session_id, 'custom', 'newsletter_subscribe', page, cursor, utm, referrer, {
-          source: 'blog_sidebar',
-        }),
-      );
-      cursor = new Date(cursor.getTime() + randInt(2000, 5000));
-    }
-
-    // Advance between pages 3–90s
-    cursor = new Date(cursor.getTime() + randInt(3000, 90000));
-  }
-
-  return events;
-}
-
-function makeEvent(user, session_id, event_type, event_name, page, timestamp, utm, referrer, props = {}) {
-  return {
-    site_id: SITE_ID,
-    event_id: randomUUID(),
-    session_id,
-    canonical_id: user.canonical_id,
-    anonymous_id: user.anonymous_id,
-    event_type,
-    event_name,
-    page_url: `https://gurulu.io${page.url}`,
-    page_title: page.title,
-    referrer,
-    utm_source: utm.source,
-    utm_medium: utm.medium,
-    utm_campaign: utm.campaign,
-    utm_term: '',
-    utm_content: '',
-    device_type: user.device.type,
-    browser: user.browser,
-    os: user.os,
-    country: user.country,
-    city: user.city,
-    language: user.language,
-    screen_width: user.device.width,
-    screen_height: user.device.height,
-    properties: JSON.stringify(props),
-    consent_level: pick(['necessary', 'analytics', 'full']),
-    timestamp: formatCH(timestamp),
-    received_at: formatCH(new Date(timestamp.getTime() + randInt(50, 500))),
-    is_bot: 0,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main() {
-  console.log('Generating test events...');
-
-  const now = Date.now();
-  const users = Array.from({ length: NUM_USERS }, (_, i) => createUserProfile(i));
-  const allEvents = [];
-
-  for (const user of users) {
-    // Each user has 1–5 sessions across the 7 days
-    const sessionCount = randInt(1, 5);
-    for (let s = 0; s < sessionCount; s++) {
-      const dayOffset = randInt(0, DAYS_BACK - 1);
-      const hourOffset = randInt(6, 23); // bias toward waking hours
-      const minuteOffset = randInt(0, 59);
-
-      const sessionStart = new Date(now - dayOffset * 86400000);
-      sessionStart.setUTCHours(hourOffset, minuteOffset, 0, 0);
-
-      const events = generateSessionEvents(user, sessionStart);
-      allEvents.push(...events);
-    }
-  }
-
-  // Sort by timestamp
-  allEvents.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-
-  console.log(`Generated ${allEvents.length} events from ${NUM_USERS} users.`);
-
-  // Insert into ClickHouse in batches
-  const BATCH_SIZE = 200;
-  let inserted = 0;
-
-  for (let i = 0; i < allEvents.length; i += BATCH_SIZE) {
-    const batch = allEvents.slice(i, i + BATCH_SIZE);
-    const body = batch.map((e) => JSON.stringify(e)).join('\n');
-
-    const res = await fetch(
-      `${CLICKHOUSE_URL}/?database=gurulu&query=${encodeURIComponent('INSERT INTO events_raw FORMAT JSONEachRow')}`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body,
-      },
-    );
-
-    if (!res.ok) {
-      const text = await res.text();
-      console.error(`ClickHouse error (batch ${Math.floor(i / BATCH_SIZE) + 1}):`, text);
-      process.exit(1);
-    }
-
-    inserted += batch.length;
-    process.stdout.write(`\rInserted ${inserted}/${allEvents.length} events`);
-  }
-
-  console.log('\n');
-
-  // Summary
-  const eventTypes = {};
-  const utmSources = {};
-  const deviceTypes = {};
-  const identifiedCount = allEvents.filter((e) => e.canonical_id).length;
-  const uniqueSessions = new Set(allEvents.map((e) => e.session_id)).size;
-
-  for (const e of allEvents) {
-    eventTypes[e.event_name] = (eventTypes[e.event_name] || 0) + 1;
-    if (e.utm_source) utmSources[e.utm_source] = (utmSources[e.utm_source] || 0) + 1;
-    else utmSources['(direct)'] = (utmSources['(direct)'] || 0) + 1;
-    deviceTypes[e.device_type] = (deviceTypes[e.device_type] || 0) + 1;
-  }
-
-  console.log('=== Seed Summary ===');
-  console.log(`Total events:    ${allEvents.length}`);
-  console.log(`Unique users:    ${NUM_USERS}`);
-  console.log(`Unique sessions: ${uniqueSessions}`);
-  console.log(`Identified:      ${identifiedCount} events (${((identifiedCount / allEvents.length) * 100).toFixed(1)}%)`);
-  console.log(`Date range:      ${allEvents[0].timestamp} → ${allEvents[allEvents.length - 1].timestamp}`);
-  console.log('\nEvent types:');
-  for (const [k, v] of Object.entries(eventTypes).sort((a, b) => b[1] - a[1])) {
-    console.log(`  ${k.padEnd(24)} ${v}`);
-  }
-  console.log('\nUTM sources:');
-  for (const [k, v] of Object.entries(utmSources).sort((a, b) => b[1] - a[1])) {
-    console.log(`  ${k.padEnd(24)} ${v}`);
-  }
-  console.log('\nDevice types:');
-  for (const [k, v] of Object.entries(deviceTypes).sort((a, b) => b[1] - a[1])) {
-    console.log(`  ${k.padEnd(24)} ${v}`);
-  }
-
-  console.log('\nDone!');
-}
-
-main().catch((err) => {
-  console.error('Fatal error:', err);
-  process.exit(1);
-});

package/scripts/spike-browserless.ts

@@ -1,65 +0,0 @@
-/**
- * Phase 11 Track B — B1 spike script
- *
- * Run with: npx tsx scripts/spike-browserless.ts
- *
- * Prereq: `docker compose up -d browserless`. Connects to the local
- * browserless service, loads https://example.com, captures a screenshot
- * to /tmp/spike-browserless.png, then closes the session.
- */
-
-import { chromium } from 'playwright-core';
-import { statSync } from 'node:fs';
-import {
-  getBrowserlessBaseUrl,
-  getBrowserlessToken,
-  spawnRemoteSession,
-} from '../src/lib/playground/browserless';
-
-const SCREENSHOT_PATH = '/tmp/spike-browserless.png';
-const TARGET_URL = 'https://example.com';
-const SESSION_ID = 'spike-test';
-
-async function main() {
-  const startedAt = Date.now();
-  console.log('[spike] browserless base URL:', getBrowserlessBaseUrl());
-  console.log('[spike] using token prefix  :', getBrowserlessToken().slice(0, 6) + '…');
-
-  console.log('[spike] spawning remote session…');
-  const session = await spawnRemoteSession({
-    url: TARGET_URL,
-    sessionId: SESSION_ID,
-  });
-  console.log('[spike] session ready:', {
-    sessionId: session.sessionId,
-    wsEndpoint: session.wsEndpoint,
-    startedAt: session.startedAt.toISOString(),
-  });
-
-  // Reconnect with the returned CDP endpoint to prove the contract: the
-  // caller can take the endpoint and drive Playwright on their own.
-  const browser = await chromium.connectOverCDP(session.wsEndpoint);
-  try {
-    const context = browser.contexts()[0] ?? (await browser.newContext());
-    const page = context.pages()[0] ?? (await context.newPage());
-    console.log('[spike] capturing screenshot →', SCREENSHOT_PATH);
-    await page.screenshot({ path: SCREENSHOT_PATH, fullPage: true });
-  } finally {
-    await browser.close().catch(() => {});
-  }
-
-  await session.close();
-  const size = statSync(SCREENSHOT_PATH).size;
-  const durationMs = Date.now() - startedAt;
-  if (size === 0) {
-    throw new Error('Screenshot file is empty');
-  }
-  console.log(
-    `[spike] ✓ success — screenshot ${size} bytes at ${SCREENSHOT_PATH} (${durationMs}ms)`,
-  );
-}
-
-main().catch((err) => {
-  console.error('[spike] ✗ failed:', err);
-  process.exit(1);
-});

package/scripts/tenant-pivot-consistency-check.mjs

@@ -1,205 +0,0 @@
-#!/usr/bin/env node
-/**
- * Phase 16 B2 — Tenant pivot consistency check.
- *
- * For a given tenant, runs the analytics read path twice:
- *   1. LEGACY: WHERE site_id IN (<sites from Prisma>)
- *   2. TENANT: WHERE tenant_id = <tenantId>
- * and diffs the row counts + a handful of key aggregates. Prints a report.
- *
- * Operators use this to validate that the tenant_id column on `events_raw` is
- * fully backfilled and consistent with the Prisma site→tenant mapping before
- * flipping `ANALYTICS_TENANT_READ_PATH=1` in prod.
- *
- * Usage:
- *   node scripts/tenant-pivot-consistency-check.mjs --tenant-id <id> \
- *     [--from <iso>] [--to <iso>]
- *
- * Environment:
- *   CLICKHOUSE_URL       (default http://localhost:8123)
- *   CLICKHOUSE_DATABASE  (default gurulu)
- *
- * Safe to run in prod — read-only, no side effects.
- */
-
-// ---------------------------------------------------------------------------
-// CLI arg parsing
-// ---------------------------------------------------------------------------
-
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 2; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--tenant-id') args.tenantId = argv[++i];
-    else if (a === '--from') args.from = argv[++i];
-    else if (a === '--to') args.to = argv[++i];
-    else if (a === '--help' || a === '-h') args.help = true;
-  }
-  return args;
-}
-
-function printHelp() {
-  console.log(
-    `\nUsage: node scripts/tenant-pivot-consistency-check.mjs --tenant-id <id> [--from <iso>] [--to <iso>]\n\n` +
-      `  --tenant-id   Required. The tenant id to audit.\n` +
-      `  --from        Optional. ISO timestamp for lower bound (default: 7d ago).\n` +
-      `  --to          Optional. ISO timestamp for upper bound (default: now).\n`
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Diff helper — exported for unit tests.
-// ---------------------------------------------------------------------------
-
-/**
- * Compare two aggregate result bags and return a structured diff.
- *
- * Each bag is a flat object like:
- *   { events: 1234, visitors: 56, sessions: 78, pageviews: 910 }
- *
- * The diff returns:
- *   { ok: boolean, mismatches: Array<{key, legacy, tenant, absDelta, relDelta}> }
- *
- * A key is considered a mismatch when abs(legacy - tenant) > absTolerance AND
- * abs((legacy - tenant) / legacy) > relTolerance (if legacy != 0). This keeps
- * the check resilient to harmless rounding in floating-point aggregates.
- */
-export function diffAggregates(legacy, tenant, opts = {}) {
-  const absTolerance = opts.absTolerance ?? 0;
-  const relTolerance = opts.relTolerance ?? 0;
-
-  const keys = new Set([...Object.keys(legacy || {}), ...Object.keys(tenant || {})]);
-  const mismatches = [];
-
-  for (const key of keys) {
-    const l = Number(legacy?.[key] ?? 0);
-    const t = Number(tenant?.[key] ?? 0);
-    const absDelta = Math.abs(l - t);
-    const relDelta = l !== 0 ? Math.abs((l - t) / l) : absDelta > 0 ? 1 : 0;
-
-    const overAbs = absDelta > absTolerance;
-    const overRel = relDelta > relTolerance;
-    if (overAbs && overRel) {
-      mismatches.push({ key, legacy: l, tenant: t, absDelta, relDelta });
-    }
-  }
-
-  return { ok: mismatches.length === 0, mismatches };
-}
-
-// ---------------------------------------------------------------------------
-// ClickHouse helper (mirrors src/lib/clickhouse.ts — kept inline so this
-// script is `node`-runnable without a TS toolchain).
-// ---------------------------------------------------------------------------
-
-async function clickhouseQuery(query, params = {}) {
-  const CLICKHOUSE_URL = process.env.CLICKHOUSE_URL || 'http://localhost:8123';
-  const CLICKHOUSE_DB = process.env.CLICKHOUSE_DATABASE || 'gurulu';
-
-  const url = new URL(CLICKHOUSE_URL);
-  url.searchParams.set('database', CLICKHOUSE_DB);
-  url.searchParams.set('default_format', 'JSON');
-  for (const [k, v] of Object.entries(params)) {
-    let s = String(v);
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*Z$/.test(s)) {
-      s = s.replace('T', ' ').replace('Z', '');
-    }
-    url.searchParams.set(`param_${k}`, s);
-  }
-
-  const res = await fetch(url.toString(), {
-    method: 'POST',
-    body: query,
-    headers: { 'Content-Type': 'text/plain' },
-  });
-  if (!res.ok) throw new Error(`ClickHouse error ${res.status}: ${await res.text()}`);
-  return res.json();
-}
-
-function escapeSiteId(s) {
-  const cleaned = String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-  return `'${cleaned}'`;
-}
-
-// ---------------------------------------------------------------------------
-// Main.
-// ---------------------------------------------------------------------------
-
-async function main() {
-  const args = parseArgs(process.argv);
-  if (args.help || !args.tenantId) {
-    printHelp();
-    if (!args.tenantId) process.exit(1);
-    return;
-  }
-
-  const to = args.to || new Date().toISOString();
-  const from = args.from || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
-
-  console.log(`[consistency-check] tenant=${args.tenantId} window=${from}..${to}`);
-
-  // Resolve site ids via Prisma — lazy-loaded so the test importing
-  // `diffAggregates` doesn't have to pay the Prisma client cost.
-  const { PrismaClient } = await import('@prisma/client');
-  const prisma = new PrismaClient();
-  const sites = await prisma.site.findMany({
-    where: { tenantId: args.tenantId },
-    select: { id: true },
-  });
-  await prisma.$disconnect();
-
-  if (sites.length === 0) {
-    console.error(`[consistency-check] no sites found for tenant ${args.tenantId}`);
-    process.exit(2);
-  }
-  const siteIds = sites.map((s) => s.id);
-  const inList = siteIds.map(escapeSiteId).join(',');
-
-  const AGG = `
-    SELECT
-      count() AS events,
-      uniqExact(anonymous_id) AS visitors,
-      uniqExact(session_id) AS sessions,
-      countIf(event_type = 'pageview') AS pageviews
-  `;
-  const WINDOW = `timestamp >= {from:DateTime64(3)} AND timestamp <= {to:DateTime64(3)} AND is_bot = 0`;
-
-  const [legacyRes, tenantRes] = await Promise.all([
-    clickhouseQuery(
-      `${AGG} FROM events_raw WHERE site_id IN (${inList}) AND ${WINDOW}`,
-      { from, to }
-    ),
-    clickhouseQuery(
-      `${AGG} FROM events_raw WHERE tenant_id = {tenantId:String} AND ${WINDOW}`,
-      { from, to, tenantId: args.tenantId }
-    ),
-  ]);
-
-  const legacy = legacyRes.data[0] || {};
-  const tenant = tenantRes.data[0] || {};
-
-  console.log('[consistency-check] legacy path:', legacy);
-  console.log('[consistency-check] tenant path:', tenant);
-
-  const diff = diffAggregates(legacy, tenant);
-  if (diff.ok) {
-    console.log('[consistency-check] OK — both paths agree.');
-    process.exit(0);
-  }
-  console.error('[consistency-check] MISMATCH:');
-  for (const m of diff.mismatches) {
-    console.error(
-      `  ${m.key}: legacy=${m.legacy} tenant=${m.tenant} (Δ=${m.absDelta}, rel=${(m.relDelta * 100).toFixed(2)}%)`
-    );
-  }
-  process.exit(3);
-}
-
-// Only run main() when invoked directly, never when imported by tests.
-const isMain = import.meta.url === `file://${process.argv[1]}`;
-if (isMain) {
-  main().catch((err) => {
-    console.error('[consistency-check] fatal:', err);
-    process.exit(10);
-  });
-}