ccclub 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,647 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+import { randomBytes } from "crypto";
+
+// ../shared/dist/constants.js
+var BLOCK_DURATION_HOURS = 5;
+var BLOCK_DURATION_MS = BLOCK_DURATION_HOURS * 60 * 60 * 1e3;
+var DEFAULT_API_URL = "https://ccclub.dev";
+var CLAUDE_PROJECTS_DIR = ".claude/projects";
+var CCCLUB_CONFIG_DIR = ".ccclub";
+var MODEL_PRICING = {
+  "claude-opus-4-6": { input: 15, output: 75, cacheCreation: 18.75, cacheRead: 1.5 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4, cacheCreation: 1, cacheRead: 0.08 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4, cacheCreation: 1, cacheRead: 0.08 }
+};
+function calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+  const pricing = MODEL_PRICING[model] || MODEL_PRICING["claude-sonnet-4-5-20250929"];
+  return (inputTokens * pricing.input + outputTokens * pricing.output + cacheCreationTokens * pricing.cacheCreation + cacheReadTokens * pricing.cacheRead) / 1e6;
+}
+
+// src/config.ts
+function getConfigDir() {
+  return join(homedir(), CCCLUB_CONFIG_DIR);
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getLastSyncPath() {
+  return join(getConfigDir(), "last-sync");
+}
+async function loadConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) return null;
+  const content = await readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+async function saveConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(getConfigPath(), JSON.stringify(config, null, 2));
+}
+function generateDeviceToken() {
+  return randomBytes(32).toString("hex");
+}
+function getApiUrl() {
+  return process.env.CCCLUB_API_URL || DEFAULT_API_URL;
+}
+async function requireConfig() {
+  const config = await loadConfig();
+  if (!config) {
+    throw new Error('Not initialized. Run "ccclub init" first.');
+  }
+  return config;
+}
+
+// src/heartbeat.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2 } from "fs";
+import { execFile } from "child_process";
+var PLIST_NAME = "dev.ccclub.sync";
+var LAUNCH_AGENTS_DIR = join2(homedir2(), "Library", "LaunchAgents");
+var PLIST_PATH = join2(LAUNCH_AGENTS_DIR, `${PLIST_NAME}.plist`);
+function getPlist() {
+  const logPath = join2(homedir2(), ".ccclub", "sync.log");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/usr/bin/env</string>
+    <string>npx</string>
+    <string>ccclub</string>
+    <string>sync</string>
+    <string>--silent</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>3600</integer>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+}
+async function installHeartbeat() {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  if (existsSync2(PLIST_PATH)) {
+    return true;
+  }
+  if (!existsSync2(LAUNCH_AGENTS_DIR)) {
+    await mkdir2(LAUNCH_AGENTS_DIR, { recursive: true });
+  }
+  await writeFile2(PLIST_PATH, getPlist());
+  try {
+    await new Promise((resolve, reject) => {
+      execFile("launchctl", ["load", PLIST_PATH], (err) => err ? reject(err) : resolve());
+    });
+  } catch {
+  }
+  return true;
+}
+
+// src/commands/sync.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/collector.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { glob } from "glob";
+async function collectUsageEntries() {
+  const projectsDir = join3(homedir3(), CLAUDE_PROJECTS_DIR);
+  const files = await glob("**/*.jsonl", { cwd: projectsDir, absolute: true });
+  if (files.length === 0) {
+    return [];
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await readFile2(file, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type !== "assistant" || !parsed.message?.usage) {
+        continue;
+      }
+      const usage = parsed.message.usage;
+      const requestId = parsed.requestId || "";
+      const sessionId = parsed.sessionId || "";
+      const dedupeKey = `${sessionId}:${requestId}`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      const inputTokens = usage.input_tokens || 0;
+      const outputTokens = usage.output_tokens || 0;
+      const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+      const cacheReadTokens = usage.cache_read_input_tokens || 0;
+      entries.push({
+        timestamp: parsed.timestamp,
+        sessionId,
+        requestId,
+        model: parsed.message.model || "unknown",
+        inputTokens,
+        outputTokens,
+        cacheCreationTokens,
+        cacheReadTokens,
+        totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
+        costUSD: parsed.costUSD || 0
+      });
+    }
+  }
+  entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  return entries;
+}
+
+// src/aggregator.ts
+function floorToHour(date) {
+  const floored = new Date(date);
+  floored.setUTCMinutes(0, 0, 0);
+  return floored;
+}
+function aggregateToBlocks(entries) {
+  if (entries.length === 0) return [];
+  const blocks = [];
+  let blockStart = floorToHour(new Date(entries[0].timestamp));
+  let blockEnd = new Date(blockStart.getTime() + BLOCK_DURATION_MS);
+  let currentBlock = [];
+  function flushBlock() {
+    if (currentBlock.length === 0) return;
+    const models = /* @__PURE__ */ new Set();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationTokens = 0;
+    let cacheReadTokens = 0;
+    let totalTokens = 0;
+    let costUSD = 0;
+    for (const entry of currentBlock) {
+      inputTokens += entry.inputTokens;
+      outputTokens += entry.outputTokens;
+      cacheCreationTokens += entry.cacheCreationTokens;
+      cacheReadTokens += entry.cacheReadTokens;
+      totalTokens += entry.totalTokens;
+      models.add(entry.model);
+      if (entry.costUSD > 0) {
+        costUSD += entry.costUSD;
+      } else {
+        costUSD += calculateCost(
+          entry.model,
+          entry.inputTokens,
+          entry.outputTokens,
+          entry.cacheCreationTokens,
+          entry.cacheReadTokens
+        );
+      }
+    }
+    blocks.push({
+      blockStart: blockStart.toISOString(),
+      blockEnd: blockEnd.toISOString(),
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      totalTokens,
+      costUSD: Math.round(costUSD * 1e4) / 1e4,
+      models: Array.from(models),
+      entryCount: currentBlock.length
+    });
+  }
+  for (const entry of entries) {
+    const entryTime = new Date(entry.timestamp);
+    while (entryTime >= blockEnd) {
+      flushBlock();
+      currentBlock = [];
+      blockStart = new Date(blockEnd);
+      blockEnd = new Date(blockStart.getTime() + BLOCK_DURATION_MS);
+    }
+    currentBlock.push(entry);
+  }
+  flushBlock();
+  return blocks;
+}
+
+// src/commands/sync.ts
+async function syncCommand(options) {
+  await doSync(false, options.silent);
+}
+async function doSync(firstSync = false, silent = false) {
+  const config = await requireConfig();
+  const log = silent ? () => {
+  } : console.log;
+  const spinner = silent ? null : ora("Collecting usage data...").start();
+  try {
+    const entries = await collectUsageEntries();
+    if (spinner) spinner.text = `Found ${entries.length} entries`;
+    if (entries.length === 0) {
+      if (spinner) spinner.warn("No usage data found in ~/.claude/projects/");
+      return;
+    }
+    const allBlocks = aggregateToBlocks(entries);
+    const lastSyncPath = getLastSyncPath();
+    let lastSync = null;
+    if (existsSync3(lastSyncPath)) {
+      lastSync = (await readFile3(lastSyncPath, "utf-8")).trim() || null;
+    }
+    let blocksToSync;
+    if (lastSync && !firstSync) {
+      const lastSyncTime = new Date(lastSync).getTime();
+      blocksToSync = allBlocks.filter((b) => new Date(b.blockStart).getTime() >= lastSyncTime);
+    } else {
+      blocksToSync = allBlocks;
+    }
+    if (blocksToSync.length === 0) {
+      if (spinner) spinner.succeed("Already up to date");
+      return;
+    }
+    if (spinner) spinner.text = `Uploading ${blocksToSync.length} blocks...`;
+    const res = await fetch(`${config.apiUrl}/api/sync`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify({ blocks: blocksToSync })
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      if (spinner) spinner.fail(`Sync failed: ${err.error}`);
+      return;
+    }
+    const data = await res.json();
+    const latest = blocksToSync[blocksToSync.length - 1];
+    await writeFile3(lastSyncPath, latest.blockStart);
+    const totalTokens = blocksToSync.reduce((s, b) => s + b.totalTokens, 0);
+    const totalCost = blocksToSync.reduce((s, b) => s + b.costUSD, 0);
+    if (spinner) {
+      spinner.succeed(`Synced ${data.synced} blocks`);
+      log(chalk.dim(`  Tokens: ${totalTokens.toLocaleString()}  Cost: $${totalCost.toFixed(4)}`));
+    }
+  } catch (err) {
+    if (spinner) spinner.fail(`Sync error: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  const existing = await loadConfig();
+  if (existing) {
+    console.log(chalk2.yellow("Already initialized!"));
+    console.log(`  User: ${existing.displayName}`);
+    console.log(`  Groups: ${existing.groups.join(", ") || "(none)"}`);
+    console.log(chalk2.dim('\n  Run "ccclub rank" to see rankings'));
+    return;
+  }
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const displayName = await rl.question(chalk2.bold("Your display name: "));
+    if (!displayName.trim()) {
+      console.error(chalk2.red("Name cannot be empty"));
+      return;
+    }
+    const spinner = ora2("Setting up...").start();
+    const token = generateDeviceToken();
+    const apiUrl = getApiUrl();
+    const res = await fetch(`${apiUrl}/api/init`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, displayName: displayName.trim() })
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      spinner.fail(`Setup failed: ${err.error}`);
+      return;
+    }
+    const data = await res.json();
+    await saveConfig({
+      apiUrl,
+      token,
+      userId: data.userId,
+      displayName: displayName.trim(),
+      groups: [data.groupCode]
+    });
+    const heartbeatOk = await installHeartbeat();
+    spinner.succeed("CCClub initialized!");
+    console.log("");
+    console.log(chalk2.bold("  Your invite code:"));
+    console.log(chalk2.cyan.bold(`
+    ${data.groupCode}
+`));
+    console.log(chalk2.dim("  Share with friends: ") + chalk2.white(`npx ccclub join ${data.groupCode}`));
+    if (heartbeatOk) {
+      console.log(chalk2.dim("  Heartbeat: installed (syncs every hour)"));
+    } else {
+      console.log(chalk2.dim('  Tip: run "ccclub sync" periodically to update data'));
+    }
+    console.log("");
+    await doSync(true);
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/join.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function joinCommand(inviteCode) {
+  let config = await loadConfig();
+  const apiUrl = getApiUrl();
+  let token;
+  let displayName;
+  if (config) {
+    token = config.token;
+    displayName = config.displayName;
+  } else {
+    const rl = createInterface2({ input: stdin2, output: stdout2 });
+    try {
+      displayName = await rl.question(chalk3.bold("Your display name: "));
+      if (!displayName.trim()) {
+        console.error(chalk3.red("Name cannot be empty"));
+        return;
+      }
+      displayName = displayName.trim();
+    } finally {
+      rl.close();
+    }
+    token = generateDeviceToken();
+  }
+  const spinner = ora3("Joining group...").start();
+  const res = await fetch(`${apiUrl}/api/join`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token, displayName, inviteCode })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    spinner.fail(`Join failed: ${err.error}`);
+    return;
+  }
+  const data = await res.json();
+  if (config) {
+    if (!config.groups.includes(data.groupCode)) {
+      config.groups.push(data.groupCode);
+    }
+    await saveConfig(config);
+  } else {
+    await saveConfig({
+      apiUrl,
+      token,
+      userId: data.userId,
+      displayName,
+      groups: [data.groupCode]
+    });
+    await installHeartbeat();
+  }
+  spinner.succeed(`Joined "${data.groupName}"!`);
+  console.log(chalk3.dim(`
+  Dashboard: ${apiUrl}/g/${data.groupCode}`));
+  console.log(chalk3.dim('  Run "ccclub rank" to see rankings'));
+  if (!config) {
+    console.log("");
+    await doSync(true);
+  }
+}
+
+// src/commands/rank.ts
+import chalk4 from "chalk";
+import Table from "cli-table3";
+import ora4 from "ora";
+async function rankCommand(options) {
+  const config = await requireConfig();
+  const spinner = ora4("Fetching rankings...").start();
+  const isGlobal = options.global === true;
+  const groupCode = isGlobal ? "global" : options.group || config.groups[0];
+  if (!groupCode) {
+    spinner.fail("No group found. Run 'ccclub init' or 'ccclub join <code>' first.");
+    return;
+  }
+  const period = options.period || "daily";
+  const url = `${config.apiUrl}/api/rank/${groupCode}?period=${period}`;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      spinner.fail("Failed to fetch rankings");
+      return;
+    }
+    const data = await res.json();
+    spinner.stop();
+    if (data.rankings.length === 0) {
+      console.log(chalk4.yellow("\n  No rankings data for this period"));
+      console.log(chalk4.dim('  Run "ccclub sync" to upload your usage data'));
+      return;
+    }
+    console.log(chalk4.bold(`
+  ${data.group.name}`));
+    console.log(chalk4.dim(`  ${period.toUpperCase()} \xB7 ${data.start.slice(0, 10)} \u2192 ${data.end.slice(0, 10)} \xB7 ${data.group.memberCount} members
+`));
+    const table = new Table({
+      head: ["#", "Name", "Tokens", "Cost", "Calls"].map((h) => chalk4.cyan(h)),
+      style: { head: [], border: [] },
+      colWidths: [5, 20, 16, 12, 8]
+    });
+    for (const entry of data.rankings) {
+      const isMe = entry.userId === config.userId;
+      const marker = isMe ? chalk4.green("\u2192") : " ";
+      const name = isMe ? chalk4.green.bold(entry.displayName) : entry.displayName;
+      const rankColor = entry.rank <= 3 ? chalk4.yellow : chalk4.white;
+      table.push([
+        `${marker}${rankColor(String(entry.rank))}`,
+        name,
+        entry.totalTokens.toLocaleString(),
+        `$${entry.costUSD.toFixed(2)}`,
+        String(entry.entryCount)
+      ]);
+    }
+    console.log(table.toString());
+    console.log(chalk4.dim(`
+  Dashboard: ${config.apiUrl}/g/${groupCode}`));
+  } catch (err) {
+    spinner.fail(`Error: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/commands/profile.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+async function profileCommand(options) {
+  const config = await requireConfig();
+  const hasUpdate = options.name !== void 0 || options.avatar !== void 0 || options.public || options.private;
+  if (!hasUpdate) {
+    const spinner2 = ora5("Fetching profile...").start();
+    try {
+      const res = await fetch(`${config.apiUrl}/api/profile`, {
+        headers: { Authorization: `Bearer ${config.token}` }
+      });
+      if (!res.ok) {
+        spinner2.fail("Failed to fetch profile");
+        return;
+      }
+      const profile = await res.json();
+      spinner2.stop();
+      console.log(chalk5.bold("\n  Your Profile"));
+      console.log(`  Name:       ${profile.displayName}`);
+      console.log(`  Avatar:     ${profile.avatar || chalk5.dim("(default)")}`);
+      console.log(`  Visibility: ${profile.visibility === "public" ? chalk5.green("public") : chalk5.dim("private")}`);
+      console.log();
+    } catch (err) {
+      spinner2.fail(`Error: ${err instanceof Error ? err.message : err}`);
+    }
+    return;
+  }
+  const body = {};
+  if (options.name !== void 0) body.displayName = options.name;
+  if (options.avatar !== void 0) body.avatar = options.avatar;
+  if (options.public) body.visibility = "public";
+  if (options.private) body.visibility = "private";
+  const spinner = ora5("Updating profile...").start();
+  try {
+    const res = await fetch(`${config.apiUrl}/api/profile`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      spinner.fail("Failed to update profile");
+      return;
+    }
+    const profile = await res.json();
+    spinner.stop();
+    if (body.displayName && body.displayName !== config.displayName) {
+      config.displayName = body.displayName;
+      await saveConfig(config);
+    }
+    console.log(chalk5.green("\n  Profile updated!"));
+    console.log(`  Name:       ${profile.displayName}`);
+    console.log(`  Avatar:     ${profile.avatar || chalk5.dim("(default)")}`);
+    console.log(`  Visibility: ${profile.visibility === "public" ? chalk5.green("public") : chalk5.dim("private")}`);
+    console.log();
+  } catch (err) {
+    spinner.fail(`Error: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/commands/show-data.ts
+import chalk6 from "chalk";
+async function showDataCommand() {
+  console.log(chalk6.bold("\n  What CCClub uploads:\n"));
+  console.log(chalk6.dim("  Only aggregated 5-hour block summaries. No conversation content,"));
+  console.log(chalk6.dim("  no file paths, no project names, no session details.\n"));
+  const entries = await collectUsageEntries();
+  const blocks = aggregateToBlocks(entries);
+  if (blocks.length === 0) {
+    console.log(chalk6.yellow("  No usage data found in ~/.claude/projects/"));
+    return;
+  }
+  console.log(chalk6.dim(`  Total entries found: ${entries.length}`));
+  console.log(chalk6.dim(`  Aggregated into: ${blocks.length} blocks
+`));
+  const recent = blocks.slice(-5);
+  console.log(chalk6.bold("  Last 5 blocks (this is exactly what gets uploaded):\n"));
+  for (const block of recent) {
+    console.log(chalk6.cyan(`  ${block.blockStart.slice(0, 16)} \u2192 ${block.blockEnd.slice(11, 16)}`));
+    console.log(chalk6.dim(`    tokens: ${block.totalTokens.toLocaleString()}  cost: $${block.costUSD.toFixed(4)}  calls: ${block.entryCount}  models: ${block.models.join(", ")}`));
+  }
+  const totalTokens = blocks.reduce((s, b) => s + b.totalTokens, 0);
+  const totalCost = blocks.reduce((s, b) => s + b.costUSD, 0);
+  console.log(chalk6.bold(`
+  All-time total: ${totalTokens.toLocaleString()} tokens \xB7 $${totalCost.toFixed(2)}`));
+}
+
+// src/commands/group.ts
+import { createInterface as createInterface3 } from "readline/promises";
+import { stdin as stdin3, stdout as stdout3 } from "process";
+import chalk7 from "chalk";
+import ora6 from "ora";
+async function createGroupCommand() {
+  const config = await requireConfig();
+  const rl = createInterface3({ input: stdin3, output: stdout3 });
+  try {
+    const name = await rl.question(chalk7.bold("Group name: "));
+    if (!name.trim()) {
+      console.error(chalk7.red("Name cannot be empty"));
+      return;
+    }
+    const spinner = ora6("Creating group...").start();
+    const res = await fetch(`${config.apiUrl}/api/group/create`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify({ name: name.trim() })
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      spinner.fail(`Failed: ${err.error}`);
+      return;
+    }
+    const data = await res.json();
+    if (!config.groups.includes(data.groupCode)) {
+      config.groups.push(data.groupCode);
+      await saveConfig(config);
+    }
+    spinner.succeed(`Created "${data.groupName}"`);
+    console.log(chalk7.bold(`
+  Invite code: `) + chalk7.cyan.bold(data.groupCode));
+    console.log(chalk7.dim(`  Share: npx ccclub join ${data.groupCode}`));
+    console.log(chalk7.dim(`  Dashboard: ${config.apiUrl}/g/${data.groupCode}`));
+  } finally {
+    rl.close();
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("ccclub").description("CCClub - Compare Claude Code usage with friends").version("0.1.0");
+program.command("init").description("Initialize CCClub (one-time setup)").action(initCommand);
+program.command("join").description("Join a friend's group").argument("<invite-code>", "6-character invite code").action(joinCommand);
+program.command("sync").description("Sync local usage data to server").option("-s, --silent", "No output (used by heartbeat)").action(syncCommand);
+program.command("rank").description("Show leaderboard rankings").option("-p, --period <period>", "daily, weekly, monthly, all-time", "daily").option("-g, --group <code>", "Group invite code").option("--global", "Show global public ranking").action(rankCommand);
+program.command("profile").description("View or update your profile").option("-n, --name <name>", "Set display name").option("--avatar <url>", "Set avatar URL (empty string to reset)").option("--public", "Set profile visibility to public").option("--private", "Set profile visibility to private").action(profileCommand);
+program.command("create").description("Create a new group").action(createGroupCommand);
+program.command("show-data").description("Show exactly what data CCClub uploads (privacy audit)").action(showDataCommand);
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ccclub",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "See how much Claude Code you and your friends are using",
+  "bin": {
+    "ccclub": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "glob": "^11.0.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@ccclub/shared": "workspace:*",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "usage",
+    "ranking",
+    "leaderboard"
+  ],
+  "license": "MIT"
+}