@rune-kit/rune 2.2.0 → 2.2.2

package/extensions/analytics/skills/data-validation.md

@@ -0,0 +1,68 @@
+---
+name: "data-validation"
+pack: "@rune/analytics"
+description: "Data quality patterns — input validation, schema enforcement, data pipeline checks, anomaly detection, and data freshness monitoring."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# data-validation
+
+Data quality patterns — input validation, schema enforcement, data pipeline checks, anomaly detection, and data freshness monitoring.
+
+#### Workflow
+
+**Step 1 — Detect data flows**
+Use Grep to find data ingestion points: API endpoints that accept data, CSV/JSON import handlers, webhook receivers, database seed scripts, ETL pipelines. Map: source → transform → destination for each flow.
+
+**Step 2 — Audit data quality**
+Check for: missing input validation on data ingestion endpoints, no schema validation on imported files, no null/empty checks on required fields, no data type coercion (string "123" stored as string not number), no anomaly detection (sudden 10x spike in values), no data freshness check ("when was this data last updated?"), and no deduplication on event streams.
+
+**Step 3 — Emit validation patterns**
+Emit: schema validation with Zod for API inputs, data pipeline validation middleware, anomaly detection query, data freshness monitor, and deduplication patterns.
+
+#### Example
+
+```typescript
+import { z } from 'zod';
+
+// Data pipeline validation schema
+const MetricRowSchema = z.object({
+  timestamp: z.coerce.date(),
+  metric_name: z.string().min(1).max(100),
+  value: z.number().finite(),
+  source: z.enum(['api', 'webhook', 'import', 'manual']),
+  tags: z.record(z.string()).optional(),
+});
+
+// Batch validation with error collection (not fail-fast)
+function validateBatch(rows: unknown[]): { valid: z.infer<typeof MetricRowSchema>[]; errors: { row: number; error: string }[] } {
+  const valid: z.infer<typeof MetricRowSchema>[] = [];
+  const errors: { row: number; error: string }[] = [];
+  rows.forEach((row, i) => {
+    const result = MetricRowSchema.safeParse(row);
+    if (result.success) valid.push(result.data);
+    else errors.push({ row: i, error: result.error.issues.map(e => e.message).join('; ') });
+  });
+  return { valid, errors };
+}
+
+// Anomaly detection — flag values >3 standard deviations from rolling mean
+// SELECT metric_name, value, timestamp,
+//   AVG(value) OVER (PARTITION BY metric_name ORDER BY timestamp ROWS 30 PRECEDING) AS rolling_mean,
+//   STDDEV(value) OVER (PARTITION BY metric_name ORDER BY timestamp ROWS 30 PRECEDING) AS rolling_std
+// FROM metrics
+// HAVING ABS(value - rolling_mean) > 3 * rolling_std;
+
+// Data freshness monitor
+async function checkFreshness(tables: string[], maxStaleMinutes: number) {
+  const stale: string[] = [];
+  for (const table of tables) {
+    const result = await db.query(
+      `SELECT EXTRACT(EPOCH FROM NOW() - MAX(updated_at)) / 60 AS minutes_stale FROM ${table}`
+    );
+    if (result.rows[0]?.minutes_stale > maxStaleMinutes) stale.push(table);
+  }
+  return stale;
+}
+```

package/extensions/analytics/skills/funnel-analysis.md

@@ -0,0 +1,81 @@
+---
+name: "funnel-analysis"
+pack: "@rune/analytics"
+description: "Funnel analysis — conversion tracking, drop-off identification, cohort analysis, retention metrics, LTV calculation, attribution modeling."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# funnel-analysis
+
+Funnel analysis — conversion tracking, drop-off identification, cohort analysis, retention metrics, LTV calculation, attribution modeling.
+
+#### Workflow
+
+**Step 1 — Detect funnel tracking**
+Use Grep to find funnel-related code: `funnel`, `conversion`, `step`, `checkout.*step`, `onboarding.*step`, `cohort`, `retention`. Read event tracking calls to understand: which user journey steps are tracked, how step completion is determined, and where drop-off data is collected.
+
+**Step 2 — Audit funnel completeness**
+Check for: missing steps in the funnel (gap between "add to cart" and "payment complete" — no "checkout started"), step events not including a session or flow ID (can't link steps to same journey), no timestamp on steps (can't measure time between steps), no segmentation on funnel data (can't compare mobile vs desktop conversion), and no drop-off alerting.
+
+**Step 3 — Emit funnel patterns**
+Emit: typed funnel step tracker with flow ID, funnel aggregation query (SQL), drop-off rate calculator, cohort retention matrix, and simple LTV estimation.
+
+#### Example
+
+```typescript
+// Funnel step tracker with flow correlation
+interface FunnelStep {
+  funnelId: string;
+  flowId: string;      // ties steps to same user journey
+  step: string;
+  stepIndex: number;
+  userId: string;
+  timestamp: number;
+  metadata?: Record<string, string | number>;
+}
+
+const CHECKOUT_FUNNEL = ['cart_viewed', 'checkout_started', 'shipping_entered', 'payment_entered', 'order_completed'] as const;
+
+function trackFunnelStep(step: typeof CHECKOUT_FUNNEL[number], flowId: string, meta?: Record<string, string | number>) {
+  const event: FunnelStep = {
+    funnelId: 'checkout',
+    flowId,
+    step,
+    stepIndex: CHECKOUT_FUNNEL.indexOf(step),
+    userId: getCurrentUserId(),
+    timestamp: Date.now(),
+    metadata: meta,
+  };
+  analytics.track({ name: 'funnel_step', properties: event });
+}
+
+// SQL — funnel drop-off analysis (PostgreSQL)
+// SELECT step, COUNT(DISTINCT flow_id) as users,
+//   LAG(COUNT(DISTINCT flow_id)) OVER (ORDER BY step_index) as prev_users,
+//   ROUND(COUNT(DISTINCT flow_id)::numeric /
+//     LAG(COUNT(DISTINCT flow_id)) OVER (ORDER BY step_index) * 100, 1) as conversion_pct
+// FROM funnel_events
+// WHERE funnel_id = 'checkout' AND timestamp > NOW() - INTERVAL '30 days'
+// GROUP BY step, step_index ORDER BY step_index;
+
+// Cohort retention matrix
+async function cohortRetention(cohortField: string, periods: number) {
+  return db.execute(sql`
+    WITH cohorts AS (
+      SELECT user_id, DATE_TRUNC('week', MIN(created_at)) AS cohort_week
+      FROM events WHERE name = 'signup_completed'
+      GROUP BY user_id
+    ),
+    activity AS (
+      SELECT user_id, DATE_TRUNC('week', timestamp) AS active_week
+      FROM events GROUP BY user_id, DATE_TRUNC('week', timestamp)
+    )
+    SELECT c.cohort_week, EXTRACT(WEEK FROM a.active_week - c.cohort_week) AS week_number,
+      COUNT(DISTINCT a.user_id) AS active_users
+    FROM cohorts c JOIN activity a ON c.user_id = a.user_id
+    WHERE a.active_week >= c.cohort_week
+    GROUP BY c.cohort_week, week_number ORDER BY c.cohort_week, week_number
+  `);
+}
+```

package/extensions/analytics/skills/sql-patterns.md

@@ -0,0 +1,57 @@
+---
+name: "sql-patterns"
+pack: "@rune/analytics"
+description: "SQL query patterns for analytics — common aggregations, window functions, CTEs, performance optimization, and safe parameterized queries for analytics workloads."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# sql-patterns
+
+SQL query patterns for analytics — common aggregations, window functions, CTEs, performance optimization, and safe parameterized queries for analytics workloads.
+
+#### Workflow
+
+**Step 1 — Detect database setup**
+Use Grep to find database usage: `prisma`, `drizzle`, `knex`, `pg`, `mysql2`, `better-sqlite3`, `sql`, `SELECT`, `INSERT`. Identify: ORM vs raw SQL, database engine (PostgreSQL, MySQL, SQLite), migration tool, and query builder.
+
+**Step 2 — Audit query quality**
+Check for: string interpolation in SQL (injection risk), missing indexes on columns used in WHERE/JOIN/ORDER BY, N+1 queries in loops, SELECT * instead of specific columns, no pagination on large result sets, aggregations done client-side instead of database, and missing EXPLAIN ANALYZE on slow queries.
+
+**Step 3 — Emit SQL patterns**
+Emit patterns appropriate to the detected database engine.
+
+#### Example
+
+```sql
+-- Time-bucketed metrics (PostgreSQL)
+-- Use DATE_TRUNC for consistent time buckets
+SELECT
+  DATE_TRUNC('hour', created_at) AS bucket,
+  COUNT(*) AS total_events,
+  COUNT(DISTINCT user_id) AS unique_users,
+  PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY response_ms) AS p95_latency
+FROM events
+WHERE created_at > NOW() - INTERVAL '24 hours'
+GROUP BY bucket
+ORDER BY bucket;
+
+-- Running totals with window functions
+SELECT date, daily_revenue,
+  SUM(daily_revenue) OVER (ORDER BY date ROWS UNBOUNDED PRECEDING) AS cumulative_revenue,
+  AVG(daily_revenue) OVER (ORDER BY date ROWS 6 PRECEDING) AS rolling_7d_avg
+FROM daily_metrics;
+
+-- Efficient pagination (keyset, not OFFSET)
+-- BAD:  SELECT * FROM events ORDER BY id LIMIT 20 OFFSET 10000;
+-- GOOD: cursor-based
+SELECT * FROM events
+WHERE id > $1  -- last seen ID
+ORDER BY id
+LIMIT 20;
+
+-- Safe parameterized queries (NEVER string interpolation)
+-- BAD:  `SELECT * FROM users WHERE id = ${userId}`
+-- GOOD: prepared statement
+const result = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+```

package/extensions/analytics/skills/statistical-analysis.md

@@ -0,0 +1,79 @@
+---
+name: "statistical-analysis"
+pack: "@rune/analytics"
+description: "Statistical analysis patterns — significance testing, regression basics, distribution analysis, and correlation detection for product metrics."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# statistical-analysis
+
+Statistical analysis patterns — significance testing, regression basics, distribution analysis, and correlation detection for product metrics.
+
+#### Workflow
+
+**Step 1 — Identify analysis need**
+Determine what type of analysis is needed: comparing two groups (A/B test significance), finding relationships (correlation), predicting values (regression), understanding distribution (histogram, percentiles), or detecting trends (time series decomposition).
+
+**Step 2 — Select method**
+
+| Question | Method | When to use |
+|----------|--------|-------------|
+| "Is A different from B?" | Two-sample t-test or Chi-square | Comparing conversion rates, revenue per user |
+| "Are these correlated?" | Pearson/Spearman correlation | Feature usage vs retention, price vs conversion |
+| "What predicts Y?" | Linear/logistic regression | Churn prediction, revenue forecasting |
+| "What's the distribution?" | Histogram + percentiles | Response times, order values, session lengths |
+| "Is this trend real?" | Mann-Kendall or linear regression on time | Month-over-month growth, seasonal patterns |
+
+**Step 3 — Emit analysis patterns**
+
+#### Example
+
+```typescript
+// Chi-square significance test for A/B conversion rates
+function chiSquareTest(
+  controlConversions: number, controlTotal: number,
+  treatmentConversions: number, treatmentTotal: number
+): { chiSquare: number; pValue: number; significant: boolean } {
+  const controlRate = controlConversions / controlTotal;
+  const treatmentRate = treatmentConversions / treatmentTotal;
+  const pooledRate = (controlConversions + treatmentConversions) / (controlTotal + treatmentTotal);
+
+  const expected = [
+    [controlTotal * pooledRate, controlTotal * (1 - pooledRate)],
+    [treatmentTotal * pooledRate, treatmentTotal * (1 - pooledRate)],
+  ];
+  const observed = [
+    [controlConversions, controlTotal - controlConversions],
+    [treatmentConversions, treatmentTotal - treatmentConversions],
+  ];
+
+  let chiSq = 0;
+  for (let i = 0; i < 2; i++) {
+    for (let j = 0; j < 2; j++) {
+      chiSq += Math.pow(observed[i][j] - expected[i][j], 2) / expected[i][j];
+    }
+  }
+
+  // p-value approximation for 1 degree of freedom
+  const pValue = 1 - normalCDF(Math.sqrt(chiSq));
+  return { chiSquare: chiSq, pValue, significant: pValue < 0.05 };
+}
+
+// Percentile calculation (for response time analysis, order values, etc.)
+function percentiles(values: number[], points: number[] = [50, 75, 90, 95, 99]): Record<string, number> {
+  const sorted = [...values].sort((a, b) => a - b);
+  return Object.fromEntries(
+    points.map(p => [`p${p}`, sorted[Math.ceil((p / 100) * sorted.length) - 1]])
+  );
+}
+
+// SQL — Correlation between two metrics (PostgreSQL)
+// SELECT CORR(feature_usage_count, retention_days) AS correlation,
+//   CASE
+//     WHEN ABS(CORR(feature_usage_count, retention_days)) > 0.7 THEN 'strong'
+//     WHEN ABS(CORR(feature_usage_count, retention_days)) > 0.4 THEN 'moderate'
+//     ELSE 'weak'
+//   END AS strength
+// FROM user_metrics;
+```

package/extensions/analytics/skills/tracking-setup.md

@@ -0,0 +1,71 @@
+---
+name: "tracking-setup"
+pack: "@rune/analytics"
+description: "Analytics tracking — Google Analytics 4, Plausible, PostHog, Mixpanel. Event taxonomy design, consent management, server-side tracking, UTM handling."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# tracking-setup
+
+Analytics tracking — Google Analytics 4, Plausible, PostHog, Mixpanel. Event taxonomy design, consent management, server-side tracking, UTM handling.
+
+#### Workflow
+
+**Step 1 — Detect tracking setup**
+Use Grep to find analytics code: `gtag`, `posthog.capture`, `mixpanel.track`, `plausible`, `analytics.track`, `useAnalytics`. Read the tracking initialization and event calls to understand: analytics provider, event naming convention, consent flow, and client vs server-side tracking.
+
+**Step 2 — Audit tracking quality**
+Check for: inconsistent event naming (mix of `snake_case`, `camelCase`, `kebab-case`), missing consent management (GDPR violation), tracking scripts blocking page load (performance impact), no event taxonomy document (ad-hoc event names), UTM parameters not captured on landing, user identification happening before consent, and no server-side tracking fallback (ad blockers lose 30-40% of events).
+
+**Step 3 — Emit tracking patterns**
+Emit: typed event taxonomy with auto-complete, consent-aware analytics wrapper, server-side event proxy for ad-blocker resistance, UTM capture and persistence utility, and page view tracking with proper SPA handling.
+
+#### Example
+
+```typescript
+// Type-safe analytics wrapper with consent management
+type AnalyticsEvent =
+  | { name: 'page_view'; properties: { path: string; referrer: string } }
+  | { name: 'signup_started'; properties: { method: 'email' | 'google' | 'github' } }
+  | { name: 'feature_used'; properties: { feature: string; plan: string } }
+  | { name: 'checkout_started'; properties: { plan: string; billing: 'monthly' | 'annual' } }
+  | { name: 'checkout_completed'; properties: { plan: string; revenue: number; currency: string } };
+
+class Analytics {
+  private consent: 'granted' | 'denied' | 'pending' = 'pending';
+  private queue: AnalyticsEvent[] = [];
+
+  updateConsent(status: 'granted' | 'denied') {
+    this.consent = status;
+    if (status === 'granted') {
+      this.queue.forEach(e => this.send(e));
+      this.queue = [];
+    } else {
+      this.queue = [];
+    }
+  }
+
+  track<E extends AnalyticsEvent>(event: E) {
+    if (this.consent === 'denied') return;
+    if (this.consent === 'pending') { this.queue.push(event); return; }
+    this.send(event);
+  }
+
+  private send(event: AnalyticsEvent) {
+    // Client-side (may be blocked)
+    window.gtag?.('event', event.name, event.properties);
+    // Server-side fallback (ad-blocker resistant)
+    navigator.sendBeacon('/api/analytics', JSON.stringify(event));
+  }
+}
+
+// UTM capture — run on landing page
+function captureUtm() {
+  const params = new URLSearchParams(window.location.search);
+  const utmKeys = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content'];
+  const utm: Record<string, string> = {};
+  utmKeys.forEach(key => { if (params.has(key)) utm[key] = params.get(key)!; });
+  if (Object.keys(utm).length) sessionStorage.setItem('utm', JSON.stringify(utm));
+}
+```