vibechk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1691 @@
+"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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/atomic.ts
+function writeJson(filePath, data) {
+  const tmp = filePath + ".tmp." + (0, import_crypto.randomBytes)(6).toString("hex");
+  (0, import_fs.writeFileSync)(tmp, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+  (0, import_fs.renameSync)(tmp, filePath);
+}
+function readJson(filePath) {
+  if (!(0, import_fs.existsSync)(filePath)) return null;
+  try {
+    return JSON.parse((0, import_fs.readFileSync)(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var import_fs, import_crypto;
+var init_atomic = __esm({
+  "src/storage/atomic.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_crypto = require("crypto");
+  }
+});
+
+// src/storage/paths.ts
+function ensureDir() {
+  if (!(0, import_fs2.existsSync)(VIBECHK_DIR)) {
+    (0, import_fs2.mkdirSync)(VIBECHK_DIR, { recursive: true, mode: 448 });
+  }
+}
+var import_os, import_path, import_fs2, VIBECHK_SERVER, VIBECHK_DIR, PROFILE_PATH, STREAK_PATH, ACTIVITY_PATH, BADGES_PATH, LEADERBOARD_CACHE_PATH, FRIENDS_PATH, GIST_TOKEN_PATH;
+var init_paths = __esm({
+  "src/storage/paths.ts"() {
+    "use strict";
+    import_os = require("os");
+    import_path = require("path");
+    import_fs2 = require("fs");
+    VIBECHK_SERVER = process.env.VIBECHK_SERVER ? process.env.VIBECHK_SERVER.replace(/\/$/, "") : null;
+    VIBECHK_DIR = (0, import_path.join)((0, import_os.homedir)(), ".vibechk");
+    PROFILE_PATH = (0, import_path.join)(VIBECHK_DIR, "profile.json");
+    STREAK_PATH = (0, import_path.join)(VIBECHK_DIR, "streak.json");
+    ACTIVITY_PATH = (0, import_path.join)(VIBECHK_DIR, "activity.jsonl");
+    BADGES_PATH = (0, import_path.join)(VIBECHK_DIR, "badges.json");
+    LEADERBOARD_CACHE_PATH = (0, import_path.join)(VIBECHK_DIR, "leaderboard.json");
+    FRIENDS_PATH = (0, import_path.join)(VIBECHK_DIR, "friends.json");
+    GIST_TOKEN_PATH = (0, import_path.join)(VIBECHK_DIR, "gist-token");
+  }
+});
+
+// src/storage/profile-store.ts
+function loadProfile() {
+  return readJson(PROFILE_PATH);
+}
+function requireProfile() {
+  const profile = loadProfile();
+  if (!profile) {
+    throw new Error(
+      "No vibechk profile found. Run `vibechk init` to get started."
+    );
+  }
+  return profile;
+}
+var init_profile_store = __esm({
+  "src/storage/profile-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+  }
+});
+
+// src/storage/streak-store.ts
+function loadStreak() {
+  return readJson(STREAK_PATH) ?? { ...DEFAULT_STREAK };
+}
+function saveStreak(streak) {
+  ensureDir();
+  writeJson(STREAK_PATH, streak);
+}
+var DEFAULT_STREAK;
+var init_streak_store = __esm({
+  "src/storage/streak-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    DEFAULT_STREAK = {
+      currentStreak: 0,
+      longestStreak: 0,
+      lastActivityDate: null,
+      lastCheckInAt: null,
+      freezeTokens: 2,
+      totalCheckIns: 0,
+      graceUsedAt: null,
+      status: "new"
+    };
+  }
+});
+
+// src/storage/activity-store.ts
+function appendActivity(entry) {
+  ensureDir();
+  const line = JSON.stringify(entry) + "\n";
+  (0, import_fs3.appendFileSync)(ACTIVITY_PATH, line, { encoding: "utf8", mode: 384 });
+}
+function loadActivity() {
+  if (!(0, import_fs3.existsSync)(ACTIVITY_PATH)) return [];
+  try {
+    const content = (0, import_fs3.readFileSync)(ACTIVITY_PATH, "utf8");
+    return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+var import_fs3;
+var init_activity_store = __esm({
+  "src/storage/activity-store.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    init_paths();
+  }
+});
+
+// src/storage/badge-store.ts
+function loadBadges() {
+  return readJson(BADGES_PATH) ?? { ...DEFAULT_BADGES };
+}
+function saveBadges(badges) {
+  ensureDir();
+  writeJson(BADGES_PATH, badges);
+}
+function appendBadges(newBadges) {
+  if (newBadges.length === 0) return;
+  const current = loadBadges();
+  current.earned.push(...newBadges);
+  saveBadges(current);
+}
+var DEFAULT_BADGES;
+var init_badge_store = __esm({
+  "src/storage/badge-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    DEFAULT_BADGES = { earned: [] };
+  }
+});
+
+// src/core/date-utils.ts
+function todayInTz(tz) {
+  return (0, import_dayjs.default)().tz(tz).format("YYYY-MM-DD");
+}
+function dateInTz(isoTimestamp, tz) {
+  return (0, import_dayjs.default)(isoTimestamp).tz(tz).format("YYYY-MM-DD");
+}
+function daysBetween(a, b) {
+  const da = (0, import_dayjs.default)(a, "YYYY-MM-DD");
+  const db = (0, import_dayjs.default)(b, "YYYY-MM-DD");
+  return db.diff(da, "day");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var import_dayjs, import_utc, import_timezone;
+var init_date_utils = __esm({
+  "src/core/date-utils.ts"() {
+    "use strict";
+    import_dayjs = __toESM(require("dayjs"), 1);
+    import_utc = __toESM(require("dayjs/plugin/utc.js"), 1);
+    import_timezone = __toESM(require("dayjs/plugin/timezone.js"), 1);
+    import_dayjs.default.extend(import_utc.default);
+    import_dayjs.default.extend(import_timezone.default);
+  }
+});
+
+// src/core/milestone-checker.ts
+function getAllMilestones() {
+  return MILESTONES;
+}
+function checkNewMilestones(newStreak, badges) {
+  const all = getAllMilestones();
+  const earnedIds = new Set(badges.earned.map((b) => b.milestoneId));
+  return all.filter((m) => m.streakRequired <= newStreak && !earnedIds.has(m.id));
+}
+function createEarnedBadges(milestones, streak, nowIso2) {
+  return milestones.map((m) => ({
+    milestoneId: m.id,
+    earnedAt: nowIso2,
+    streakAtEarning: streak
+  }));
+}
+function totalFreezeReward(milestones) {
+  return milestones.reduce((sum, m) => sum + m.freezeTokenReward, 0);
+}
+var MILESTONES;
+var init_milestone_checker = __esm({
+  "src/core/milestone-checker.ts"() {
+    "use strict";
+    MILESTONES = [
+      { id: "streak_3", name: "Warming Up", description: "3 days of vibe coding", streakRequired: 3, icon: "\u{1F331}", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_7", name: "Week Warrior", description: "7 days straight \u2014 that's a real habit", streakRequired: 7, icon: "\u26A1", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_14", name: "Fortnight Coder", description: "Two weeks of consistent vibe coding", streakRequired: 14, icon: "\u{1F680}", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_30", name: "Monthly Builder", description: "A full month of showing up every day", streakRequired: 30, icon: "\u{1F3C6}", rarity: "rare", freezeTokenReward: 1 },
+      { id: "streak_60", name: "Two Month Grind", description: "60 days \u2014 you're not messing around", streakRequired: 60, icon: "\u{1F48E}", rarity: "rare", freezeTokenReward: 1 },
+      { id: "streak_90", name: "Quarter Strong", description: "Three months of daily vibe coding", streakRequired: 90, icon: "\u{1F525}", rarity: "epic", freezeTokenReward: 1 },
+      { id: "streak_100", name: "Triple Digits", description: "100 days. This is who you are.", streakRequired: 100, icon: "\u{1F4AF}", rarity: "epic", freezeTokenReward: 0 },
+      { id: "streak_180", name: "Half Year Vibe", description: "Six months of consistent AI-assisted coding", streakRequired: 180, icon: "\u{1F31F}", rarity: "legendary", freezeTokenReward: 0 },
+      { id: "streak_365", name: "Year of the Vibe", description: "365 days. Legendary status achieved.", streakRequired: 365, icon: "\u{1F451}", rarity: "legendary", freezeTokenReward: 0 }
+    ];
+  }
+});
+
+// src/storage/friends-store.ts
+function getPublishEndpoint() {
+  if (VIBECHK_SERVER) return VIBECHK_SERVER;
+  return loadFriends().publishEndpoint ?? null;
+}
+function loadFriends() {
+  if (!(0, import_fs6.existsSync)(FRIENDS_PATH)) return { ...DEFAULT };
+  try {
+    return JSON.parse((0, import_fs6.readFileSync)(FRIENDS_PATH, "utf8"));
+  } catch {
+    return { ...DEFAULT };
+  }
+}
+function saveFriends(data) {
+  ensureDir();
+  (0, import_fs6.writeFileSync)(FRIENDS_PATH, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+}
+function getFriendByAlias(alias) {
+  const { friends } = loadFriends();
+  return friends.find((f) => f.alias.toLowerCase() === alias.toLowerCase()) ?? null;
+}
+function loadGistToken() {
+  if (!(0, import_fs6.existsSync)(GIST_TOKEN_PATH)) return null;
+  try {
+    const t = (0, import_fs6.readFileSync)(GIST_TOKEN_PATH, "utf8").trim();
+    return t || null;
+  } catch {
+    return null;
+  }
+}
+function saveGistToken(token) {
+  ensureDir();
+  (0, import_fs6.writeFileSync)(GIST_TOKEN_PATH, token, { encoding: "utf8", mode: 384 });
+}
+var import_fs6, DEFAULT;
+var init_friends_store = __esm({
+  "src/storage/friends-store.ts"() {
+    "use strict";
+    import_fs6 = require("fs");
+    init_paths();
+    DEFAULT = {
+      version: 1,
+      friends: [],
+      myPublishUrl: null,
+      gistId: null,
+      publishEndpoint: null
+    };
+  }
+});
+
+// src/commands/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  buildPublicProfile: () => buildPublicProfile,
+  runPublish: () => runPublish
+});
+function buildPublicProfile(username, currentStreak, longestStreak, lastActiveDate, totalCheckIns, badges, activeLast30) {
+  return {
+    version: 1,
+    username,
+    currentStreak,
+    longestStreak,
+    lastActiveDate,
+    consistencyLast30: Math.round(activeLast30 / 30 * 100),
+    totalCheckIns,
+    badges,
+    publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function runPublish(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const today = todayInTz(profile.timezone);
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 29);
+  const cutoff = thirtyDaysAgo.toISOString().slice(0, 10);
+  const activeLast30 = activity.filter((a) => a.date >= cutoff && a.date <= today).length;
+  const payload = buildPublicProfile(
+    profile.username,
+    streak.currentStreak,
+    streak.longestStreak,
+    streak.lastActivityDate,
+    streak.totalCheckIns,
+    badges.earned.map((b) => b.milestoneId),
+    activeLast30
+  );
+  const json = JSON.stringify(payload, null, 2);
+  if (options.stdout) {
+    console.log(json);
+    return null;
+  }
+  if (options.gist) {
+    return publishToGist(profile, json, options);
+  }
+  const endpoint = options.endpoint ? options.endpoint.replace(/\/$/, "") : getPublishEndpoint();
+  if (endpoint) {
+    return publishToEndpoint(profile, json, endpoint, options.silent ?? false);
+  }
+  return publishToGist(profile, json, options);
+}
+async function publishToEndpoint(profile, json, endpoint, silent) {
+  try {
+    if (!silent) process.stdout.write(import_chalk2.default.dim(`  Publishing to ${endpoint}...`));
+    const res = await fetch(`${endpoint}/api/users/${profile.id}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${profile.id}`,
+        "User-Agent": "vibechk/0.1.0"
+      },
+      body: json,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) throw new Error(`${res.status}: ${res.statusText}`);
+    const data = await res.json();
+    const friends = loadFriends();
+    friends.myPublishUrl = data.jsonUrl;
+    friends.publishEndpoint = endpoint;
+    saveFriends(friends);
+    if (!silent) {
+      console.log(import_chalk2.default.green(" \u2713"));
+      console.log("");
+      console.log(`  ${import_chalk2.default.bold("Your profile:")} ${import_chalk2.default.cyan(data.url)}`);
+      console.log("");
+      console.log(import_chalk2.default.dim("  Friends on the same server can add you by username:"));
+      console.log(import_chalk2.default.dim(`    vibechk friend add ${profile.username}`));
+      console.log("");
+      console.log(import_chalk2.default.dim("  Or share your direct URL:"));
+      console.log(import_chalk2.default.dim(`    vibechk friend add ${profile.username} ${data.jsonUrl}`));
+      console.log("");
+    }
+    return data.jsonUrl;
+  } catch (err) {
+    if (!silent) {
+      console.log(import_chalk2.default.red(` \u2717 ${err.message}`));
+      console.log(import_chalk2.default.dim("\n  Check that the endpoint is reachable and supports the vibechk API."));
+      console.log(import_chalk2.default.dim("  Use --gist to publish via GitHub Gist instead."));
+    }
+    return null;
+  }
+}
+async function publishToGist(profile, json, options) {
+  let token = options.token ?? loadGistToken();
+  if (!token) {
+    if (options.silent) return null;
+    console.log("");
+    console.log(import_chalk2.default.bold("  Publish your streak via GitHub Gist"));
+    console.log("");
+    console.log(import_chalk2.default.dim("  This creates a public JSON file that friends can subscribe to."));
+    console.log(import_chalk2.default.dim("  You need a GitHub personal access token with the `gist` scope."));
+    console.log("");
+    console.log(import_chalk2.default.dim("  1. Go to https://github.com/settings/tokens/new?scopes=gist"));
+    console.log(import_chalk2.default.dim('  2. Create a token with just the "gist" scope'));
+    console.log(import_chalk2.default.dim("  3. Paste it below"));
+    console.log("");
+    token = await (0, import_prompts.input)({ message: "GitHub token (gist scope):" });
+    if (!token.trim()) {
+      console.log(import_chalk2.default.dim("  Skipped. Run `vibechk publish` again when ready."));
+      return null;
+    }
+    saveGistToken(token.trim());
+    token = token.trim();
+  }
+  const friends = loadFriends();
+  try {
+    if (!options.silent) process.stdout.write(import_chalk2.default.dim("  Publishing to Gist..."));
+    const { gistId, rawUrl } = friends.gistId ? await updateGist(friends.gistId, json, token) : await createGist(json, token);
+    friends.gistId = gistId;
+    friends.myPublishUrl = rawUrl;
+    saveFriends(friends);
+    if (!options.silent) {
+      console.log(import_chalk2.default.green(" \u2713"));
+      console.log("");
+      console.log(`  ${import_chalk2.default.bold("Your friend URL:")} ${import_chalk2.default.cyan(rawUrl)}`);
+      console.log("");
+      console.log(import_chalk2.default.dim("  Share this URL with friends so they can follow your streak:"));
+      console.log(import_chalk2.default.dim(`    vibechk friend add ${profile.username} ${rawUrl}`));
+      console.log("");
+    }
+    return rawUrl;
+  } catch (err) {
+    if (!options.silent) {
+      console.log(import_chalk2.default.red(` \u2717 ${err.message}`));
+      if (err.message.includes("401") || err.message.includes("403")) {
+        console.log(import_chalk2.default.dim("\n  Token may be expired or missing the gist scope."));
+        console.log(import_chalk2.default.dim("  Delete ~/.vibechk/gist-token and run `vibechk publish` again."));
+      }
+    }
+    return null;
+  }
+}
+async function createGist(json, token) {
+  const res = await fetch(`${GIST_API}/gists`, {
+    method: "POST",
+    headers: gistHeaders(token),
+    body: JSON.stringify({
+      description: "vibechk \u2014 my vibe coding streak",
+      public: true,
+      files: { [GIST_FILENAME]: { content: json } }
+    }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${res.statusText}`);
+  const data = await res.json();
+  const login = data.owner?.login ?? "me";
+  const rawUrl = `https://gist.githubusercontent.com/${login}/${data.id}/raw/${GIST_FILENAME}`;
+  return { gistId: data.id, rawUrl, login };
+}
+async function updateGist(gistId, json, token) {
+  const res = await fetch(`${GIST_API}/gists/${gistId}`, {
+    method: "PATCH",
+    headers: gistHeaders(token),
+    body: JSON.stringify({
+      files: { [GIST_FILENAME]: { content: json } }
+    }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${res.statusText}`);
+  const data = await res.json();
+  const login = data.owner?.login ?? "me";
+  const rawUrl = `https://gist.githubusercontent.com/${login}/${data.id}/raw/${GIST_FILENAME}`;
+  return { gistId: data.id, rawUrl, login };
+}
+function gistHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "Content-Type": "application/json",
+    "User-Agent": "vibechk/0.1.0",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+}
+var import_chalk2, import_prompts, GIST_API, GIST_FILENAME;
+var init_publish = __esm({
+  "src/commands/publish.ts"() {
+    "use strict";
+    import_chalk2 = __toESM(require("chalk"), 1);
+    import_prompts = require("@inquirer/prompts");
+    init_profile_store();
+    init_streak_store();
+    init_activity_store();
+    init_badge_store();
+    init_friends_store();
+    init_date_utils();
+    GIST_API = "https://api.github.com";
+    GIST_FILENAME = "vibechk.json";
+  }
+});
+
+// src/commands/friend.ts
+var friend_exports = {};
+__export(friend_exports, {
+  runFriendAdd: () => runFriendAdd,
+  runFriendList: () => runFriendList,
+  runFriendPull: () => runFriendPull,
+  runFriendRemove: () => runFriendRemove
+});
+async function runFriendAdd(alias, url) {
+  const normalized = alias.trim().toLowerCase();
+  if (!normalized || !/^[\w\-\.]+$/.test(normalized)) {
+    console.error(import_chalk3.default.red("  Alias must be letters, numbers, - or _ only."));
+    process.exit(1);
+  }
+  const existing = getFriendByAlias(normalized);
+  if (existing) {
+    console.log(import_chalk3.default.yellow(`  Already following "${normalized}" at ${existing.url}`));
+    console.log(import_chalk3.default.dim(`  Use \`vibechk friend remove ${normalized}\` first to replace them.`));
+    return;
+  }
+  let resolvedUrl;
+  if (url?.trim()) {
+    resolvedUrl = url.trim();
+  } else {
+    const endpoint = getPublishEndpoint();
+    if (endpoint) {
+      resolvedUrl = `${endpoint}/u/${normalized}.json`;
+    } else {
+      console.error(import_chalk3.default.red("  No URL provided and no remote endpoint configured."));
+      console.log("");
+      console.log(import_chalk3.default.dim("  Provide the friend's profile URL:"));
+      console.log(import_chalk3.default.dim(`    vibechk friend add ${normalized} https://...`));
+      console.log("");
+      console.log(import_chalk3.default.dim("  Or set a remote endpoint via the VIBECHK_SERVER env var."));
+      process.exit(1);
+    }
+  }
+  const data = loadFriends();
+  const entry = {
+    alias: normalized,
+    url: resolvedUrl,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastFetchedAt: null,
+    cached: null
+  };
+  data.friends.push(entry);
+  saveFriends(data);
+  console.log(import_chalk3.default.green(`
+  \u2713 Added ${normalized}.`));
+  console.log(import_chalk3.default.dim("  Fetching their streak now...\n"));
+  const result = await fetchOneFriend(entry);
+  if (result.cached) {
+    printFriendRow(result, todayInTz(requireProfile().timezone), true);
+  } else {
+    console.log(import_chalk3.default.yellow(`  Could not fetch their data: ${result.lastFetchError ?? "unknown error"}`));
+    console.log(import_chalk3.default.dim("  Their data will be retried on the next `vibechk friend pull`."));
+  }
+  console.log("");
+}
+function runFriendRemove(alias) {
+  const normalized = alias.trim().toLowerCase();
+  const data = loadFriends();
+  const idx = data.friends.findIndex((f) => f.alias.toLowerCase() === normalized);
+  if (idx === -1) {
+    console.log(import_chalk3.default.yellow(`  No friend found with alias "${normalized}".`));
+    return;
+  }
+  data.friends.splice(idx, 1);
+  saveFriends(data);
+  console.log(import_chalk3.default.green(`
+  \u2713 Removed ${normalized}.
+`));
+}
+async function runFriendPull(options = {}) {
+  const data = loadFriends();
+  if (data.friends.length === 0) {
+    if (!options.quiet) {
+      console.log(import_chalk3.default.dim("\n  No friends added yet. Run `vibechk friend add <alias> <url>`.\n"));
+    }
+    return;
+  }
+  if (!options.quiet) process.stdout.write(import_chalk3.default.dim(`  Syncing ${data.friends.length} friend(s)...`));
+  const updated = await Promise.all(data.friends.map(fetchOneFriend));
+  data.friends = updated;
+  saveFriends(data);
+  if (!options.quiet) {
+    const ok = updated.filter((f) => f.cached !== null).length;
+    console.log(import_chalk3.default.green(` ${ok}/${updated.length} updated.
+`));
+  }
+}
+async function runFriendList() {
+  const profile = requireProfile();
+  const myStreak = loadStreak();
+  const today = todayInTz(profile.timezone);
+  let data = loadFriends();
+  if (data.friends.length === 0) {
+    console.log("");
+    console.log(import_chalk3.default.dim("  No friends yet.\n"));
+    console.log("  Share your streak URL with friends and add theirs:");
+    if (data.myPublishUrl) {
+      console.log("");
+      console.log(`  Your URL: ${import_chalk3.default.cyan(data.myPublishUrl)}`);
+    } else {
+      console.log(import_chalk3.default.dim("  Run `vibechk publish` to generate your shareable URL first."));
+    }
+    console.log(import_chalk3.default.dim("\n  vibechk friend add <alias> <their-url>\n"));
+    return;
+  }
+  const needsRefresh = data.friends.some((f) => isStale(f) || !f.lastFetchedAt);
+  if (needsRefresh) {
+    process.stdout.write(import_chalk3.default.dim(`  Refreshing ${data.friends.length} friend(s)...`));
+    const updated = await Promise.all(data.friends.map(fetchOneFriend));
+    data.friends = updated;
+    saveFriends(data);
+    const ok = updated.filter((f) => f.cached !== null).length;
+    console.log(import_chalk3.default.green(` ${ok}/${updated.length} updated.`));
+  }
+  console.log("");
+  const sorted = [...data.friends].sort((a, b) => {
+    const aToday = a.cached?.lastActiveDate === today ? 1 : 0;
+    const bToday = b.cached?.lastActiveDate === today ? 1 : 0;
+    if (bToday !== aToday) return bToday - aToday;
+    return (b.cached?.currentStreak ?? -1) - (a.cached?.currentStreak ?? -1);
+  });
+  const COL = { alias: 14, streak: 9, today: 8, consistency: 8, best: 7 };
+  const header = import_chalk3.default.dim(padR("  name", COL.alias)) + import_chalk3.default.dim(padR("streak", COL.streak)) + import_chalk3.default.dim(padR("today", COL.today)) + import_chalk3.default.dim(padR("30d%", COL.consistency)) + import_chalk3.default.dim("best");
+  console.log(header);
+  console.log(import_chalk3.default.dim("  " + "\u2500".repeat(48)));
+  for (const friend of sorted) {
+    printFriendRow(friend, today, false);
+  }
+  console.log(import_chalk3.default.dim("  " + "\u2500".repeat(48)));
+  const myCheckedIn = myStreak.lastActivityDate === today;
+  const myEmoji = myStreak.currentStreak >= 30 ? "\u{1F3C6}" : myStreak.currentStreak > 0 ? "\u{1F525}" : "\u{1F331}";
+  const myTodayLabel = myCheckedIn ? import_chalk3.default.green("\u2713") : import_chalk3.default.yellow("\u25CB");
+  console.log(
+    padR(`  ${import_chalk3.default.bold("you")}`, COL.alias) + padR(`${myEmoji} ${myStreak.currentStreak}d`, COL.streak) + padR(myTodayLabel, COL.today) + padR(import_chalk3.default.dim("\u2014"), COL.consistency) + import_chalk3.default.dim(`${myStreak.longestStreak}d`)
+  );
+  console.log("");
+  if (data.friends.some((f) => f.lastFetchedAt)) {
+    const oldest = data.friends.filter((f) => f.lastFetchedAt).sort((a, b) => a.lastFetchedAt.localeCompare(b.lastFetchedAt)).at(0);
+    const age = Math.round((Date.now() - new Date(oldest.lastFetchedAt).getTime()) / 6e4);
+    console.log(import_chalk3.default.dim(`  Last synced: ${age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`}`));
+  }
+  if (data.myPublishUrl) {
+    console.log(import_chalk3.default.dim(`  Your URL: ${data.myPublishUrl}`));
+  } else {
+    console.log(import_chalk3.default.dim("  Run `vibechk publish` so friends can follow you."));
+  }
+  console.log("");
+}
+async function fetchOneFriend(entry) {
+  try {
+    const res = await fetch(entry.url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { "User-Agent": "vibechk/0.1.0", Accept: "application/json" }
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const json = await res.json();
+    if (typeof json.username !== "string" || typeof json.currentStreak !== "number") {
+      throw new Error("Invalid profile format");
+    }
+    return {
+      ...entry,
+      lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastFetchError: void 0,
+      cached: json
+    };
+  } catch (err) {
+    return {
+      ...entry,
+      lastFetchError: err.message ?? "fetch failed"
+      // preserve old cached data — stale is better than empty
+    };
+  }
+}
+function printFriendRow(friend, today, verbose) {
+  const c = friend.cached;
+  const COL = { alias: 14, streak: 9, today: 8, consistency: 8 };
+  if (!c) {
+    const errLabel = friend.lastFetchError ? import_chalk3.default.red(`\u26A0 ${friend.lastFetchError.slice(0, 30)}`) : import_chalk3.default.dim("fetching...");
+    console.log(padR(`  ${import_chalk3.default.bold(friend.alias)}`, COL.alias) + errLabel);
+    return;
+  }
+  const streakEmoji = c.currentStreak >= 30 ? "\u{1F3C6}" : c.currentStreak > 0 ? "\u{1F525}" : "\u{1F331}";
+  const checkedInToday = c.lastActiveDate === today;
+  const todayLabel = checkedInToday ? import_chalk3.default.green("\u2713") : import_chalk3.default.dim("\u25CB");
+  const consistencyColor = c.consistencyLast30 >= 80 ? import_chalk3.default.green : c.consistencyLast30 >= 50 ? import_chalk3.default.yellow : import_chalk3.default.red;
+  const prevNote = c.longestStreak > c.currentStreak && c.longestStreak > 0 ? import_chalk3.default.dim(` prev ${c.longestStreak}d`) : "";
+  const staleNote = isStale(friend) ? import_chalk3.default.yellow(" \u26A0") : "";
+  const theirName = c.username !== friend.alias ? import_chalk3.default.dim(` (${c.username})`) : "";
+  if (verbose) {
+    console.log(`  ${streakEmoji} ${import_chalk3.default.bold(friend.alias)}${theirName}: ${import_chalk3.default.yellow.bold(c.currentStreak + " days")}`);
+    console.log(`     Today: ${checkedInToday ? import_chalk3.default.green("checked in \u2713") : import_chalk3.default.dim("not yet \u25CB")}`);
+    console.log(`     30-day consistency: ${consistencyColor(c.consistencyLast30 + "%")}`);
+    console.log(`     Best streak: ${c.longestStreak}d   Check-ins: ${c.totalCheckIns}`);
+    const milestones = getAllMilestones();
+    const earned = c.badges.map((id) => milestones.find((m) => m.id === id)?.icon ?? "").filter(Boolean);
+    if (earned.length) console.log(`     Badges: ${earned.join(" ")}`);
+  } else {
+    console.log(
+      padR(`  ${import_chalk3.default.bold(friend.alias)}${theirName}`, COL.alias) + padR(`${streakEmoji} ${c.currentStreak}d${prevNote}`, COL.streak) + padR(todayLabel, COL.today) + padR(consistencyColor(c.consistencyLast30 + "%"), COL.consistency) + import_chalk3.default.dim(c.longestStreak + "d") + staleNote
+    );
+  }
+}
+function isStale(friend) {
+  if (!friend.lastFetchedAt) return false;
+  const ageMs = Date.now() - new Date(friend.lastFetchedAt).getTime();
+  return ageMs > STALE_HOURS * 3600 * 1e3;
+}
+function padR(s, width) {
+  const plainLen = s.replace(/\x1B\[[0-9;]*m/g, "").length;
+  const pad = Math.max(0, width - plainLen);
+  return s + " ".repeat(pad);
+}
+var import_chalk3, FETCH_TIMEOUT_MS, STALE_HOURS;
+var init_friend = __esm({
+  "src/commands/friend.ts"() {
+    "use strict";
+    import_chalk3 = __toESM(require("chalk"), 1);
+    init_friends_store();
+    init_profile_store();
+    init_streak_store();
+    init_date_utils();
+    init_milestone_checker();
+    FETCH_TIMEOUT_MS = 8e3;
+    STALE_HOURS = 25;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  checkIn: () => runCheckIn,
+  exportData: () => runExport,
+  getLeaderboard: () => getLeaderboard,
+  getProfile: () => loadProfile,
+  getStreak: () => getStreak
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/commands/check-in.ts
+var import_chalk4 = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var import_prompts2 = require("@inquirer/prompts");
+var import_uuid = require("uuid");
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+init_badge_store();
+init_date_utils();
+
+// src/core/streak-calculator.ts
+init_date_utils();
+var GRACE_COOLDOWN_DAYS = 14;
+var MAX_FREEZE_TOKENS = 5;
+function calculateStreakImpact(streak, today, useFreeze = false) {
+  const { lastActivityDate, currentStreak, graceUsedAt, freezeTokens } = streak;
+  if (!lastActivityDate) {
+    return { action: "started", newStreak: 1 };
+  }
+  const daysDiff = daysBetween(lastActivityDate, today);
+  if (daysDiff === 0) {
+    return { action: "already_checked_in", newStreak: currentStreak };
+  }
+  if (daysDiff === 1) {
+    return { action: "continued", newStreak: currentStreak + 1 };
+  }
+  if (daysDiff === 2) {
+    const graceAvailable = !graceUsedAt || daysBetween(graceUsedAt, today) >= GRACE_COOLDOWN_DAYS;
+    if (graceAvailable) {
+      return { action: "grace", newStreak: currentStreak + 1, usedGrace: true };
+    }
+    if (useFreeze && freezeTokens > 0) {
+      return { action: "frozen", newStreak: currentStreak + 1, usedFreeze: true };
+    }
+    if (freezeTokens > 0 && !useFreeze) {
+      return {
+        action: "broken",
+        newStreak: 1,
+        previousStreak: currentStreak
+      };
+    }
+  }
+  return {
+    action: "broken",
+    newStreak: 1,
+    previousStreak: currentStreak
+  };
+}
+function applyStreakImpact(current, impact, today, nowIso2) {
+  const newStreak = impact.newStreak;
+  const newLongest = Math.max(current.longestStreak, newStreak);
+  let freezeTokens = current.freezeTokens;
+  if (impact.usedFreeze) {
+    freezeTokens = Math.max(0, freezeTokens - 1);
+  }
+  let graceUsedAt = current.graceUsedAt;
+  if (impact.usedGrace) {
+    graceUsedAt = today;
+  }
+  let status = "active";
+  if (impact.action === "frozen") status = "frozen";
+  else if (impact.action === "grace") status = "grace";
+  else if (impact.action === "broken") status = "broken";
+  else if (impact.action === "started" || impact.action === "continued" || impact.action === "already_checked_in") status = "active";
+  return {
+    ...current,
+    currentStreak: newStreak,
+    longestStreak: newLongest,
+    lastActivityDate: impact.action === "already_checked_in" ? current.lastActivityDate : today,
+    lastCheckInAt: nowIso2,
+    freezeTokens,
+    totalCheckIns: impact.action === "already_checked_in" ? current.totalCheckIns : current.totalCheckIns + 1,
+    graceUsedAt,
+    status
+  };
+}
+function addFreezeTokens(current, toAdd) {
+  return Math.min(MAX_FREEZE_TOKENS, current + toAdd);
+}
+
+// src/commands/check-in.ts
+init_milestone_checker();
+
+// src/detection/claude-code.ts
+var import_fs4 = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+var import_child_process = require("child_process");
+init_date_utils();
+var CLAUDE_PROJECTS_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".config", "claude", "projects");
+async function detectClaudeCodeUsage(date, timezone3) {
+  const ccusageResult = tryCcusageCli(date);
+  if (ccusageResult) return ccusageResult;
+  return scanJsonlFiles(date, timezone3);
+}
+function tryCcusageCli(date) {
+  try {
+    const output = (0, import_child_process.execSync)(`ccusage daily --date ${date} --json 2>/dev/null`, {
+      timeout: 5e3,
+      encoding: "utf8"
+    });
+    const data = JSON.parse(output);
+    const entries = Array.isArray(data) ? data : [data];
+    const total = entries.reduce((sum, e) => sum + (e.totalTokens || e.tokens || 0), 0);
+    if (total > 0) {
+      return {
+        detected: true,
+        source: "ccusage-cli",
+        agentData: {
+          sessions: entries.length,
+          tokensApprox: total,
+          models: [...new Set(entries.map((e) => e.model).filter(Boolean))]
+        }
+      };
+    }
+    return { detected: false, source: "ccusage-cli" };
+  } catch {
+    return null;
+  }
+}
+function scanJsonlFiles(date, timezone3) {
+  if (!(0, import_fs4.existsSync)(CLAUDE_PROJECTS_DIR)) {
+    return { detected: false, source: "none" };
+  }
+  let sessionCount = 0;
+  let tokenCount = 0;
+  try {
+    const projectDirs = (0, import_fs4.readdirSync)(CLAUDE_PROJECTS_DIR);
+    for (const project of projectDirs) {
+      const projectPath = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, project);
+      if (!(0, import_fs4.statSync)(projectPath).isDirectory()) continue;
+      const files = (0, import_fs4.readdirSync)(projectPath).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filePath = (0, import_path2.join)(projectPath, file);
+        const content = (0, import_fs4.readFileSync)(filePath, "utf8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        let fileHasActivity = false;
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            const ts = entry.timestamp || entry.createdAt || entry.created_at;
+            if (!ts) continue;
+            const entryDate = dateInTz(ts, timezone3);
+            if (entryDate === date) {
+              fileHasActivity = true;
+              if (typeof entry.usage?.input_tokens === "number") {
+                tokenCount += entry.usage.input_tokens + (entry.usage.output_tokens || 0);
+              } else if (typeof entry.content === "string") {
+                tokenCount += Math.floor(entry.content.length / 4);
+              }
+            }
+          } catch {
+          }
+        }
+        if (fileHasActivity) sessionCount++;
+      }
+    }
+  } catch {
+    return { detected: false, source: "none" };
+  }
+  if (sessionCount > 0) {
+    return {
+      detected: true,
+      source: "jsonl-scan",
+      agentData: { sessions: sessionCount, tokensApprox: tokenCount }
+    };
+  }
+  return { detected: false, source: "jsonl-scan" };
+}
+
+// src/detection/git.ts
+var import_child_process2 = require("child_process");
+var import_fs5 = require("fs");
+var import_path3 = require("path");
+var import_os3 = require("os");
+async function detectGitActivity(date, timezone3, watchedRepos) {
+  const repoPaths = watchedRepos.length > 0 ? watchedRepos.map(expandHome) : discoverRepos();
+  for (const repoPath of repoPaths) {
+    if (!(0, import_fs5.existsSync)((0, import_path3.join)(repoPath, ".git"))) continue;
+    try {
+      const since = `${date} 00:00:00`;
+      const until = `${date} 23:59:59`;
+      const result = (0, import_child_process2.execSync)(
+        `git -C ${JSON.stringify(repoPath)} log --oneline --after=${JSON.stringify(since)} --before=${JSON.stringify(until)} 2>/dev/null`,
+        { encoding: "utf8", timeout: 5e3, env: { ...process.env, TZ: timezone3 } }
+      ).trim();
+      if (result.length > 0) {
+        return { detected: true, repoPath };
+      }
+    } catch {
+    }
+  }
+  return { detected: false };
+}
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return (0, import_path3.join)((0, import_os3.homedir)(), p.slice(2));
+  }
+  return p;
+}
+function discoverRepos() {
+  const candidates = [
+    (0, import_os3.homedir)(),
+    (0, import_path3.join)((0, import_os3.homedir)(), "code"),
+    (0, import_path3.join)((0, import_os3.homedir)(), "projects"),
+    (0, import_path3.join)((0, import_os3.homedir)(), "dev"),
+    (0, import_path3.join)((0, import_os3.homedir)(), "workspace"),
+    (0, import_path3.join)((0, import_os3.homedir)(), "src")
+  ];
+  const repos = [];
+  for (const dir of candidates) {
+    if (!(0, import_fs5.existsSync)(dir)) continue;
+    if ((0, import_fs5.existsSync)((0, import_path3.join)(dir, ".git"))) {
+      repos.push(dir);
+      continue;
+    }
+    try {
+      const entries = (0, import_fs5.readdirSync)(dir);
+      for (const entry of entries) {
+        const full = (0, import_path3.join)(dir, entry);
+        try {
+          if ((0, import_fs5.statSync)(full).isDirectory() && (0, import_fs5.existsSync)((0, import_path3.join)(full, ".git"))) {
+            repos.push(full);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (repos.length >= 50) break;
+  }
+  return repos;
+}
+
+// src/detection/index.ts
+async function detectTodaySession(date, timezone3, enabledSources, watchedRepos = []) {
+  if (enabledSources.includes("claude-code")) {
+    const result = await detectClaudeCodeUsage(date, timezone3);
+    if (result.detected) {
+      return { detected: true, source: "claude-code", agentData: result.agentData };
+    }
+  }
+  if (enabledSources.includes("git")) {
+    const result = await detectGitActivity(date, timezone3, watchedRepos);
+    if (result.detected) {
+      return { detected: true, source: "git" };
+    }
+  }
+  return { detected: false, source: "manual" };
+}
+
+// src/sync/client.ts
+function makeHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    "User-Agent": "vibechk/0.1.0"
+  };
+}
+function buildSyncPayload(profile, streak, badges) {
+  const totalFreezesUsed = streak.totalCheckIns - streak.currentStreak;
+  return {
+    userId: profile.id,
+    username: profile.username,
+    currentStreak: streak.currentStreak,
+    longestStreak: streak.longestStreak,
+    lastActiveDate: streak.lastActivityDate,
+    freezesUsed: totalFreezesUsed > 0 ? totalFreezesUsed : 0,
+    badges: badges.earned.map((b) => b.milestoneId),
+    shareOnLeaderboard: profile.preferences.shareOnLeaderboard
+  };
+}
+async function pushStreak(profile, streak, badges) {
+  const sync = profile.cloudSync;
+  if (!sync) return false;
+  const payload = buildSyncPayload(profile, streak, badges);
+  try {
+    const response = await fetch(`${sync.endpoint}/users/${profile.id}`, {
+      method: "PUT",
+      headers: makeHeaders(sync.apiKey),
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(8e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/ui/renderer.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_boxen = __toESM(require("boxen"), 1);
+var import_dayjs2 = __toESM(require("dayjs"), 1);
+var import_utc2 = __toESM(require("dayjs/plugin/utc.js"), 1);
+var import_timezone2 = __toESM(require("dayjs/plugin/timezone.js"), 1);
+init_date_utils();
+init_milestone_checker();
+import_dayjs2.default.extend(import_utc2.default);
+import_dayjs2.default.extend(import_timezone2.default);
+function renderCheckIn(action, streak, previousStreak, newMilestones = [], quiet = false) {
+  if (quiet) return "";
+  const lines = [];
+  if (action === "already_checked_in") {
+    lines.push(import_chalk.default.green(`\u2713 Already checked in today \u2014 ${streak}-day streak protected.`));
+    return lines.join("\n");
+  }
+  if (action === "broken") {
+    if (previousStreak && previousStreak > 0) {
+      lines.push(import_chalk.default.cyan(`Your ${previousStreak}-day streak was real.`));
+      lines.push(import_chalk.default.dim(`  Every day you showed up counted. That doesn't disappear.`));
+      lines.push(``);
+    }
+    lines.push(import_chalk.default.yellow(`\u{1F331} Day 1. Fresh start.`));
+    return (0, import_boxen.default)(lines.join("\n"), { padding: 1, borderColor: "cyan", borderStyle: "round" });
+  }
+  const actionEmoji = action === "started" ? "\u{1F331}" : action === "grace" ? "\u2728" : action === "frozen" ? "\u2744\uFE0F" : "\u{1F525}";
+  const actionLabel = action === "started" ? "Day 1! The journey begins." : action === "grace" ? `Grace period used \u2014 streak preserved!` : action === "frozen" ? `Freeze token used \u2014 streak preserved!` : `Day ${streak}! Streak protected.`;
+  lines.push(`${actionEmoji} ${import_chalk.default.bold(actionLabel)}`);
+  lines.push(import_chalk.default.dim(`\u{1F525} ${streak}-day streak`));
+  return lines.join("\n");
+}
+function renderMilestone(milestone, streak) {
+  const border = milestone.rarity === "legendary" ? "double" : milestone.rarity === "epic" ? "bold" : "round";
+  const color = milestone.rarity === "legendary" ? "magentaBright" : milestone.rarity === "epic" ? "yellowBright" : "cyan";
+  const lines = [
+    import_chalk.default.bold.yellow("\u2B50 ACHIEVEMENT UNLOCKED!"),
+    ``,
+    `${milestone.icon}  ${import_chalk.default.bold(milestone.name)}`,
+    import_chalk.default.dim(milestone.description),
+    ``,
+    import_chalk.default.green(`${streak}-day streak reached!`)
+  ];
+  if (milestone.freezeTokenReward > 0) {
+    lines.push(``);
+    lines.push(import_chalk.default.cyan(`+ ${milestone.freezeTokenReward} freeze token earned!`));
+  }
+  return (0, import_boxen.default)(lines.join("\n"), {
+    padding: 1,
+    borderStyle: border,
+    borderColor: color,
+    title: ` ${milestone.rarity.toUpperCase()} `,
+    titleAlignment: "center"
+  });
+}
+
+// src/web/server.ts
+var import_http = require("http");
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+
+// src/storage/leaderboard-cache.ts
+init_atomic();
+init_paths();
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function loadLeaderboardCache() {
+  return readJson(LEADERBOARD_CACHE_PATH);
+}
+
+// src/web/server.ts
+init_milestone_checker();
+init_date_utils();
+async function startDashboard(autoClose = true) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const leaderboard = loadLeaderboardCache();
+  const milestones = getAllMilestones();
+  const today = todayInTz(profile.timezone);
+  const dashboardData = {
+    profile: { username: profile.username, timezone: profile.timezone },
+    streak,
+    recentActivity: activity.slice(-90),
+    badges: badges.earned,
+    milestones,
+    leaderboard,
+    today
+  };
+  const html = generateDashboardHtml(dashboardData);
+  const server = (0, import_http.createServer)((req, res) => {
+    if (req.url === "/data") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(dashboardData));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+    if (autoClose) {
+      setTimeout(() => server.close(), 500);
+    }
+  });
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const url = `http://127.0.0.1:${addr.port}`;
+      resolve(url);
+    });
+  });
+}
+function generateDashboardHtml(data) {
+  const { profile, streak, recentActivity, badges, milestones, leaderboard, today } = data;
+  const activityMap = {};
+  for (const a of recentActivity) {
+    activityMap[a.date] = { checked: true, frozen: a.isFrozen, grace: a.isGrace, source: a.source };
+  }
+  const cells = [];
+  for (let i = 89; i >= 0; i--) {
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() - i);
+    const dateStr = d.toISOString().slice(0, 10);
+    const act = activityMap[dateStr];
+    const isToday = dateStr === today;
+    let cls = "day-empty";
+    if (act?.frozen) cls = "day-frozen";
+    else if (act?.grace) cls = "day-grace";
+    else if (act?.checked) cls = "day-active";
+    if (isToday) cls += " day-today";
+    cells.push(`<div class="day ${cls}" title="${dateStr}"></div>`);
+  }
+  const lbRows = leaderboard ? leaderboard.entries.slice(0, 20).map((e) => {
+    const isYou = e.userId === profile.id || e.displayName === profile.username;
+    const badges_icons = (e.badges || []).slice(0, 3).map((id) => milestones.find((m) => m.id === id)?.icon ?? "").join("");
+    return `<tr class="${isYou ? "you" : ""}">
+          <td class="rank">${e.rank ?? "?"}</td>
+          <td class="name">${isYou ? "\u2192 " : ""}${e.displayName}</td>
+          <td class="streak">${e.currentStreak}d</td>
+          <td class="longest">${e.longestStreak}d</td>
+          <td class="badges">${badges_icons}${e.freezesUsed > 0 ? `<span class="freeze-used">${e.freezesUsed}\u2744</span>` : ""}</td>
+        </tr>`;
+  }).join("\n") : '<tr><td colspan="5" class="empty">No leaderboard data \u2014 run <code>vibechk sync</code></td></tr>';
+  const earnedIds = new Set(badges.map((b) => b.milestoneId));
+  const milestoneCards = milestones.map((m) => {
+    const earned = earnedIds.has(m.id);
+    return `<div class="milestone-card ${earned ? "earned" : "locked"} rarity-${m.rarity}">
+      <div class="ms-icon">${earned ? m.icon : "\u{1F512}"}</div>
+      <div class="ms-name">${m.name}</div>
+      <div class="ms-req">${m.streakRequired}d</div>
+    </div>`;
+  }).join("\n");
+  const isCheckedInToday = streak.lastActivityDate === today;
+  const streakEmoji = streak.currentStreak >= 100 ? "\u{1F4AF}" : streak.currentStreak >= 30 ? "\u{1F3C6}" : "\u{1F525}";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>vibechk \u2014 ${profile.username}</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --surface: #161b22;
+      --border: #30363d;
+      --text: #e6edf3;
+      --muted: #8b949e;
+      --accent: #f78166;
+      --green: #3fb950;
+      --yellow: #d29922;
+      --blue: #58a6ff;
+      --frozen: #79c0ff;
+      --grace: #ffa657;
+      --purple: #bc8cff;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+      padding: 24px;
+    }
+    h1, h2, h3 { font-weight: 600; }
+    .container { max-width: 900px; margin: 0 auto; }
+    header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      margin-bottom: 32px;
+    }
+    header .logo {
+      font-size: 1.5rem;
+      font-weight: 700;
+      background: linear-gradient(135deg, #f78166, #d29922);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+    header .username {
+      color: var(--muted);
+      font-size: 0.9rem;
+    }
+
+    /* Streak hero card */
+    .streak-hero {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 28px 32px;
+      margin-bottom: 24px;
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 16px;
+      align-items: center;
+    }
+    .streak-number {
+      font-size: 4rem;
+      font-weight: 700;
+      line-height: 1;
+      color: var(--accent);
+    }
+    .streak-label {
+      color: var(--muted);
+      font-size: 0.9rem;
+      margin-top: 4px;
+    }
+    .streak-stats {
+      display: flex;
+      gap: 24px;
+    }
+    .stat { text-align: center; }
+    .stat-value { font-size: 1.5rem; font-weight: 600; color: var(--blue); }
+    .stat-label { font-size: 0.75rem; color: var(--muted); margin-top: 2px; }
+
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 12px;
+      border-radius: 20px;
+      font-size: 0.8rem;
+      font-weight: 500;
+      margin-top: 8px;
+    }
+    .status-badge.protected { background: rgba(63, 185, 80, 0.15); color: var(--green); border: 1px solid rgba(63,185,80,0.3); }
+    .status-badge.at-risk { background: rgba(210, 153, 34, 0.15); color: var(--yellow); border: 1px solid rgba(210,153,34,0.3); }
+    .status-badge.broken { background: rgba(247, 129, 102, 0.15); color: var(--accent); border: 1px solid rgba(247,129,102,0.3); }
+
+    .freeze-tokens {
+      font-size: 1.2rem;
+      margin-top: 8px;
+    }
+
+    /* Progress bar */
+    .progress-section {
+      margin-top: 16px;
+      grid-column: 1 / -1;
+    }
+    .progress-label {
+      font-size: 0.75rem;
+      color: var(--muted);
+      margin-bottom: 6px;
+    }
+    .progress-bar-track {
+      height: 8px;
+      background: var(--border);
+      border-radius: 4px;
+      overflow: hidden;
+    }
+    .progress-bar-fill {
+      height: 100%;
+      border-radius: 4px;
+      background: linear-gradient(90deg, #f78166, #d29922);
+      transition: width 0.6s ease;
+    }
+
+    /* Calendar grid */
+    .section {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 20px 24px;
+      margin-bottom: 24px;
+    }
+    .section h2 {
+      font-size: 0.85rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--muted);
+      margin-bottom: 16px;
+    }
+    .calendar-grid {
+      display: grid;
+      grid-template-columns: repeat(13, 1fr);
+      gap: 3px;
+    }
+    .day {
+      aspect-ratio: 1;
+      border-radius: 3px;
+      cursor: default;
+      transition: transform 0.1s;
+    }
+    .day:hover { transform: scale(1.3); }
+    .day-empty { background: var(--border); }
+    .day-active { background: var(--green); }
+    .day-frozen { background: var(--frozen); }
+    .day-grace { background: var(--grace); }
+    .day-today { outline: 2px solid var(--text); outline-offset: 1px; }
+    .calendar-legend {
+      display: flex;
+      gap: 16px;
+      margin-top: 12px;
+      flex-wrap: wrap;
+    }
+    .legend-item {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 0.75rem;
+      color: var(--muted);
+    }
+    .legend-dot {
+      width: 12px;
+      height: 12px;
+      border-radius: 3px;
+    }
+
+    /* Leaderboard */
+    table { width: 100%; border-collapse: collapse; }
+    th, td { padding: 8px 12px; text-align: left; font-size: 0.875rem; }
+    th { color: var(--muted); font-weight: 500; border-bottom: 1px solid var(--border); }
+    tr.you { background: rgba(88, 166, 255, 0.08); }
+    tr.you td { color: var(--blue); font-weight: 600; }
+    td.rank { color: var(--muted); width: 40px; }
+    td.streak { color: var(--accent); font-weight: 600; }
+    td.longest { color: var(--muted); }
+    td.badges { font-size: 1rem; letter-spacing: 2px; }
+    td.empty { color: var(--muted); font-style: italic; padding: 20px 12px; }
+    .freeze-used { font-size: 0.7rem; color: var(--frozen); margin-left: 4px; }
+    tr:hover:not(.you) { background: rgba(255,255,255,0.03); }
+
+    /* Milestones */
+    .milestones-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
+      gap: 12px;
+    }
+    .milestone-card {
+      text-align: center;
+      padding: 16px 8px;
+      border-radius: 10px;
+      border: 1px solid var(--border);
+      transition: transform 0.2s;
+    }
+    .milestone-card:hover { transform: translateY(-2px); }
+    .milestone-card.locked { opacity: 0.35; filter: grayscale(1); }
+    .milestone-card.earned { border-color: transparent; }
+    .milestone-card.rarity-common.earned { background: rgba(63,185,80,0.1); border-color: rgba(63,185,80,0.3); }
+    .milestone-card.rarity-rare.earned { background: rgba(88,166,255,0.1); border-color: rgba(88,166,255,0.3); }
+    .milestone-card.rarity-epic.earned { background: rgba(210,153,34,0.1); border-color: rgba(210,153,34,0.3); }
+    .milestone-card.rarity-legendary.earned { background: rgba(188,140,255,0.1); border-color: rgba(188,140,255,0.3); }
+    .ms-icon { font-size: 1.75rem; margin-bottom: 6px; }
+    .ms-name { font-size: 0.7rem; font-weight: 600; color: var(--text); }
+    .ms-req { font-size: 0.65rem; color: var(--muted); margin-top: 2px; }
+
+    /* Animations */
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.7; } }
+    .streak-number { animation: ${isCheckedInToday ? "none" : "pulse 2s ease-in-out infinite"}; }
+
+    @keyframes celebrate {
+      0% { transform: scale(1); }
+      50% { transform: scale(1.05); }
+      100% { transform: scale(1); }
+    }
+    .celebrate { animation: celebrate 0.5s ease-in-out; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <div class="logo">vibechk</div>
+      <div class="username">@${profile.username}</div>
+    </header>
+
+    <!-- Streak Hero -->
+    <div class="streak-hero" id="heroCard">
+      <div>
+        <div class="streak-number">${streakEmoji} ${streak.currentStreak}</div>
+        <div class="streak-label">day streak</div>
+        <div class="status-badge ${isCheckedInToday ? "protected" : streak.currentStreak > 0 ? "at-risk" : "broken"}">
+          ${isCheckedInToday ? "\u2713 Protected for today" : streak.currentStreak > 0 ? "\u25CB Check in to protect" : "\u25CF Start your streak"}
+        </div>
+        <div class="freeze-tokens" title="Freeze tokens available">
+          ${"\u2744\uFE0F".repeat(streak.freezeTokens)}${streak.freezeTokens === 0 ? '<span style="color:var(--muted);font-size:0.8rem">No freezes</span>' : ""}
+        </div>
+      </div>
+      <div class="streak-stats">
+        <div class="stat">
+          <div class="stat-value">${streak.longestStreak}d</div>
+          <div class="stat-label">Longest</div>
+        </div>
+        <div class="stat">
+          <div class="stat-value">${streak.totalCheckIns}</div>
+          <div class="stat-label">Total days</div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Activity Calendar -->
+    <div class="section">
+      <h2>Last 90 Days</h2>
+      <div class="calendar-grid">
+        ${cells.join("\n        ")}
+      </div>
+      <div class="calendar-legend">
+        <div class="legend-item"><div class="legend-dot" style="background:var(--green)"></div> Coded</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--frozen)"></div> Frozen</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--grace)"></div> Grace</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--border)"></div> Missed</div>
+      </div>
+    </div>
+
+    <!-- Leaderboard -->
+    <div class="section">
+      <h2>Leaderboard</h2>
+      ${leaderboard ? `<table>
+        <thead>
+          <tr>
+            <th>Rank</th>
+            <th>Name</th>
+            <th>Streak</th>
+            <th>Longest</th>
+            <th>Badges</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${lbRows}
+        </tbody>
+      </table>` : '<p style="color:var(--muted);font-size:0.875rem">No leaderboard data yet. Configure cloud sync to compare with friends.</p>'}
+    </div>
+
+    <!-- Milestones -->
+    <div class="section">
+      <h2>Milestones</h2>
+      <div class="milestones-grid">
+        ${milestoneCards}
+      </div>
+    </div>
+  </div>
+
+  <script>
+    // Celebrate if just reached a new milestone
+    const urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.get('celebrate')) {
+      document.getElementById('heroCard').classList.add('celebrate');
+    }
+
+    // Auto-refresh every 60s
+    setTimeout(() => window.location.reload(), 60000);
+  </script>
+</body>
+</html>`;
+}
+
+// src/commands/check-in.ts
+var import_open = __toESM(require("open"), 1);
+async function runCheckIn(options = {}) {
+  const profile = requireProfile();
+  const today = todayInTz(profile.timezone);
+  const now = nowIso();
+  let source = options.source ?? "manual";
+  let agentData = void 0;
+  if (!options.source || options.source === "claude-code") {
+    const spinner = (0, import_ora.default)({ text: "Detecting coding session\u2026", isSilent: options.quiet }).start();
+    const detection = await detectTodaySession(
+      today,
+      profile.timezone,
+      profile.preferences.sessionSources,
+      profile.preferences.watchedRepos ?? []
+    );
+    spinner.stop();
+    if (detection.detected) {
+      source = detection.source;
+      agentData = detection.agentData;
+    } else if (options.noInteractive) {
+      if (!options.quiet) {
+        console.log(import_chalk4.default.dim("  No coding session detected today. Streak unchanged."));
+      }
+      const currentStreak2 = loadStreak();
+      return {
+        action: "skipped",
+        streak: currentStreak2.currentStreak,
+        previousStreak: void 0,
+        newMilestones: [],
+        freezeTokensRemaining: currentStreak2.freezeTokens,
+        agentData: void 0
+      };
+    } else if (!options.quiet) {
+      const doManual = await (0, import_prompts2.confirm)({
+        message: import_chalk4.default.dim("No AI session detected. Check in manually anyway?"),
+        default: true
+      });
+      if (!doManual) {
+        console.log(import_chalk4.default.dim("  Skipped. Run vibechk again when you've coded today."));
+        process.exit(0);
+      }
+      source = "manual";
+    }
+  }
+  const currentStreak = loadStreak();
+  const currentBadges = loadBadges();
+  let useFreeze = options.autoFreeze ?? false;
+  const impact = calculateStreakImpact(currentStreak, today, false);
+  if (impact.action === "broken" && impact.previousStreak && impact.previousStreak > 0 && currentStreak.freezeTokens > 0 && !options.noInteractive && !options.quiet) {
+    const daysDiff = currentStreak.lastActivityDate ? Math.abs(new Date(today).getTime() - new Date(currentStreak.lastActivityDate).getTime()) / 864e5 : 99;
+    if (daysDiff <= 2) {
+      console.log(import_chalk4.default.yellow(`
+  Missed yesterday. You have ${currentStreak.freezeTokens} freeze token(s).`));
+      useFreeze = await (0, import_prompts2.confirm)({
+        message: `Use a freeze token to preserve your ${impact.previousStreak}-day streak?`,
+        default: true
+      });
+    }
+  }
+  const finalImpact = calculateStreakImpact(currentStreak, today, useFreeze);
+  const newStreakRecord = applyStreakImpact(currentStreak, finalImpact, today, now);
+  const newMilestones = checkNewMilestones(newStreakRecord.currentStreak, currentBadges);
+  const newBadges = createEarnedBadges(newMilestones, newStreakRecord.currentStreak, now);
+  const freezeReward = totalFreezeReward(newMilestones);
+  if (freezeReward > 0) {
+    newStreakRecord.freezeTokens = addFreezeTokens(newStreakRecord.freezeTokens, freezeReward);
+  }
+  if (!options.dryRun) {
+    saveStreak(newStreakRecord);
+    appendBadges(newBadges);
+    if (finalImpact.action !== "already_checked_in") {
+      appendActivity({
+        date: today,
+        checkedInAt: now,
+        source,
+        isFrozen: finalImpact.action === "frozen",
+        isGrace: finalImpact.action === "grace",
+        sessionId: (0, import_uuid.v4)(),
+        agentData,
+        notes: options.notes
+      });
+    }
+  }
+  if (!options.quiet && !options.json) {
+    console.log("");
+    console.log(renderCheckIn(finalImpact.action, newStreakRecord.currentStreak, finalImpact.previousStreak, newMilestones));
+    for (const milestone of newMilestones) {
+      console.log("");
+      console.log(renderMilestone(milestone, newStreakRecord.currentStreak));
+    }
+    console.log("");
+  } else if (options.json) {
+    const result = {
+      action: finalImpact.action,
+      streak: newStreakRecord.currentStreak,
+      previousStreak: finalImpact.previousStreak,
+      newMilestones: newMilestones.map((m) => m.id),
+      freezeTokensRemaining: newStreakRecord.freezeTokens
+    };
+    console.log(JSON.stringify(result));
+  }
+  const shouldOpenBrowser = options.openDashboard || newMilestones.length > 0 && !options.quiet;
+  if (shouldOpenBrowser && !options.dryRun) {
+    try {
+      const url = await startDashboard(true);
+      const celebrateUrl = newMilestones.length > 0 ? `${url}?celebrate=1` : url;
+      await (0, import_open.default)(celebrateUrl);
+      if (!options.quiet) console.log(import_chalk4.default.dim(`  Opening dashboard in browser\u2026`));
+    } catch {
+    }
+  }
+  if (!options.dryRun && profile.cloudSync) {
+    const badges = loadBadges();
+    pushStreak(profile, newStreakRecord, badges).catch(() => {
+    });
+  }
+  if (!options.dryRun && options.noInteractive && finalImpact.action !== "already_checked_in") {
+    Promise.resolve().then(() => (init_publish(), publish_exports)).then(({ runPublish: runPublish2 }) => runPublish2({ silent: true })).catch(() => {
+    });
+    Promise.resolve().then(() => (init_friend(), friend_exports)).then(({ runFriendPull: runFriendPull2 }) => runFriendPull2({ quiet: true })).catch(() => {
+    });
+  }
+  return {
+    action: finalImpact.action,
+    streak: newStreakRecord.currentStreak,
+    previousStreak: finalImpact.previousStreak,
+    newMilestones,
+    freezeTokensRemaining: newStreakRecord.freezeTokens,
+    agentData
+  };
+}
+
+// src/commands/status.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_date_utils();
+var import_open2 = __toESM(require("open"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
+function getStreak() {
+  return loadStreak();
+}
+
+// src/commands/leaderboard.ts
+var import_chalk7 = __toESM(require("chalk"), 1);
+var import_ora2 = __toESM(require("ora"), 1);
+init_profile_store();
+
+// src/ui/leaderboard-view.ts
+var import_chalk6 = __toESM(require("chalk"), 1);
+init_milestone_checker();
+var import_dayjs3 = __toESM(require("dayjs"), 1);
+
+// src/commands/leaderboard.ts
+var import_open3 = __toESM(require("open"), 1);
+function getLeaderboard() {
+  return loadLeaderboardCache();
+}
+
+// src/index.ts
+init_profile_store();
+
+// src/commands/export.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+async function runExport(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const data = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "0.1.0",
+    profile: {
+      username: profile.username,
+      timezone: profile.timezone,
+      createdAt: profile.createdAt
+    },
+    streak,
+    activity,
+    badges
+  };
+  if (options.format === "csv") {
+    const rows = ["date,source,isFrozen,isGrace"];
+    for (const a of activity) {
+      rows.push(`${a.date},${a.source},${a.isFrozen},${a.isGrace}`);
+    }
+    process.stdout.write(rows.join("\n") + "\n");
+  } else {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIn,
+  exportData,
+  getLeaderboard,
+  getProfile,
+  getStreak
+});