ccgather 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/lib/config.ts
+function getConfig() {
+  if (!configInstance) {
+    configInstance = new import_conf.default({
+      projectName: "ccgather",
+      defaults
+    });
+  }
+  return configInstance;
+}
+function resetConfig() {
+  const config = getConfig();
+  config.clear();
+  Object.entries(defaults).forEach(([key, value]) => {
+    config.set(key, value);
+  });
+}
+function isAuthenticated() {
+  const config = getConfig();
+  return !!config.get("apiToken");
+}
+function getApiUrl() {
+  const config = getConfig();
+  return config.get("apiUrl") || defaults.apiUrl;
+}
+var import_conf, defaults, configInstance;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    import_conf = __toESM(require("conf"));
+    defaults = {
+      apiUrl: "https://ccgather.dev/api",
+      autoSync: false,
+      syncInterval: 60,
+      verbose: false
+    };
+    configInstance = null;
+  }
+});
+
+// src/commands/reset.ts
+var reset_exports = {};
+__export(reset_exports, {
+  reset: () => reset
+});
+function getClaudeSettingsDir() {
+  return path2.join(os2.homedir(), ".claude");
+}
+function removeStopHook() {
+  const claudeDir = getClaudeSettingsDir();
+  const settingsPath = path2.join(claudeDir, "settings.json");
+  if (!fs2.existsSync(settingsPath)) {
+    return { success: true, message: "No settings file found" };
+  }
+  try {
+    const content = fs2.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    if (settings.hooks && typeof settings.hooks === "object") {
+      const hooks = settings.hooks;
+      if (hooks.Stop && Array.isArray(hooks.Stop)) {
+        hooks.Stop = hooks.Stop.filter((hook) => {
+          if (typeof hook === "object" && hook !== null) {
+            const h = hook;
+            return typeof h.command !== "string" || !h.command.includes("ccgather");
+          }
+          return true;
+        });
+        if (hooks.Stop.length === 0) {
+          delete hooks.Stop;
+        }
+      }
+    }
+    fs2.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    return { success: true, message: "Hook removed" };
+  } catch (err) {
+    return {
+      success: false,
+      message: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function removeSyncScript() {
+  const claudeDir = getClaudeSettingsDir();
+  const scriptPath = path2.join(claudeDir, "ccgather-sync.js");
+  if (fs2.existsSync(scriptPath)) {
+    fs2.unlinkSync(scriptPath);
+  }
+}
+async function reset() {
+  const config = getConfig();
+  console.log(import_chalk3.default.bold("\n\u{1F504} CCgather Reset\n"));
+  if (!config.get("apiToken")) {
+    console.log(import_chalk3.default.yellow("CCgather is not configured."));
+    return;
+  }
+  const { confirmReset } = await import_inquirer.default.prompt([
+    {
+      type: "confirm",
+      name: "confirmReset",
+      message: "This will remove the CCgather hook and local configuration. Continue?",
+      default: false
+    }
+  ]);
+  if (!confirmReset) {
+    console.log(import_chalk3.default.gray("Reset cancelled."));
+    return;
+  }
+  const hookSpinner = (0, import_ora3.default)("Removing Claude Code hook...").start();
+  const hookResult = removeStopHook();
+  if (hookResult.success) {
+    hookSpinner.succeed(import_chalk3.default.green("Hook removed"));
+  } else {
+    hookSpinner.warn(import_chalk3.default.yellow(`Could not remove hook: ${hookResult.message}`));
+  }
+  const scriptSpinner = (0, import_ora3.default)("Removing sync script...").start();
+  try {
+    removeSyncScript();
+    scriptSpinner.succeed(import_chalk3.default.green("Sync script removed"));
+  } catch {
+    scriptSpinner.warn(import_chalk3.default.yellow("Could not remove sync script"));
+  }
+  const { deleteAccount } = await import_inquirer.default.prompt([
+    {
+      type: "confirm",
+      name: "deleteAccount",
+      message: import_chalk3.default.red("Do you also want to delete your account from the leaderboard? (This cannot be undone)"),
+      default: false
+    }
+  ]);
+  if (deleteAccount) {
+    console.log(import_chalk3.default.yellow("\nAccount deletion is not yet implemented."));
+    console.log(import_chalk3.default.gray("Please contact support to delete your account."));
+  }
+  const configSpinner = (0, import_ora3.default)("Resetting local configuration...").start();
+  resetConfig();
+  configSpinner.succeed(import_chalk3.default.green("Local configuration reset"));
+  console.log();
+  console.log(import_chalk3.default.green.bold("\u2705 Reset complete!"));
+  console.log();
+  console.log(import_chalk3.default.gray("Your usage will no longer be tracked."));
+  console.log(import_chalk3.default.gray("Run `npx ccg` to set up again."));
+  console.log();
+}
+var import_chalk3, import_ora3, fs2, path2, os2, import_inquirer;
+var init_reset = __esm({
+  "src/commands/reset.ts"() {
+    "use strict";
+    import_chalk3 = __toESM(require("chalk"));
+    import_ora3 = __toESM(require("ora"));
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    os2 = __toESM(require("os"));
+    import_inquirer = __toESM(require("inquirer"));
+    init_config();
+  }
+});
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/submit.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+init_config();
+function findCcJson() {
+  const possiblePaths = [
+    path.join(process.cwd(), "cc.json"),
+    path.join(os.homedir(), "cc.json"),
+    path.join(os.homedir(), ".claude", "cc.json")
+  ];
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return p;
+    }
+  }
+  return null;
+}
+function parseCcJson(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return {
+      totalTokens: data.totalTokens || data.total_tokens || 0,
+      totalCost: data.totalCost || data.total_cost || data.costUSD || 0,
+      inputTokens: data.inputTokens || data.input_tokens || 0,
+      outputTokens: data.outputTokens || data.output_tokens || 0,
+      cacheReadTokens: data.cacheReadTokens || data.cache_read_tokens || 0,
+      cacheWriteTokens: data.cacheWriteTokens || data.cache_write_tokens || 0,
+      daysTracked: data.daysTracked || data.days_tracked || calculateDaysTracked(data)
+    };
+  } catch {
+    return null;
+  }
+}
+function calculateDaysTracked(data) {
+  if (data.dailyStats && Array.isArray(data.dailyStats)) {
+    return data.dailyStats.length;
+  }
+  if (data.daily && typeof data.daily === "object") {
+    return Object.keys(data.daily).length;
+  }
+  return 1;
+}
+function parseUsageFromJsonl() {
+  const projectsDir = path.join(os.homedir(), ".claude", "projects");
+  if (!fs.existsSync(projectsDir)) {
+    return null;
+  }
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  const dates = /* @__PURE__ */ new Set();
+  function findJsonlFiles(dir) {
+    const files = [];
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          files.push(...findJsonlFiles(fullPath));
+        } else if (entry.name.endsWith(".jsonl")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+    return files;
+  }
+  const jsonlFiles = findJsonlFiles(projectsDir);
+  for (const filePath of jsonlFiles) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const lines = content.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "assistant" && event.message?.usage) {
+            const usage = event.message.usage;
+            totalInputTokens += usage.input_tokens || 0;
+            totalOutputTokens += usage.output_tokens || 0;
+            totalCacheRead += usage.cache_read_input_tokens || 0;
+            totalCacheWrite += usage.cache_creation_input_tokens || 0;
+            if (event.timestamp) {
+              const date = new Date(event.timestamp).toISOString().split("T")[0];
+              dates.add(date);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const totalTokens = totalInputTokens + totalOutputTokens;
+  if (totalTokens === 0) {
+    return null;
+  }
+  const costPerMillion = 3;
+  const totalCost = totalTokens / 1e6 * costPerMillion;
+  return {
+    totalTokens,
+    totalCost: Math.round(totalCost * 100) / 100,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    cacheReadTokens: totalCacheRead,
+    cacheWriteTokens: totalCacheWrite,
+    daysTracked: dates.size || 1
+  };
+}
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+async function detectGitHubUsername() {
+  try {
+    const { execSync } = await import("child_process");
+    try {
+      const username = execSync("git config --get user.name", { encoding: "utf-8" }).trim();
+      if (username) return username;
+    } catch {
+    }
+    try {
+      const remote = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+      const match = remote.match(/github\.com[:/]([^/]+)/);
+      if (match) return match[1];
+    } catch {
+    }
+  } catch {
+  }
+  return null;
+}
+async function submitToServer(username, data) {
+  const apiUrl = getApiUrl();
+  try {
+    const response = await fetch(`${apiUrl}/cli/submit`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        username,
+        totalTokens: data.totalTokens,
+        totalSpent: data.totalCost,
+        inputTokens: data.inputTokens,
+        outputTokens: data.outputTokens,
+        cacheReadTokens: data.cacheReadTokens,
+        cacheWriteTokens: data.cacheWriteTokens,
+        daysTracked: data.daysTracked,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return { success: false, error: errorData.error || `HTTP ${response.status}` };
+    }
+    const result = await response.json();
+    return { success: true, profileUrl: result.profileUrl };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
+  }
+}
+async function submit(options) {
+  console.log(import_chalk.default.bold("\n\u{1F680} CCgather Submission Tool v1.0.0\n"));
+  const spinner = (0, import_ora.default)("Detecting GitHub username...").start();
+  let username = await detectGitHubUsername();
+  spinner.stop();
+  if (username) {
+    console.log(import_chalk.default.gray(`Detected GitHub username from repository: ${import_chalk.default.white(username)}`));
+  }
+  const inquirer2 = await import("inquirer");
+  const { confirmedUsername } = await inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "confirmedUsername",
+      message: "GitHub username:",
+      default: username || "",
+      validate: (input) => input.trim().length > 0 || "Username is required"
+    }
+  ]);
+  username = confirmedUsername.trim();
+  const ccJsonPath = findCcJson();
+  let usageData = null;
+  let dataSource = "";
+  if (ccJsonPath) {
+    const { useCcJson } = await inquirer2.default.prompt([
+      {
+        type: "confirm",
+        name: "useCcJson",
+        message: `Found existing cc.json. Use this file?`,
+        default: true
+      }
+    ]);
+    if (useCcJson) {
+      usageData = parseCcJson(ccJsonPath);
+      dataSource = "cc.json";
+    }
+  }
+  if (!usageData) {
+    const parseSpinner = (0, import_ora.default)("Scanning Claude Code usage data...").start();
+    usageData = parseUsageFromJsonl();
+    parseSpinner.stop();
+    dataSource = "Claude Code logs";
+  }
+  if (!usageData) {
+    console.log(import_chalk.default.red("\n\u274C No usage data found."));
+    console.log(import_chalk.default.gray("Make sure you have used Claude Code or have a cc.json file."));
+    process.exit(1);
+  }
+  console.log(import_chalk.default.green(`\u2713 Using ${dataSource}
+`));
+  console.log(import_chalk.default.bold("Summary:"));
+  console.log(import_chalk.default.gray(`  Total Cost: ${import_chalk.default.green("$" + formatNumber(Math.round(usageData.totalCost)))}`));
+  console.log(import_chalk.default.gray(`  Total Tokens: ${import_chalk.default.cyan(formatNumber(usageData.totalTokens))}`));
+  console.log(import_chalk.default.gray(`  Days Tracked: ${import_chalk.default.yellow(usageData.daysTracked.toString())}`));
+  console.log();
+  if (!options.yes) {
+    const { confirmSubmit } = await inquirer2.default.prompt([
+      {
+        type: "confirm",
+        name: "confirmSubmit",
+        message: "Submit to CCgather leaderboard?",
+        default: true
+      }
+    ]);
+    if (!confirmSubmit) {
+      console.log(import_chalk.default.gray("\nSubmission cancelled."));
+      return;
+    }
+  }
+  const submitSpinner = (0, import_ora.default)("Submitting to CCgather...").start();
+  const result = await submitToServer(username, usageData);
+  if (result.success) {
+    submitSpinner.succeed(import_chalk.default.green("Successfully submitted to CCgather!"));
+    console.log();
+    console.log(import_chalk.default.gray(`View your profile at: ${import_chalk.default.cyan(result.profileUrl || `https://ccgather.dev/u/${username}`)}`));
+    console.log();
+    console.log(import_chalk.default.bold("Done! \u{1F389}"));
+  } else {
+    submitSpinner.fail(import_chalk.default.red("Failed to submit"));
+    console.log(import_chalk.default.red(result.error || "Unknown error"));
+    process.exit(1);
+  }
+  console.log();
+}
+
+// src/commands/status.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+init_config();
+
+// src/lib/api.ts
+init_config();
+async function fetchApi(endpoint, options = {}) {
+  const config = getConfig();
+  const apiToken = config.get("apiToken");
+  const apiUrl = getApiUrl();
+  if (!apiToken) {
+    return { success: false, error: "Not authenticated. Run: npx ccgather auth" };
+  }
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`,
+        ...options.headers
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return { success: false, error: data.error || `HTTP ${response.status}` };
+    }
+    return { success: true, data };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+async function getStatus() {
+  return fetchApi("/cli/status");
+}
+
+// src/commands/status.ts
+function formatNumber2(num) {
+  if (num >= 1e9) return `${(num / 1e9).toFixed(2)}B`;
+  if (num >= 1e6) return `${(num / 1e6).toFixed(2)}M`;
+  if (num >= 1e3) return `${(num / 1e3).toFixed(2)}K`;
+  return num.toString();
+}
+function getTierEmoji(tier) {
+  const emojis = {
+    free: "\u{1F193}",
+    pro: "\u2B50",
+    team: "\u{1F465}",
+    enterprise: "\u{1F3E2}"
+  };
+  return emojis[tier.toLowerCase()] || "\u{1F3AF}";
+}
+function getRankMedal(rank) {
+  if (rank === 1) return "\u{1F947}";
+  if (rank === 2) return "\u{1F948}";
+  if (rank === 3) return "\u{1F949}";
+  if (rank <= 10) return "\u{1F3C5}";
+  if (rank <= 100) return "\u{1F396}\uFE0F";
+  return "\u{1F4CA}";
+}
+async function status(options) {
+  if (!isAuthenticated()) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not authenticated" }));
+    } else {
+      console.log(import_chalk2.default.red("\nNot authenticated."));
+      console.log(import_chalk2.default.gray("Run: npx ccgather auth\n"));
+    }
+    process.exit(1);
+  }
+  const spinner = options.json ? null : (0, import_ora2.default)("Fetching your stats...").start();
+  const result = await getStatus();
+  if (!result.success) {
+    if (spinner) spinner.fail(import_chalk2.default.red("Failed to fetch status"));
+    if (options.json) {
+      console.log(JSON.stringify({ error: result.error }));
+    } else {
+      console.log(import_chalk2.default.red(`Error: ${result.error}
+`));
+    }
+    process.exit(1);
+  }
+  const stats = result.data;
+  if (options.json) {
+    console.log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  spinner?.succeed(import_chalk2.default.green("Status retrieved"));
+  console.log("\n" + import_chalk2.default.bold("\u2550".repeat(42)));
+  console.log(import_chalk2.default.bold.white("           \u{1F310} CCgather Status"));
+  console.log(import_chalk2.default.bold("\u2550".repeat(42)));
+  const medal = getRankMedal(stats.rank);
+  console.log(`
+  ${medal} ${import_chalk2.default.bold.yellow(`Rank #${stats.rank}`)}`);
+  console.log(import_chalk2.default.gray(`     Top ${stats.percentile.toFixed(1)}% of all users`));
+  console.log("\n" + import_chalk2.default.gray("\u2500".repeat(42)));
+  console.log(
+    `  ${import_chalk2.default.gray("Tokens")}      ${import_chalk2.default.white(formatNumber2(stats.totalTokens))}`
+  );
+  console.log(
+    `  ${import_chalk2.default.gray("Spent")}       ${import_chalk2.default.green("$" + stats.totalSpent.toFixed(2))}`
+  );
+  console.log(
+    `  ${import_chalk2.default.gray("Tier")}        ${getTierEmoji(stats.tier)} ${import_chalk2.default.white(stats.tier)}`
+  );
+  if (stats.badges && stats.badges.length > 0) {
+    console.log("\n" + import_chalk2.default.gray("\u2500".repeat(42)));
+    console.log(import_chalk2.default.gray("  Badges"));
+    console.log(`  ${stats.badges.join("  ")}`);
+  }
+  console.log("\n" + import_chalk2.default.bold("\u2550".repeat(42)));
+  console.log(import_chalk2.default.gray("\n  View leaderboard: https://ccgather.dev/leaderboard\n"));
+}
+
+// src/commands/setup-auto.ts
+var import_chalk4 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+var http = __toESM(require("http"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+init_config();
+init_config();
+var CALLBACK_PORT = 9876;
+function getClaudeSettingsDir2() {
+  return path3.join(os3.homedir(), ".claude");
+}
+async function openBrowser(url) {
+  const { default: open } = await import("open");
+  await open(url);
+}
+function createCallbackServer() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const userId = url.searchParams.get("userId");
+        const username = url.searchParams.get("username");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(`
+            <html>
+              <head><title>CCgather - Error</title></head>
+              <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a1a; color: #fff;">
+                <div style="text-align: center;">
+                  <h1 style="color: #ef4444;">\u274C Authentication Failed</h1>
+                  <p>${error}</p>
+                  <p style="color: #888;">You can close this window.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (token && userId && username) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(`
+            <html>
+              <head><title>CCgather - Success</title></head>
+              <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #1a1a1a; color: #fff;">
+                <div style="text-align: center;">
+                  <h1 style="color: #22c55e;">\u2705 Authentication Successful!</h1>
+                  <p>Welcome, <strong>${username}</strong>!</p>
+                  <p style="color: #888;">You can close this window and return to your terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve({ token, userId, username });
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing required parameters");
+        }
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+      }
+    });
+    server.listen(CALLBACK_PORT, () => {
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start callback server: ${err.message}`));
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out"));
+    }, 5 * 60 * 1e3);
+  });
+}
+function generateSyncScript(apiUrl, apiToken) {
+  return `#!/usr/bin/env node
+/**
+ * CCgather Auto-Sync Script
+ * This script is automatically called by Claude Code's Stop hook
+ * to sync your usage data to the leaderboard.
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const API_URL = '${apiUrl}';
+const API_TOKEN = '${apiToken}';
+
+// Get Claude Code projects directory for JSONL files
+function getClaudeProjectsDir() {
+  const platform = os.platform();
+  if (platform === 'win32') {
+    return path.join(os.homedir(), '.claude', 'projects');
+  }
+  return path.join(os.homedir(), '.claude', 'projects');
+}
+
+// Parse JSONL files for usage data
+function parseUsageFromJsonl() {
+  const projectsDir = getClaudeProjectsDir();
+
+  if (!fs.existsSync(projectsDir)) {
+    return null;
+  }
+
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  const modelBreakdown = {};
+
+  // Recursively find all .jsonl files
+  function findJsonlFiles(dir) {
+    const files = [];
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          files.push(...findJsonlFiles(fullPath));
+        } else if (entry.name.endsWith('.jsonl')) {
+          files.push(fullPath);
+        }
+      }
+    } catch (e) {
+      // Ignore permission errors
+    }
+    return files;
+  }
+
+  const jsonlFiles = findJsonlFiles(projectsDir);
+
+  for (const filePath of jsonlFiles) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\\n').filter(line => line.trim());
+
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+
+          if (event.type === 'assistant' && event.message?.usage) {
+            const usage = event.message.usage;
+            totalInputTokens += usage.input_tokens || 0;
+            totalOutputTokens += usage.output_tokens || 0;
+            totalCacheRead += usage.cache_read_input_tokens || 0;
+            totalCacheWrite += usage.cache_creation_input_tokens || 0;
+
+            const model = event.message.model || 'unknown';
+            modelBreakdown[model] = (modelBreakdown[model] || 0) +
+              (usage.input_tokens || 0) + (usage.output_tokens || 0);
+          }
+        } catch (e) {
+          // Skip invalid JSON lines
+        }
+      }
+    } catch (e) {
+      // Skip unreadable files
+    }
+  }
+
+  const totalTokens = totalInputTokens + totalOutputTokens;
+
+  if (totalTokens === 0) {
+    return null;
+  }
+
+  // Estimate cost (rough approximation)
+  const costPerMillion = 3; // Average cost
+  const totalCost = (totalTokens / 1000000) * costPerMillion;
+
+  return {
+    totalTokens,
+    totalCost: Math.round(totalCost * 100) / 100,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    cacheReadTokens: totalCacheRead,
+    cacheWriteTokens: totalCacheWrite,
+    modelBreakdown
+  };
+}
+
+// Send data to CCgather API
+function syncToServer(data) {
+  const urlObj = new URL(API_URL + '/cli/sync');
+  const isHttps = urlObj.protocol === 'https:';
+  const client = isHttps ? https : http;
+
+  const postData = JSON.stringify({
+    totalTokens: data.totalTokens,
+    totalSpent: data.totalCost,
+    inputTokens: data.inputTokens,
+    outputTokens: data.outputTokens,
+    cacheReadTokens: data.cacheReadTokens,
+    cacheWriteTokens: data.cacheWriteTokens,
+    modelBreakdown: data.modelBreakdown,
+    timestamp: new Date().toISOString()
+  });
+
+  const options = {
+    hostname: urlObj.hostname,
+    port: urlObj.port || (isHttps ? 443 : 80),
+    path: urlObj.pathname,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(postData),
+      'Authorization': 'Bearer ' + API_TOKEN
+    }
+  };
+
+  const req = client.request(options, (res) => {
+    // Silent success
+  });
+
+  req.on('error', (e) => {
+    // Silent failure - don't interrupt user's workflow
+  });
+
+  req.write(postData);
+  req.end();
+}
+
+// Main execution
+const usageData = parseUsageFromJsonl();
+if (usageData) {
+  syncToServer(usageData);
+}
+`;
+}
+function installStopHook() {
+  const claudeDir = getClaudeSettingsDir2();
+  const settingsPath = path3.join(claudeDir, "settings.json");
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  try {
+    if (fs3.existsSync(settingsPath)) {
+      const content = fs3.readFileSync(settingsPath, "utf-8");
+      settings = JSON.parse(content);
+    }
+  } catch {
+  }
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    settings.hooks = {};
+  }
+  const hooks = settings.hooks;
+  const syncScriptPath = path3.join(claudeDir, "ccgather-sync.js");
+  const hookCommand = `node "${syncScriptPath}"`;
+  if (!hooks.Stop || !Array.isArray(hooks.Stop)) {
+    hooks.Stop = [];
+  }
+  const existingHook = hooks.Stop.find(
+    (h) => typeof h === "object" && h !== null && h.command === hookCommand
+  );
+  if (!existingHook) {
+    hooks.Stop.push({
+      command: hookCommand,
+      background: true
+    });
+  }
+  fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  return { success: true, message: "Stop hook installed" };
+}
+function saveSyncScript(apiUrl, apiToken) {
+  const claudeDir = getClaudeSettingsDir2();
+  const scriptPath = path3.join(claudeDir, "ccgather-sync.js");
+  const scriptContent = generateSyncScript(apiUrl, apiToken);
+  fs3.writeFileSync(scriptPath, scriptContent);
+  if (os3.platform() !== "win32") {
+    fs3.chmodSync(scriptPath, "755");
+  }
+}
+async function setupAuto(options = {}) {
+  if (options.manual) {
+    console.log(import_chalk4.default.bold("\n\u{1F527} Disabling Auto-Sync\n"));
+    const { reset: reset2 } = await Promise.resolve().then(() => (init_reset(), reset_exports));
+    await reset2();
+    console.log(import_chalk4.default.green("\u2713 Auto-sync disabled. Use `npx ccg` to submit manually."));
+    return;
+  }
+  console.log(import_chalk4.default.bold("\n\u26A0\uFE0F  Auto-Sync Mode (Optional)\n"));
+  console.log(import_chalk4.default.gray("This will install a hook that automatically syncs"));
+  console.log(import_chalk4.default.gray("your usage data when Claude Code sessions end."));
+  console.log();
+  console.log(import_chalk4.default.yellow("Note: Manual submission (`npx ccg`) is recommended for most users."));
+  console.log();
+  const inquirer2 = await import("inquirer");
+  const { proceed } = await inquirer2.default.prompt([
+    {
+      type: "confirm",
+      name: "proceed",
+      message: "Continue with auto-sync setup?",
+      default: false
+    }
+  ]);
+  if (!proceed) {
+    console.log(import_chalk4.default.gray("\nSetup cancelled. Use `npx ccg` to submit manually."));
+    return;
+  }
+  const config = getConfig();
+  const apiUrl = getApiUrl();
+  console.log(import_chalk4.default.bold("\n\u{1F310} CCgather Setup\n"));
+  const existingToken = config.get("apiToken");
+  if (existingToken) {
+    const inquirer3 = await import("inquirer");
+    const { reconfigure } = await inquirer3.default.prompt([
+      {
+        type: "confirm",
+        name: "reconfigure",
+        message: "You are already set up. Do you want to reconfigure?",
+        default: false
+      }
+    ]);
+    if (!reconfigure) {
+      console.log(import_chalk4.default.gray("Setup cancelled."));
+      return;
+    }
+  }
+  console.log(import_chalk4.default.gray("Opening browser for GitHub authentication...\n"));
+  const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+  const baseUrl = apiUrl.replace("/api", "");
+  const authUrl = `${baseUrl}/cli/auth?callback=${encodeURIComponent(callbackUrl)}`;
+  const serverPromise = createCallbackServer();
+  try {
+    await openBrowser(authUrl);
+  } catch {
+    console.log(import_chalk4.default.yellow("Could not open browser automatically."));
+    console.log(import_chalk4.default.gray("Please open this URL manually:"));
+    console.log(import_chalk4.default.cyan(authUrl));
+    console.log();
+  }
+  const spinner = (0, import_ora4.default)("Waiting for authentication...").start();
+  try {
+    const authData = await serverPromise;
+    spinner.succeed(import_chalk4.default.green("Authentication successful!"));
+    config.set("apiToken", authData.token);
+    config.set("userId", authData.userId);
+    const hookSpinner = (0, import_ora4.default)("Installing Claude Code hook...").start();
+    try {
+      saveSyncScript(apiUrl, authData.token);
+      const hookResult = installStopHook();
+      if (hookResult.success) {
+        hookSpinner.succeed(import_chalk4.default.green("Hook installed successfully!"));
+      } else {
+        hookSpinner.fail(import_chalk4.default.red("Failed to install hook"));
+        console.log(import_chalk4.default.red(hookResult.message));
+      }
+    } catch (err) {
+      hookSpinner.fail(import_chalk4.default.red("Failed to install hook"));
+      console.log(import_chalk4.default.red(err instanceof Error ? err.message : "Unknown error"));
+    }
+    console.log();
+    console.log(import_chalk4.default.green.bold("\u2705 Setup complete!"));
+    console.log();
+    console.log(import_chalk4.default.gray(`Welcome, ${import_chalk4.default.white(authData.username)}!`));
+    console.log();
+    console.log(import_chalk4.default.gray("Your Claude Code usage will now be automatically synced"));
+    console.log(import_chalk4.default.gray("to the leaderboard when each session ends."));
+    console.log();
+    console.log(import_chalk4.default.gray("View your stats:"));
+    console.log(import_chalk4.default.cyan("  npx ccg status"));
+    console.log();
+    console.log(import_chalk4.default.gray("View the leaderboard:"));
+    console.log(import_chalk4.default.cyan("  https://ccgather.dev/leaderboard"));
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk4.default.red("Authentication failed"));
+    console.log(import_chalk4.default.red(err instanceof Error ? err.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("ccg").description("Submit your Claude Code usage to the CCgather leaderboard").version("1.0.0").option("-y, --yes", "Skip confirmation prompt").option("--auto", "Enable automatic sync on session end").option("--manual", "Disable automatic sync");
+program.command("rank").description("View your current rank and stats").action(status);
+program.command("reset").description("Remove auto-sync hook and clear config").action(async () => {
+  const { reset: reset2 } = await Promise.resolve().then(() => (init_reset(), reset_exports));
+  await reset2();
+});
+program.action(async (options) => {
+  if (options.auto) {
+    await setupAuto({ auto: true });
+    return;
+  }
+  if (options.manual) {
+    await setupAuto({ manual: true });
+    return;
+  }
+  await submit({ yes: options.yes });
+});
+program.parse();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "ccgather",
+  "version": "1.0.0",
+  "description": "CLI tool for syncing Claude Code usage data to CCgather leaderboard",
+  "bin": {
+    "ccgather": "./dist/index.js",
+    "ccg": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts",
+    "dev": "tsup src/index.ts --format cjs --dts --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "claude-code",
+    "ccgather",
+    "leaderboard",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "inquirer": "^10.2.2",
+    "open": "^10.1.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/ccgather"
+  }
+}