cribblecheck 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bobby Backlogs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# CribbleCheck
+
+[![Version](https://img.shields.io/badge/version-1.0.0-gold.svg)](package.json)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-339933.svg)](package.json)
+[![Platform](https://img.shields.io/badge/platform-win%20%7C%20mac%20%7C%20linux-007acc.svg)](package.json)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Cribble](https://img.shields.io/badge/integration-cribble.dev-black.svg)](https://cribble.dev)
+
+A terminal companion for tracking live rankings, compute metrics, and activity across the Cribble arena.
+
+---
+
+## Overview
+
+CribbleCheck provides instant terminal access to your public stats on Cribble. It reads live season standings, token throughput, AI tool breakdowns, and achievement badges directly from the command line without opening a browser.
+
+---
+
+## Installation
+
+Link the package globally using npm:
+
+```bash
+git clone https://github.com/bobbybacklogs/CribbleCheck.git
+cd CribbleCheck
+npm link
+```
+
+---
+
+## Quick Start
+
+### Check Personal Stats
+
+Running without arguments displays your full performance dashboard:
+
+```bash
+cribblecheck
+```
+
+### Leaderboard Exploration
+
+```bash
+# View top developers on the global board
+cribblecheck top 10
+
+# View compute barons on the token board
+cribblecheck tokens
+
+# Inspect AI platform standings
+cribblecheck ai
+
+# Inspect squad rankings
+cribblecheck teams
+```
+
+### Inspect Profiles & Badges
+
+```bash
+# Look up any developer
+cribblecheck <username>
+
+# View all unlocked achievement badges
+cribblecheck badges <username>
+```
+
+### Agent Integration
+
+```bash
+# Verify local background sync status
+cribblecheck local
+
+# Change default handle
+cribblecheck set-user <username>
+
+# Export raw JSON for scripting and status bars
+cribblecheck --json
+```
+
+---
+
+## Commands Summary
+
+| Command | Action |
+| :--- | :--- |
+| `cribblecheck` | Render personal arena dashboard |
+| `cribblecheck top [n]` | Display global leaderboard standings |
+| `cribblecheck tokens` | Display token leaderboard and compute rankings |
+| `cribblecheck ai` | Display AI model and faction share |
+| `cribblecheck teams` | Display team scores and rosters |
+| `cribblecheck badges` | Display achievement badges dossier |
+| `cribblecheck local` | Check local Cribble client and sync status |
+| `cribblecheck set-user <handle>` | Update default saved username |
+
+---
+
+## References
+
+CribbleCheck interfaces with the Cribble developer ecosystem:
+
+- **Cribble Platform**: [cribble.dev](https://cribble.dev)
+- **Global Leaderboard**: [cribble.dev/leaderboard](https://cribble.dev/leaderboard)
+- **Official Agent Repository**: [Birdabo404/cribble-agent](https://github.com/Birdabo404/cribble-agent)
+- **Token Tracker**: Powered by `ccusage` and the Cribble background collector
+
+---
+
+## License
+
+MIT (c) Bobby Backlogs

package/bin/cribblecheck.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+"use strict";
+
+const api = require("../src/api");
+const config = require("../src/config");
+const formatters = require("../src/formatters");
+const local = require("../src/local");
+
+function printHelp() {
+  const c = formatters.c;
+  console.log(`
+${c.goldBold}CribbleCheck · Live Cribble.dev Leaderboard CLI${c.reset}
+
+${c.neonCyan}Usage:${c.reset}
+  cribblecheck [command] [options]
+
+${c.neonCyan}Commands:${c.reset}
+  ${c.white}cribblecheck [username]${c.reset}              Show stats dashboard for yourself or a user
+  ${c.white}cribblecheck top [limit]${c.reset}             Show global developer leaderboard (default: 15)
+  ${c.white}cribblecheck tokens [username]${c.reset}       Show token leaderboard or user token stats
+  ${c.white}cribblecheck ai${c.reset}                      Show AI faction war rankings (ChatGPT, Claude, etc.)
+  ${c.white}cribblecheck teams${c.reset}                   Show team leaderboard and scores
+  ${c.white}cribblecheck badges [username]${c.reset}      Show all unlocked achievement badges
+  ${c.white}cribblecheck local${c.reset}                   Inspect your local Cribble Agent status & sync
+  ${c.white}cribblecheck set-user <handle>${c.reset}      Set your default Cribble username (saved locally)
+
+${c.neonCyan}Options:${c.reset}
+  ${c.white}--json${c.reset}                               Output raw JSON for scripts/pipes
+  ${c.white}-h, --help${c.reset}                           Show this help message
+  ${c.white}-v, --version${c.reset}                        Show CLI version
+
+${c.charcoal}Default username: ${config.getDefaultUser()}${c.reset}
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const jsonMode = args.includes("--json");
+  const filteredArgs = args.filter(a => a !== "--json");
+
+  let cmd = filteredArgs[0] || "stats";
+  let targetUser = config.getDefaultUser();
+
+  if (cmd === "-h" || cmd === "--help" || cmd === "help") {
+    printHelp();
+    return;
+  }
+
+  if (cmd === "-v" || cmd === "--version" || cmd === "version") {
+    const pkg = require("../package.json");
+    console.log(`cribblecheck v${pkg.version}`);
+    return;
+  }
+
+  if (cmd === "set-user" || cmd === "config") {
+    const newUsername = cmd === "set-user" ? filteredArgs[1] : (filteredArgs[1] === "set-user" ? filteredArgs[2] : filteredArgs[1]);
+    if (!newUsername) {
+      console.error("Please specify a username: cribblecheck set-user <handle>");
+      process.exit(1);
+    }
+    config.setDefaultUser(newUsername);
+    console.log(`${formatters.c.neonGreen}✓ Default Cribble username set to:${formatters.c.reset} ${formatters.c.bold}${newUsername}${formatters.c.reset}`);
+    return;
+  }
+
+  try {
+    if (cmd === "top" || cmd === "leaderboard") {
+      const limit = parseInt(filteredArgs[1], 10) || 15;
+      const lb = await api.getLeaderboard();
+      if (jsonMode) {
+        console.log(JSON.stringify(lb.data?.slice(0, limit), null, 2));
+        return;
+      }
+      formatters.renderLeaderboardTable(lb.data || [], limit, targetUser);
+      return;
+    }
+
+    if (cmd === "ai" || cmd === "factions" || cmd === "models") {
+      const aiData = await api.getAiLeaderboard();
+      const tools = aiData.boards?.season?.tools || aiData.boards?.alltime?.tools || [];
+      if (jsonMode) {
+        console.log(JSON.stringify(tools, null, 2));
+        return;
+      }
+      formatters.renderAiTable(tools);
+      return;
+    }
+
+    if (cmd === "tokens") {
+      const specificUser = filteredArgs[1];
+      const tokData = await api.getTokenLeaderboard();
+      if (specificUser) {
+        const found = tokData.rows?.find(r => r.username?.toLowerCase() === specificUser.toLowerCase());
+        if (!found) {
+          console.error(`User "${specificUser}" not found on Token Leaderboard.`);
+          process.exit(1);
+        }
+        if (jsonMode) {
+          console.log(JSON.stringify(found, null, 2));
+          return;
+        }
+        // render stats
+        console.log(JSON.stringify(found, null, 2));
+        return;
+      }
+
+      if (jsonMode) {
+        console.log(JSON.stringify(tokData.rows, null, 2));
+        return;
+      }
+      formatters.renderTokenTable(tokData.rows || [], 15, targetUser);
+      return;
+    }
+
+    if (cmd === "teams") {
+      const teamsData = await api.getTeamsLeaderboard();
+      if (jsonMode) {
+        console.log(JSON.stringify(teamsData, null, 2));
+        return;
+      }
+      formatters.renderHeader("TEAMS LEADERBOARD", "Active Factions & Squads");
+      const teams = teamsData.data || [];
+      console.log(`${formatters.c.charcoal}RANK  TEAM NAME                    MEMBERS    TOTAL SCORE${formatters.c.reset}`);
+      console.log(`${formatters.c.charcoal}─────────────────────────────────────────────────────────────${formatters.c.reset}`);
+      teams.slice(0, 15).forEach((t, i) => {
+        const rankStr = (`#${i + 1}`).padEnd(5);
+        const nameStr = (t.name || t.username).slice(0, 26).padEnd(28);
+        const membersStr = (`${t.members?.length || t.memberCount || 1}`).padStart(7);
+        const scoreStr = formatters.formatNumber(t.score || t.totalScore || 0).padStart(14);
+        console.log(`${formatters.c.white}${rankStr}${formatters.c.reset} ${formatters.c.bold}${nameStr}${formatters.c.reset} ${formatters.c.cyan}${membersStr}${formatters.c.reset}   ${formatters.c.neonGreen}${scoreStr}${formatters.c.reset}`);
+      });
+      console.log("");
+      return;
+    }
+
+    if (cmd === "badges") {
+      const user = filteredArgs[1] || targetUser;
+      const profile = await api.getUserProfile(user);
+      if (jsonMode) {
+        console.log(JSON.stringify(profile.profile?.badges || [], null, 2));
+        return;
+      }
+      formatters.renderBadges(profile);
+      return;
+    }
+
+    if (cmd === "local") {
+      const localInfo = local.readLocalStatus();
+      if (jsonMode) {
+        console.log(JSON.stringify(localInfo, null, 2));
+        return;
+      }
+      formatters.renderHeader("LOCAL AGENT STATUS", "Cribble CLI & Token Ledger");
+      console.log(`${formatters.c.brightWhite}Installed:${formatters.c.reset}       ${localInfo.installed ? formatters.c.neonGreen + "Yes" : formatters.c.red + "No"}${formatters.c.reset}`);
+      console.log(`${formatters.c.brightWhite}Config Directory:${formatters.c.reset} ${localInfo.directory}`);
+      console.log(`${formatters.c.brightWhite}Client ID:${formatters.c.reset}        ${localInfo.clientId || "None"}`);
+      console.log(`${formatters.c.brightWhite}API Key Storage:${formatters.c.reset}  ${localInfo.hasKey ? formatters.c.neonGreen + "Protected in DPAPI" : formatters.c.yellow + "Not found"}${formatters.c.reset}`);
+      if (localInfo.syncState) {
+        console.log(`${formatters.c.brightWhite}Last Sync Attempt:${formatters.c.reset} ${localInfo.syncState.lastAttemptAt || "—"}`);
+        console.log(`${formatters.c.brightWhite}Last Sync Success:${formatters.c.reset} ${localInfo.syncState.lastSuccessAt || "—"}`);
+        if (localInfo.syncState.lastResult) {
+          const r = localInfo.syncState.lastResult;
+          console.log(`${formatters.c.brightWhite}Last Sync Result:${formatters.c.reset}  ${r.inserted || 0} inserted, ${r.replaced || 0} replaced, ${r.stale || 0} stale`);
+        }
+      }
+      console.log("");
+      return;
+    }
+
+    // Default: stats or username
+    let userToCheck = targetUser;
+    if (cmd !== "stats" && !cmd.startsWith("-")) {
+      userToCheck = cmd;
+    } else if (filteredArgs[1]) {
+      userToCheck = filteredArgs[1];
+    }
+
+    const [profile, lbData, tokData] = await Promise.all([
+      api.getUserProfile(userToCheck),
+      api.getLeaderboard(),
+      api.getTokenLeaderboard()
+    ]);
+
+    const lbEntry = lbData.data?.find(u => u.username?.toLowerCase() === userToCheck.toLowerCase());
+    const tokenEntry = tokData.rows?.find(r => r.username?.toLowerCase() === userToCheck.toLowerCase());
+
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        profile: profile.profile,
+        leaderboard: lbEntry,
+        tokenStats: tokenEntry,
+        season: lbData.season
+      }, null, 2));
+      return;
+    }
+
+    formatters.renderUserDashboard(profile, lbEntry, tokenEntry, lbData.season);
+
+  } catch (err) {
+    if (jsonMode) {
+      console.error(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`\n${formatters.c.red}${formatters.c.bold}Error:${formatters.c.reset} ${err.message}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "cribblecheck",
+  "version": "1.0.0",
+  "description": "CLI tool to check your Cribble.dev leaderboard rankings, token stats, AI factions, and badges.",
+  "main": "src/index.js",
+  "bin": {
+    "cribblecheck": "bin/cribblecheck.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true,
+  "scripts": {
+    "start": "node bin/cribblecheck.js",
+    "test": "node bin/cribblecheck.js stats"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bobbybacklogs/CribbleCheck.git"
+  },
+  "keywords": [
+    "cribble",
+    "cribble.dev",
+    "leaderboard",
+    "ai-usage",
+    "token-tracker",
+    "ccusage",
+    "cli"
+  ],
+  "author": "Bobby Backlogs",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bobbybacklogs/CribbleCheck/issues"
+  },
+  "homepage": "https://github.com/bobbybacklogs/CribbleCheck#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/api.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const BASE_URL = "https://cribble.dev";
+
+async function fetchJson(endpoint) {
+  const url = `${BASE_URL}${endpoint}`;
+  const res = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": "CribbleCheck-CLI/1.0"
+    }
+  });
+
+  if (!res.ok) {
+    throw new Error(`Cribble API returned HTTP ${res.status} for ${endpoint}`);
+  }
+
+  return await res.json();
+}
+
+async function getLeaderboard() {
+  return await fetchJson("/api/leaderboard");
+}
+
+async function getTokenLeaderboard() {
+  return await fetchJson("/api/leaderboard/tokens");
+}
+
+async function getAiLeaderboard() {
+  return await fetchJson("/api/leaderboard/ai");
+}
+
+async function getTeamsLeaderboard() {
+  return await fetchJson("/api/leaderboard/teams");
+}
+
+async function getUserProfile(username) {
+  if (!username) throw new Error("Username is required");
+  return await fetchJson(`/api/profile/${encodeURIComponent(username)}`);
+}
+
+async function getCursorAgentsLeaderboard() {
+  return await fetchJson("/api/leaderboard/cursor-agents");
+}
+
+async function getBillboard() {
+  return await fetchJson("/api/billboard/leaderboard");
+}
+
+module.exports = {
+  BASE_URL,
+  getLeaderboard,
+  getTokenLeaderboard,
+  getAiLeaderboard,
+  getTeamsLeaderboard,
+  getUserProfile,
+  getCursorAgentsLeaderboard,
+  getBillboard
+};

package/src/config.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function getConfigPath() {
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    const dir = path.join(localAppData, "CribbleCheck");
+    if (!fs.existsSync(dir)) {
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+      } catch {}
+    }
+    return path.join(dir, "config.json");
+  }
+  return path.join(home, ".cribblecheckrc");
+}
+
+function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf8");
+      return JSON.parse(raw);
+    }
+  } catch {}
+  return { username: "bobbybacklogs" };
+}
+
+function saveConfig(cfg) {
+  const configPath = getConfigPath();
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf8");
+    return true;
+  } catch (err) {
+    console.error("Failed to save config:", err.message);
+    return false;
+  }
+}
+
+function getDefaultUser() {
+  const cfg = loadConfig();
+  return cfg.username || "bobbybacklogs";
+}
+
+function setDefaultUser(username) {
+  const cfg = loadConfig();
+  cfg.username = username.trim();
+  saveConfig(cfg);
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  getDefaultUser,
+  setDefaultUser,
+  getConfigPath
+};

package/src/formatters.js

@@ -0,0 +1,298 @@
+"use strict";
+
+// ANSI escape codes
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  italic: "\x1b[3m",
+  underline: "\x1b[4m",
+  
+  // Colors
+  black: "\x1b[30m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  
+  // Bright colors
+  brightBlack: "\x1b[90m",
+  brightRed: "\x1b[91m",
+  brightGreen: "\x1b[92m",
+  brightYellow: "\x1b[93m",
+  brightBlue: "\x1b[94m",
+  brightMagenta: "\x1b[95m",
+  brightCyan: "\x1b[96m",
+  brightWhite: "\x1b[97m",
+  
+  // Custom theme shades
+  gold: "\x1b[38;2;255;215;0m",
+  goldBold: "\x1b[1m\x1b[38;2;255;215;0m",
+  neonCyan: "\x1b[38;2;0;240;255m",
+  neonGreen: "\x1b[38;2;57;255;136m",
+  neonPink: "\x1b[38;2;255;92;138m",
+  neonPurple: "\x1b[38;2;170;110;255m",
+  neonOrange: "\x1b[38;2;255;128;0m",
+  charcoal: "\x1b[38;2;120;120;130m",
+  silver: "\x1b[38;2;210;210;225m",
+  bronze: "\x1b[38;2;205;127;50m",
+  
+  bgBlack: "\x1b[40m",
+  bgDark: "\x1b[48;2;18;20;28m"
+};
+
+function formatNumber(num) {
+  if (num === null || num === undefined) return "0";
+  return Number(num).toLocaleString("en-US");
+}
+
+function formatCompactNumber(num) {
+  if (num === null || num === undefined) return "0";
+  const n = Number(num);
+  if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return n.toLocaleString("en-US");
+}
+
+function formatDurationMs(ms) {
+  if (!ms || ms <= 0) return "0m";
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+
+function formatMoney(amount) {
+  if (!amount || amount === "0") return "$0.00";
+  const val = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(val)) return "$0.00";
+  return "$" + val.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+
+function progressBar(percent, width = 14) {
+  const p = Math.max(0, Math.min(100, percent || 0));
+  const filled = Math.round((p / 100) * width);
+  const empty = width - filled;
+  return `${c.neonCyan}${"█".repeat(filled)}${c.brightBlack}${"░".repeat(empty)}${c.reset} ${c.white}${p}%${c.reset}`;
+}
+
+function rankTag(rank) {
+  if (rank === 1) return `${c.goldBold}#1 👑${c.reset}`;
+  if (rank === 2) return `${c.silver}#2 🥈${c.reset}`;
+  if (rank === 3) return `${c.bronze}#3 🥉${c.reset}`;
+  if (rank <= 10) return `${c.brightMagenta}#${rank} ⚡${c.reset}`;
+  return `${c.brightCyan}#${rank}${c.reset}`;
+}
+
+function getRarityBadge(rarity) {
+  switch ((rarity || "").toLowerCase()) {
+    case "legendary":
+      return `${c.goldBold}[LEGENDARY]${c.reset}`;
+    case "epic":
+      return `${c.neonPurple}[EPIC]${c.reset}`;
+    case "rare":
+      return `${c.neonCyan}[RARE]${c.reset}`;
+    case "common":
+    default:
+      return `${c.brightBlack}[COMMON]${c.reset}`;
+  }
+}
+
+function renderHeader(title, subtitle = "") {
+  const line = "═".repeat(56);
+  console.log(`${c.goldBold}╔${line}╗${c.reset}`);
+  console.log(`${c.goldBold}║${c.reset}  ${c.neonCyan}${c.bold}CRIBBLE · ${title.toUpperCase()}${c.reset}`.padEnd(68) + `${c.goldBold}║${c.reset}`);
+  if (subtitle) {
+    console.log(`${c.goldBold}║${c.reset}  ${c.charcoal}${subtitle}${c.reset}`.padEnd(68) + `${c.goldBold}║${c.reset}`);
+  }
+  console.log(`${c.goldBold}╚${line}╝${c.reset}\n`);
+}
+
+function renderUserDashboard(profile, lbEntry, tokenEntry, season) {
+  const p = profile.profile || profile;
+  const username = p.username || "Unknown";
+  const displayName = p.display_name || p.displayName || username;
+  const rank = lbEntry?.rank || p.rank || "—";
+  const score = lbEntry?.score || p.score || 0;
+  const todayScore = lbEntry?.todayScore || p.todayScore || 0;
+  const weekScore = lbEntry?.weekScore || p.weekScore || 0;
+  const streak = p.longestStreak || p.streak || 0;
+  const activeDays = p.activeDays || 0;
+  const activeTime = formatDurationMs(p.totalActiveMs || p.active_ms);
+
+  const seasonName = season?.current?.name || "SEASON 01";
+  renderHeader(`LEADERBOARD STATS`, `${seasonName} · Live Arena`);
+
+  // Main Identity Card
+  console.log(`${c.bold}${c.white}${displayName}${c.reset} ${c.charcoal}(@${username})${c.reset} ${rankTag(rank)}`);
+  if (p.bio) console.log(`${c.italic}${c.charcoal}"${p.bio}"${c.reset}`);
+  console.log("");
+
+  // Key Metrics Grid
+  console.log(`${c.goldBold}┌─ ARENA PERFORMANCE ──────────────────────────────────┐${c.reset}`);
+  console.log(`${c.goldBold}│${c.reset}  ${c.brightWhite}Current Score:${c.reset}  ${c.neonGreen}${c.bold}${formatNumber(score)} pts${c.reset}      ${c.brightWhite}Global Rank:${c.reset}  ${rankTag(rank)}`.padEnd(72) + `${c.goldBold}│${c.reset}`);
+  console.log(`${c.goldBold}│${c.reset}  ${c.brightWhite}Today's Gain:${c.reset}   ${c.neonCyan}+${formatNumber(todayScore)} pts${c.reset}      ${c.brightWhite}7-Day Gain:${c.reset}   ${c.neonCyan}+${formatNumber(weekScore)} pts${c.reset}`.padEnd(72) + `${c.goldBold}│${c.reset}`);
+  console.log(`${c.goldBold}│${c.reset}  ${c.brightWhite}Streak:${c.reset}         ${c.neonOrange}${streak} days 🔥${c.reset}        ${c.brightWhite}Active Days:${c.reset}  ${c.white}${activeDays} days${c.reset}`.padEnd(70) + `${c.goldBold}│${c.reset}`);
+  console.log(`${c.goldBold}│${c.reset}  ${c.brightWhite}Active Time:${c.reset}    ${c.white}${activeTime}${c.reset}`.padEnd(61) + `${c.goldBold}│${c.reset}`);
+  console.log(`${c.goldBold}└───────────────────────────────────────────────────────┘${c.reset}\n`);
+
+  // Token Stats (if available)
+  if (tokenEntry) {
+    const totalTokens = formatCompactNumber(tokenEntry.totalTokens);
+    const inTokens = formatCompactNumber(tokenEntry.inputTokens);
+    const outTokens = formatCompactNumber(tokenEntry.outputTokens);
+    const cacheTokens = formatCompactNumber(tokenEntry.cacheTokens || tokenEntry.cacheReadTokens);
+    const burn = formatMoney(tokenEntry.burnUsd);
+    const persona = tokenEntry.persona ? `${tokenEntry.persona.label}` : "AI AGENT";
+    const cachePct = tokenEntry.cachePercent || 0;
+
+    console.log(`${c.neonPurple}┌─ TOKEN & COMPUTE STATS ───────────────────────────────┐${c.reset}`);
+    console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Token Rank:${c.reset}     ${rankTag(tokenEntry.rank)}           ${c.brightWhite}Persona:${c.reset}      ${c.neonPurple}${persona}${c.reset}`.padEnd(70) + `${c.neonPurple}│${c.reset}`);
+    console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Total Tokens:${c.reset}   ${c.neonGreen}${c.bold}${totalTokens}${c.reset} (${formatNumber(tokenEntry.totalTokens)})${c.reset}`.padEnd(61) + `${c.neonPurple}│${c.reset}`);
+    console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Cache Ratio:${c.reset}    ${progressBar(cachePct, 12)} (${cacheTokens} cached)`.padEnd(69) + `${c.neonPurple}│${c.reset}`);
+    console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Input/Output:${c.reset}   ${c.white}${inTokens} in / ${outTokens} out${c.reset}`.padEnd(61) + `${c.neonPurple}│${c.reset}`);
+    console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Estimated Burn:${c.reset} ${c.neonOrange}${burn}${c.reset}`.padEnd(61) + `${c.neonPurple}│${c.reset}`);
+    if (tokenEntry.topAgent) {
+      console.log(`${c.neonPurple}│${c.reset}  ${c.brightWhite}Top Agent:${c.reset}      ${c.neonCyan}${tokenEntry.topAgent.toUpperCase()}${c.reset}`.padEnd(61) + `${c.neonPurple}│${c.reset}`);
+    }
+    console.log(`${c.neonPurple}└───────────────────────────────────────────────────────┘${c.reset}\n`);
+  }
+
+  // Top Tools Breakdown
+  if (p.topTools && p.topTools.length > 0) {
+    console.log(`${c.neonCyan}${c.bold}TOP AI TOOLS${c.reset}`);
+    for (const tool of p.topTools) {
+      const timeStr = formatDurationMs(tool.active_ms);
+      console.log(`  ${c.white}${tool.name.padEnd(16)}${c.reset} ${progressBar(tool.percent, 16)}  ${c.charcoal}${tool.visits} visits · ${timeStr}${c.reset}`);
+    }
+    console.log("");
+  }
+
+  // Top Agents Breakdown
+  if (p.topAgents && p.topAgents.length > 0) {
+    console.log(`${c.neonGreen}${c.bold}TOP CODING AGENTS${c.reset}`);
+    for (const agent of p.topAgents) {
+      const tokensStr = formatCompactNumber(agent.totalTokens);
+      console.log(`  ${c.white}${agent.name.padEnd(16)}${c.reset} ${progressBar(agent.percent, 16)}  ${c.charcoal}${tokensStr} tokens${c.reset}`);
+    }
+    console.log("");
+  }
+
+  // Badges Overview
+  if (p.badges && p.badges.length > 0) {
+    console.log(`${c.goldBold}BADGES UNLOCKED (${p.badges.length})${c.reset}`);
+    const preview = p.badges.slice(0, 4);
+    for (const b of preview) {
+      console.log(`  ${getRarityBadge(b.rarity)} ${c.bold}${b.name}${c.reset} · ${c.charcoal}${b.description}${c.reset}`);
+    }
+    if (p.badges.length > 4) {
+      console.log(`  ${c.dim}...and ${p.badges.length - 4} more. Run \`cribblecheck badges ${username}\` to view all.${c.reset}`);
+    }
+    console.log("");
+  }
+}
+
+function renderLeaderboardTable(users, limit = 15, currentUsername = "") {
+  renderHeader(`GLOBAL LEADERBOARD`, `Top ${limit} Developers by AI Activity`);
+  console.log(`${c.charcoal}RANK   DEVELOPER                    SCORE       TODAY       7-DAY      STREAK${c.reset}`);
+  console.log(`${c.charcoal}─────────────────────────────────────────────────────────────────────────${c.reset}`);
+
+  users.slice(0, limit).forEach(u => {
+    const isYou = currentUsername && u.username?.toLowerCase() === currentUsername.toLowerCase();
+    const rankStr = (`#${u.rank}`).padEnd(6);
+    const nameStr = (`${u.display_name || u.username}`).slice(0, 26).padEnd(27);
+    const scoreStr = formatNumber(u.score).padStart(9);
+    const todayStr = (`+${formatNumber(u.todayScore || 0)}`).padStart(10);
+    const weekStr = (`+${formatNumber(u.weekScore || 0)}`).padStart(10);
+    const youTag = isYou ? ` ${c.goldBold}◄ YOU${c.reset}` : "";
+
+    let line = `${c.white}${rankStr}${c.reset} ${c.brightWhite}${nameStr}${c.reset} ${c.neonGreen}${scoreStr}${c.reset}  ${c.cyan}${todayStr}${c.reset}  ${c.charcoal}${weekStr}${c.reset}${youTag}`;
+    if (isYou) {
+      line = `${c.goldBold}${rankStr}${c.reset} ${c.goldBold}${nameStr}${c.reset} ${c.neonGreen}${c.bold}${scoreStr}${c.reset}  ${c.neonCyan}${c.bold}${todayStr}${c.reset}  ${c.white}${weekStr}${c.reset}${youTag}`;
+    }
+    console.log(line);
+  });
+  console.log("");
+}
+
+function renderTokenTable(rows, limit = 15, currentUsername = "") {
+  renderHeader(`TOKEN LEADERBOARD`, `Top Compute Barons by Token Volume`);
+  console.log(`${c.charcoal}RANK   DEVELOPER              TOTAL TOKENS     CACHE %   EST. BURN    TOP AGENT${c.reset}`);
+  console.log(`${c.charcoal}───────────────────────────────────────────────────────────────────────────${c.reset}`);
+
+  rows.slice(0, limit).forEach(r => {
+    const isYou = currentUsername && r.username?.toLowerCase() === currentUsername.toLowerCase();
+    const rankStr = (`#${r.rank}`).padEnd(6);
+    const nameStr = (`${r.displayName || r.username}`).slice(0, 20).padEnd(21);
+    const tokenStr = formatCompactNumber(r.totalTokens).padStart(12);
+    const cacheStr = (`${r.cachePercent || 0}%`).padStart(8);
+    const burnStr = formatMoney(r.burnUsd).padStart(11);
+    const agentStr = (r.topAgent || "—").toUpperCase().padEnd(10);
+    const youTag = isYou ? ` ${c.goldBold}◄ YOU${c.reset}` : "";
+
+    let line = `${c.white}${rankStr}${c.reset} ${c.brightWhite}${nameStr}${c.reset} ${c.neonGreen}${tokenStr}${c.reset}   ${c.neonCyan}${cacheStr}${c.reset} ${c.neonOrange}${burnStr}${c.reset}    ${c.white}${agentStr}${c.reset}${youTag}`;
+    if (isYou) {
+      line = `${c.goldBold}${rankStr}${c.reset} ${c.goldBold}${nameStr}${c.reset} ${c.neonGreen}${c.bold}${tokenStr}${c.reset}   ${c.neonCyan}${c.bold}${cacheStr}${c.reset} ${c.neonOrange}${c.bold}${burnStr}${c.reset}    ${c.gold}${agentStr}${c.reset}${youTag}`;
+    }
+    console.log(line);
+  });
+  console.log("");
+}
+
+function renderAiTable(tools) {
+  renderHeader(`FACTION WARS`, `AI Tools & LLM Platform Market Share`);
+  console.log(`${c.charcoal}RANK  TOOL               SCORE         FIELD SHARE   VISITS    ACTIVE PLAYERS${c.reset}`);
+  console.log(`${c.charcoal}──────────────────────────────────────────────────────────────────────────────${c.reset}`);
+
+  tools.slice(0, 15).forEach(t => {
+    const rankStr = (`#${t.rank}`).padEnd(5);
+    const nameStr = t.name.slice(0, 17).padEnd(18);
+    const scoreStr = formatNumber(t.score).padStart(10);
+    const bar = progressBar(t.percent, 10);
+    const visitsStr = formatNumber(t.visits).padStart(8);
+    const pilotsStr = formatNumber(t.pilots).padStart(8);
+
+    console.log(`${c.white}${rankStr}${c.reset} ${c.brightWhite}${c.bold}${nameStr}${c.reset} ${c.neonGreen}${scoreStr}${c.reset}    ${bar}  ${c.charcoal}${visitsStr}${c.reset}  ${c.white}${pilotsStr}${c.reset}`);
+  });
+  console.log("");
+}
+
+function renderBadges(profile) {
+  const p = profile.profile || profile;
+  const badges = p.badges || [];
+  renderHeader(`BADGES DOSSIER`, `${p.display_name || p.username} · ${badges.length} Badges Unlocked`);
+
+  if (badges.length === 0) {
+    console.log(`${c.charcoal}No badges unlocked yet.${c.reset}\n`);
+    return;
+  }
+
+  for (const b of badges) {
+    const unlocked = b.unlockedAt ? new Date(b.unlockedAt).toLocaleDateString() : "";
+    console.log(`${getRarityBadge(b.rarity)} ${c.goldBold}${b.name}${c.reset} ${c.charcoal}(${unlocked})${c.reset}`);
+    console.log(`  ${c.white}${b.description}${c.reset}\n`);
+  }
+}
+
+module.exports = {
+  c,
+  formatNumber,
+  formatCompactNumber,
+  formatDurationMs,
+  formatMoney,
+  progressBar,
+  rankTag,
+  renderHeader,
+  renderUserDashboard,
+  renderLeaderboardTable,
+  renderTokenTable,
+  renderAiTable,
+  renderBadges
+};

package/src/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const api = require("./api");
+const config = require("./config");
+const formatters = require("./formatters");
+const local = require("./local");
+
+module.exports = {
+  api,
+  config,
+  formatters,
+  local
+};

package/src/local.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function getLocalCribbleDir() {
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    return path.join(localAppData, "Cribble");
+  }
+  if (process.platform === "darwin") {
+    return path.join(home, ".config", "cribble");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+  return path.join(xdg, "cribble");
+}
+
+function readLocalStatus() {
+  const cribbleDir = getLocalCribbleDir();
+  if (!fs.existsSync(cribbleDir)) {
+    return { installed: false, error: "Local Cribble directory not found" };
+  }
+
+  const clientIdPath = path.join(cribbleDir, "client-id");
+  const syncStatePath = path.join(cribbleDir, "sync-state.json");
+  const scopePath = path.join(cribbleDir, "usage-scope");
+  const dpapiPath = path.join(cribbleDir, "agent-key.dpapi");
+
+  let clientId = null;
+  let syncState = null;
+  let usageScope = null;
+  let hasKey = false;
+
+  if (fs.existsSync(clientIdPath)) {
+    try {
+      clientId = fs.readFileSync(clientIdPath, "utf8").trim();
+    } catch {}
+  }
+
+  if (fs.existsSync(syncStatePath)) {
+    try {
+      syncState = JSON.parse(fs.readFileSync(syncStatePath, "utf8"));
+    } catch {}
+  }
+
+  if (fs.existsSync(scopePath)) {
+    try {
+      usageScope = fs.readFileSync(scopePath, "utf8").trim();
+    } catch {}
+  }
+
+  if (fs.existsSync(dpapiPath)) {
+    hasKey = true;
+  }
+
+  return {
+    installed: true,
+    directory: cribbleDir,
+    clientId,
+    syncState,
+    usageScope,
+    hasKey
+  };
+}
+
+module.exports = {
+  getLocalCribbleDir,
+  readLocalStatus
+};