@supalytics/cli 0.1.0

package/src/commands/stats.ts

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { query, formatNumber, formatPercent, formatDuration } from "../api";
+import { getDefaultSite } from "../config";
+import { logo, parsePeriod } from "../ui";
+
+export const statsCommand = new Command("stats")
+  .description("Overview stats: pageviews, visitors, bounce rate, revenue")
+  .argument("[period]", "Time period: today, yesterday, week, month, year, 7d, 30d, 90d, 12mo, all", "30d")
+  .option("-s, --site <site>", "Site to query")
+  .option("--start <date>", "Start date (YYYY-MM-DD)")
+  .option("--end <date>", "End date (YYYY-MM-DD)")
+  .option("-f, --filter <filters...>", "Filters in format 'field:operator:value'")
+  .option("--no-revenue", "Exclude revenue metrics")
+  .option("--json", "Output as JSON")
+  .action(async (period, options) => {
+    const site = options.site || (await getDefaultSite());
+
+    if (!site) {
+      console.error(chalk.red("Error: No site specified. Use --site or set a default with `supalytics login --site`"));
+      process.exit(1);
+    }
+
+    const dateRange = options.start && options.end
+      ? [options.start, options.end] as [string, string]
+      : parsePeriod(period);
+
+    const filters = options.filter
+      ? options.filter.map((f: string) => {
+          const parts = f.split(":");
+          if (parts.length < 3) {
+            console.error(chalk.red(`Invalid filter format: ${f}. Use 'field:operator:value'`));
+            process.exit(1);
+          }
+          const [field, operator, ...valueParts] = parts;
+          return [field, operator, valueParts.join(":")] as [string, string, string];
+        })
+      : undefined;
+
+    try {
+      const metrics = ["pageviews", "visitors", "bounce_rate", "avg_session_duration"];
+      if (options.revenue !== false) {
+        metrics.push("revenue", "conversions", "conversion_rate");
+      }
+
+      const response = await query(site, {
+        metrics,
+        filters,
+        date_range: dateRange,
+        include_revenue: options.revenue !== false,
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+      }
+
+      const m = response.data[0]?.metrics || {};
+      const [startDate, endDate] = response.meta.date_range;
+
+      // Logo
+      console.log(logo());
+
+      // Site and date range
+      console.log(chalk.bold(`  ${site}`));
+      console.log(chalk.dim(`  ${startDate} → ${endDate}`));
+      console.log();
+
+      // Main metrics - clean 2x2 grid
+      const col = 20;
+
+      const visitors = formatNumber(m.visitors || 0);
+      const pageviews = formatNumber(m.pageviews || 0);
+      const bounceRate = formatPercent(m.bounce_rate || 0);
+      const duration = formatDuration(m.avg_session_duration || 0);
+
+      console.log(`  ${"VISITORS".padEnd(col)}${"PAGEVIEWS"}`);
+      console.log(`  ${chalk.bold(visitors.padEnd(col))}${chalk.bold(pageviews)}`);
+      console.log();
+      console.log(`  ${"BOUNCE RATE".padEnd(col)}${"AVG DURATION"}`);
+      console.log(`  ${chalk.bold(bounceRate.padEnd(col))}${chalk.bold(duration)}`);
+
+      // Revenue section
+      if (options.revenue !== false && m.revenue !== undefined) {
+        const revenue = "$" + (m.revenue / 100).toFixed(2);
+        const conversions = String(m.conversions || 0);
+        const convRate = formatPercent(m.conversion_rate || 0);
+
+        console.log();
+        console.log(chalk.dim("  ────────────────────────────────────────"));
+        console.log();
+        console.log(`  ${"REVENUE".padEnd(col)}${"CONVERSIONS"}`);
+        console.log(`  ${chalk.green.bold(revenue.padEnd(col))}${chalk.bold(conversions)}`);
+        console.log();
+        console.log(`  CONVERSION RATE`);
+        console.log(`  ${chalk.bold(convRate)}`);
+      }
+
+      console.log();
+    } catch (error) {
+      console.error(chalk.red(`Error: ${(error as Error).message}`));
+      process.exit(1);
+    }
+  });

package/src/commands/trend.ts

@@ -0,0 +1,95 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { query, formatNumber } from "../api";
+import { getDefaultSite } from "../config";
+
+export const trendCommand = new Command("trend")
+  .description("Daily visitor trend")
+  .option("-s, --site <site>", "Site to query")
+  .option("-p, --period <period>", "Time period (7d, 30d, 90d, 12mo, all)", "30d")
+  .option("--start <date>", "Start date (YYYY-MM-DD)")
+  .option("--end <date>", "End date (YYYY-MM-DD)")
+  .option("-f, --filter <filters...>", "Filters in format 'field:operator:value' (e.g., 'is:country:US')")
+  .option("--no-revenue", "Exclude revenue metrics")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const site = options.site || (await getDefaultSite());
+
+    if (!site) {
+      console.error(chalk.red("Error: No site specified. Use --site or set a default with `supalytics login --site`"));
+      process.exit(1);
+    }
+
+    const dateRange = options.start && options.end
+      ? [options.start, options.end] as [string, string]
+      : options.period;
+
+    // Parse filters
+    const filters = options.filter
+      ? options.filter.map((f: string) => {
+          const parts = f.split(":");
+          if (parts.length < 3) {
+            console.error(chalk.red(`Invalid filter format: ${f}. Use 'field:operator:value'`));
+            process.exit(1);
+          }
+          const [field, operator, ...valueParts] = parts;
+          return [field, operator, valueParts.join(":")] as [string, string, string];
+        })
+      : undefined;
+
+    try {
+      const metrics = ["visitors"];
+      if (options.revenue !== false) {
+        metrics.push("revenue");
+      }
+
+      const response = await query(site, {
+        metrics,
+        dimensions: ["date"],
+        filters,
+        date_range: dateRange,
+        limit: 1000, // Get all days
+        include_revenue: options.revenue !== false,
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+      }
+
+      const [startDate, endDate] = response.meta.date_range;
+
+      console.log();
+      console.log(chalk.bold("Daily Trend"), chalk.dim(`${startDate} → ${endDate}`));
+      console.log();
+
+      if (response.data.length === 0) {
+        console.log(chalk.dim("  No data"));
+        return;
+      }
+
+      // Find max for sparkline scaling
+      const maxVisitors = Math.max(...response.data.map((r) => r.metrics.visitors || 0));
+
+      for (const result of response.data) {
+        const date = result.dimensions?.date || "";
+        const visitors = result.metrics.visitors || 0;
+
+        // Simple bar chart
+        const barLength = maxVisitors > 0 ? Math.round((visitors / maxVisitors) * 20) : 0;
+        const bar = "█".repeat(barLength) + chalk.dim("░".repeat(20 - barLength));
+
+        let line = `  ${date}  ${bar}  ${formatNumber(visitors).padStart(5)}`;
+
+        if (options.revenue !== false && result.metrics.revenue != null) {
+          line += `  ${chalk.green("$" + (result.metrics.revenue / 100).toFixed(0))}`;
+        }
+
+        console.log(line);
+      }
+      console.log();
+    } catch (error) {
+      console.error(chalk.red(`Error: ${(error as Error).message}`));
+      process.exit(1);
+    }
+  });

package/src/config.ts

@@ -0,0 +1,96 @@
+import { homedir } from "os";
+import { join } from "path";
+
+const CONFIG_DIR = join(homedir(), ".supalytics");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+interface SiteConfig {
+  apiKey: string;
+}
+
+interface Config {
+  // Map of domain -> API key
+  sites: Record<string, SiteConfig>;
+  // Default site domain
+  defaultSite?: string;
+}
+
+export async function getConfig(): Promise<Config> {
+  try {
+    const file = Bun.file(CONFIG_FILE);
+    if (await file.exists()) {
+      const config = await file.json();
+      // Migrate old config format if needed
+      if (config.apiKey && !config.sites) {
+        return {
+          sites: {},
+          defaultSite: config.defaultSite,
+        };
+      }
+      return { sites: {}, ...config };
+    }
+  } catch {
+    // Config doesn't exist or is invalid
+  }
+  return { sites: {} };
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  await Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export async function addSite(domain: string, apiKey: string): Promise<void> {
+  const config = await getConfig();
+  config.sites[domain] = { apiKey };
+  // Set as default if it's the first site
+  if (!config.defaultSite || Object.keys(config.sites).length === 1) {
+    config.defaultSite = domain;
+  }
+  await saveConfig(config);
+}
+
+export async function removeSite(domain: string): Promise<boolean> {
+  const config = await getConfig();
+  if (!config.sites[domain]) {
+    return false;
+  }
+  delete config.sites[domain];
+  // Update default if we removed the default site
+  if (config.defaultSite === domain) {
+    const remaining = Object.keys(config.sites);
+    config.defaultSite = remaining.length > 0 ? remaining[0] : undefined;
+  }
+  await saveConfig(config);
+  return true;
+}
+
+export async function setDefaultSite(domain: string): Promise<boolean> {
+  const config = await getConfig();
+  if (!config.sites[domain]) {
+    return false;
+  }
+  config.defaultSite = domain;
+  await saveConfig(config);
+  return true;
+}
+
+export async function getApiKeyForSite(domain: string): Promise<string | undefined> {
+  // Check env var first
+  if (process.env.SUPALYTICS_API_KEY) {
+    return process.env.SUPALYTICS_API_KEY;
+  }
+  const config = await getConfig();
+  return config.sites[domain]?.apiKey;
+}
+
+export async function getDefaultSite(): Promise<string | undefined> {
+  const config = await getConfig();
+  return config.defaultSite;
+}
+
+export async function getSites(): Promise<string[]> {
+  const config = await getConfig();
+  return Object.keys(config.sites);
+}
+
+export { CONFIG_DIR, CONFIG_FILE };

package/src/index.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+import { program } from "commander";
+import { loginCommand } from "./commands/login";
+import { logoutCommand } from "./commands/logout";
+import { sitesCommand, defaultCommand, removeCommand } from "./commands/sites";
+import { statsCommand } from "./commands/stats";
+import { pagesCommand } from "./commands/pages";
+import { referrersCommand } from "./commands/referrers";
+import { countriesCommand } from "./commands/countries";
+import { trendCommand } from "./commands/trend";
+import { queryCommand } from "./commands/query";
+import { eventsCommand } from "./commands/events";
+import { realtimeCommand } from "./commands/realtime";
+
+const description = `CLI for Supalytics web analytics.
+
+Multi-site Support:
+  Add sites:       supalytics login <api-key>       (auto-detects domain from API key)
+  List sites:      supalytics sites
+  Set default:     supalytics default <domain>
+  Remove site:     supalytics remove <domain>
+  Query other:     supalytics stats --site <domain>
+
+  API keys start with 'sly_' and can be created at https://supalytics.co/settings/api
+
+Date Ranges:
+  --period: 7d, 14d, 30d, 90d, 12mo, all (default: 30d)
+  --start/--end: Custom range in YYYY-MM-DD format
+
+Filters (-f, --filter):
+  Format: field:operator:value
+
+  Fields:
+    page, country, region, city, browser, os, device,
+    referrer, utm_source, utm_medium, utm_campaign, utm_content, utm_term,
+    event, event_property, exit_link
+
+  Operators:
+    is           Exact match (supports comma-separated: "country:is:US,UK")
+    is_not       Exclude exact match
+    contains     Substring match
+    not_contains Exclude substring
+    starts_with  Prefix match
+
+  Examples:
+    -f "country:is:US"
+    -f "page:contains:/blog"
+    -f "device:is:mobile"
+    -f "referrer:is:twitter.com"
+    -f "event:is:signup"
+    -f "event_property:is:plan:premium"
+
+Output:
+  --json       Raw JSON output (useful for piping to other tools or AI)
+  --no-revenue Exclude revenue metrics from output`;
+
+program
+  .name("supalytics")
+  .description(description)
+  .version("0.1.0");
+
+// Auth & site management commands
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(sitesCommand);
+program.addCommand(defaultCommand);
+program.addCommand(removeCommand);
+
+// Analytics commands
+program.addCommand(statsCommand);
+program.addCommand(pagesCommand);
+program.addCommand(referrersCommand);
+program.addCommand(countriesCommand);
+program.addCommand(trendCommand);
+program.addCommand(queryCommand);
+program.addCommand(eventsCommand);
+program.addCommand(realtimeCommand);
+
+program.parse();

package/src/ui.ts

@@ -0,0 +1,79 @@
+import chalk from "chalk";
+
+// Brand color
+const brand = chalk.hex("#FF2500");
+
+// Parse friendly period names into date ranges
+export function parsePeriod(period: string): string | [string, string] {
+  const today = new Date();
+  const yyyy = (d: Date) => d.toISOString().split("T")[0];
+
+  switch (period.toLowerCase()) {
+    case "today":
+      return [yyyy(today), yyyy(today)];
+    case "yesterday": {
+      const yesterday = new Date(today);
+      yesterday.setDate(yesterday.getDate() - 1);
+      return [yyyy(yesterday), yyyy(yesterday)];
+    }
+    case "week":
+    case "this week": {
+      const startOfWeek = new Date(today);
+      startOfWeek.setDate(today.getDate() - today.getDay());
+      return [yyyy(startOfWeek), yyyy(today)];
+    }
+    case "month":
+    case "this month": {
+      const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
+      return [yyyy(startOfMonth), yyyy(today)];
+    }
+    case "year":
+    case "this year": {
+      const startOfYear = new Date(today.getFullYear(), 0, 1);
+      return [yyyy(startOfYear), yyyy(today)];
+    }
+    case "last week": {
+      const endOfLastWeek = new Date(today);
+      endOfLastWeek.setDate(today.getDate() - today.getDay() - 1);
+      const startOfLastWeek = new Date(endOfLastWeek);
+      startOfLastWeek.setDate(endOfLastWeek.getDate() - 6);
+      return [yyyy(startOfLastWeek), yyyy(endOfLastWeek)];
+    }
+    case "last month": {
+      const startOfLastMonth = new Date(today.getFullYear(), today.getMonth() - 1, 1);
+      const endOfLastMonth = new Date(today.getFullYear(), today.getMonth(), 0);
+      return [yyyy(startOfLastMonth), yyyy(endOfLastMonth)];
+    }
+    default:
+      // Return as-is for 7d, 30d, etc.
+      return period;
+  }
+}
+
+// ASCII logo
+export function logo(): string {
+  return `
+  ${brand("░█▀▀░█░█░█▀█░█▀█░█░░░█░█░▀█▀░▀█▀░█▀▀░█▀▀")}
+  ${brand("░▀▀█░█░█░█▀▀░█▀█░█░░░░█░░░█░░░█░░█░░░▀▀█")}
+  ${brand("░▀▀▀░▀▀▀░▀░░░▀░▀░▀▀▀░░▀░░░▀░░▀▀▀░▀▀▀░▀▀▀")}
+`;
+}
+
+export function sparkBar(value: number, max: number, width: number = 15): string {
+  if (max === 0) return chalk.dim("░".repeat(width));
+  const filled = Math.round((value / max) * width);
+  const empty = width - filled;
+  return chalk.cyan("█".repeat(filled)) + chalk.dim("░".repeat(empty));
+}
+
+export function truncate(str: string, max: number): string {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+
+export function formatRevenue(cents: number): string {
+  if (cents >= 100000) {
+    return chalk.green("$" + (cents / 100000).toFixed(1) + "K");
+  }
+  return chalk.green("$" + (cents / 100).toFixed(0));
+}