vibedate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pooria Arab
+
+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,117 @@
+# vibedating
+
+Dating by tokens — connect your Claude Code / Codex usage, get sorted into a
+**league** (1M / 5M / 10M / 100M / 1B+), and match with people who burn tokens
+the way you do. The premise: heavy users of these tools share something worth
+matching on.
+
+Part of the **Vibe Suite** — companion tools for agentic coding CLIs. Ships as
+**CLI + npm package + MCP server**, plus a local web app. Built on
+[`@pooriaarab/vibe-core`](https://www.npmjs.com/package/@pooriaarab/vibe-core).
+
+> **Local-first.** Raw token usage is read and stored on your own machine and
+> **never leaves it.** Only the coarse league *bucket* is ever shared — never the
+> raw number, never per-project breakdowns. v0 has no central directory; the match
+> pool is a local seeded demo.
+
+## Status
+
+**v0 — works locally, privacy-first.** Verification via read-only OAuth
+(`verified: true`) is the deliberate next step; the seam exists
+([`tryReadVerifiedUsage`](src/index.ts)). For now usage is **self-reported**
+(`verified: false`), read locally or supplied by you.
+
+## Install
+
+```bash
+npm install -g vibedate
+```
+
+…or run it ad-hoc:
+
+```bash
+npx vibedate connect
+```
+
+## Quick start
+
+```bash
+# 1. Read your usage, compute + print your league (stored locally at ~/.vibedating)
+vibedating connect
+
+# 2. See candidates in your league (same or adjacent tier)
+vibedating matches
+
+# 3. Open the local web app in your browser (served from your machine)
+vibedating open
+```
+
+Self-report a token count (otherwise a demo value is used):
+
+```bash
+VIBEDATING_TOKENS=23400000 vibedating connect   # also accepts 12M / 1.2B / 500k
+```
+
+### All commands
+
+```
+vibedating connect            Read usage, compute + print your league
+vibedating matches            List candidates in your league
+vibedating open [--port N]    Serve the local web app (default: random free port)
+vibedating mcp                Run the stdio MCP server (tools: profile, matches)
+vibedating --version
+vibedating --help
+```
+
+## Three faces, one local engine
+
+The same local engine drives all three, so you can use it wherever you work:
+
+- **Web** — `vibedating open` serves the dating UI (profile, match stack, league
+  ladder) at `http://localhost:PORT`. The page reads your league + matches from a
+  tiny local JSON endpoint.
+- **CLI** — `vibedating connect` / `matches`.
+- **MCP** — `vibedating mcp` exposes `profile` (your league) and `matches` to any
+  MCP host (Claude Code, Codex, Cursor, …).
+
+### As a library
+
+```ts
+import { league, matches, readUsage, CANDIDATES } from 'vibedate';
+
+const usage = await readUsage('claude-code');     // { totalTokens, verified, ... }
+const lg = league(usage.totalTokens);             // { name: '10M', min: 10_000_000 }
+const who = matches(lg.name, CANDIDATES);         // same/adjacent-tier candidates
+```
+
+## Privacy
+
+- **Raw usage stays local.** `totalTokens` is read into memory, stored at
+  `~/.vibedating/state.json`, and shown in the web app only behind an opt-in
+  toggle. It is never transmitted.
+- **Only the league bucket is shared** (and in v0, only with the local demo pool).
+- Consent for sharing the league is modeled with `@pooriaarab/vibe-core`'s consent
+  ledger (scope `share:league`), granted on `connect` and revocable on reset.
+
+## Leagues & matching
+
+Bucketed by lifetime tokens; you match within your league **or an adjacent tier**
+(so the tiny 1B+ pool still has people to match with):
+
+| League | Tokens (lifetime) |
+| ------ | ----------------- |
+| 1M     | 1M – 4.99M        |
+| 5M     | 5M – 9.99M        |
+| 10M    | 10M – 99.9M       |
+| 100M   | 100M – 999M       |
+| 1B+    | 1B+               |
+
+## Prototype
+
+An interactive, self-contained UX prototype (no build, no network):
+[`docs/prototype.html`](docs/prototype.html). The shipped local web app
+(`vibedating open`) is an adapted, data-driven version of this prototype.
+
+## License
+
+MIT

package/dist/chunk-64ME4THO.js

@@ -0,0 +1,126 @@
+import {
+  CANDIDATES,
+  league,
+  matches
+} from "./chunk-AU7FN2LY.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/state.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { createConsentLedger } from "@pooriaarab/vibe-core";
+var CONSENT_SCOPE = "share:league";
+function defaultStateDir() {
+  return path.join(os.homedir(), ".vibedating");
+}
+var FileConsentStore = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  load() {
+    try {
+      const raw = readFileSync(this.file, "utf8");
+      const data = JSON.parse(raw);
+      return data.grants ?? [];
+    } catch {
+      return [];
+    }
+  }
+  save(grants) {
+    mkdirSync(path.dirname(this.file), { recursive: true });
+    writeFileSync(this.file, JSON.stringify({ grants }, null, 2) + "\n", "utf8");
+  }
+};
+function createLedger(dir = defaultStateDir()) {
+  return createConsentLedger(new FileConsentStore(path.join(dir, "consent.json")));
+}
+function profilePath(dir) {
+  return path.join(dir, "state.json");
+}
+function connectProfile(snapshot, handle, dir = defaultStateDir()) {
+  const lg = league(snapshot.totalTokens);
+  createLedger(dir).grant(CONSENT_SCOPE, "connect: league bucket only; raw usage stays local");
+  const state = {
+    handle,
+    harness: snapshot.harness,
+    league: lg.name,
+    leagueMin: lg.min,
+    totalTokens: snapshot.totalTokens,
+    verified: snapshot.verified,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(profilePath(dir), JSON.stringify(state, null, 2) + "\n", "utf8");
+  return state;
+}
+function loadProfile(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync(profilePath(dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/mcp.ts
+function textBlock(text) {
+  return { type: "text", text };
+}
+var VERSION = "0.1.0";
+async function runMcp() {
+  const mcp = new McpServer({ name: "vibedating", version: VERSION });
+  mcp.tool(
+    "profile",
+    "Your vibedating league, computed locally from your token usage. Raw usage never leaves the machine \u2014 only the league bucket is shared. Requires `vibedating connect` to have run.",
+    () => {
+      const p = loadProfile();
+      if (!p) {
+        return {
+          content: [
+            textBlock("Not connected. Run `vibedating connect` first to compute your league.")
+          ]
+        };
+      }
+      const lines = [
+        `handle: ${p.handle}`,
+        `harness: ${p.harness}`,
+        `league: ${p.league} League`,
+        `verified: ${p.verified ? "true (read-only OAuth)" : "false (self-reported)"}`,
+        "privacy: raw token usage is local-only; only the league bucket is shared."
+      ];
+      return { content: [textBlock(lines.join("\n"))] };
+    }
+  );
+  mcp.tool(
+    "matches",
+    "Candidates in your league (same or adjacent tier) from the local seeded demo pool. No central directory in v0.",
+    () => {
+      const p = loadProfile();
+      if (!p) {
+        return {
+          content: [textBlock("Not connected. Run `vibedating connect` first.")]
+        };
+      }
+      const list = matches(p.league, CANDIDATES);
+      if (list.length === 0) {
+        return { content: [textBlock(`No candidates in range for the ${p.league} League.`)] };
+      }
+      const body = [`Matches for ${p.league} League (${list.length}):`];
+      for (const c of list) body.push(`- ${c.handle} (${c.league} League)`);
+      return { content: [textBlock(body.join("\n"))] };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+}
+
+export {
+  connectProfile,
+  loadProfile,
+  runMcp
+};

package/dist/chunk-AU7FN2LY.js

@@ -0,0 +1,133 @@
+// src/index.ts
+import { createConsentLedger } from "@pooriaarab/vibe-core";
+var LEAGUES = [
+  { name: "1M", min: 1e6, max: 4999999 },
+  { name: "5M", min: 5e6, max: 9999999 },
+  { name: "10M", min: 1e7, max: 99999999 },
+  { name: "100M", min: 1e8, max: 999999999 },
+  { name: "1B+", min: 1e9, max: Number.POSITIVE_INFINITY }
+];
+var BELOW_LEAGUE = "below-1M";
+function league(totalTokens) {
+  const n = Math.max(0, Math.floor(totalTokens));
+  for (const l of LEAGUES) {
+    if (n >= l.min && n <= l.max) {
+      return { name: l.name, min: l.min };
+    }
+  }
+  return { name: BELOW_LEAGUE, min: 0 };
+}
+function leagueIndex(name) {
+  if (name === BELOW_LEAGUE) return -1;
+  return LEAGUES.findIndex((l) => l.name === name);
+}
+var TOKENS_ENV = "VIBEDATING_TOKENS";
+var DEMO_TOTAL_TOKENS = 234e5;
+var MS_PER_DAY = 864e5;
+async function readUsage(harness = "claude-code") {
+  const verified = await tryReadVerifiedUsage(harness);
+  if (verified) return verified;
+  const injected = parseTokensEnv(process.env[TOKENS_ENV]);
+  const totalTokens = injected ?? DEMO_TOTAL_TOKENS;
+  const now = /* @__PURE__ */ new Date();
+  return {
+    harness,
+    totalTokens,
+    verified: false,
+    windowStart: new Date(now.getTime() - 30 * MS_PER_DAY).toISOString(),
+    windowEnd: now.toISOString()
+  };
+}
+async function tryReadVerifiedUsage(_harness) {
+  return null;
+}
+var TOKEN_MULT = {
+  "": 1,
+  k: 1e3,
+  K: 1e3,
+  m: 1e6,
+  M: 1e6,
+  b: 1e9,
+  B: 1e9
+};
+function parseTokensEnv(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed === "") return void 0;
+  const match = /^([0-9]*\.?[0-9]+)\s*([kKmMbB]?)$/.exec(trimmed);
+  if (!match) return void 0;
+  const num = Number(match[1]);
+  if (!Number.isFinite(num) || num < 0) return void 0;
+  const mult = TOKEN_MULT[match[2] ?? ""] ?? 1;
+  return Math.floor(num * mult);
+}
+var CANDIDATES = [
+  {
+    handle: "@merge_conflict_therapist",
+    league: "10M",
+    bio: ["Resolves conflicts for a living \u2014 code and otherwise.", "Currently: 47 tabs open, 3 are Stack Overflow."]
+  },
+  {
+    handle: "@rebase_romantic",
+    league: "5M",
+    bio: ["Rewrites history for a living, git and otherwise.", "Looking for someone who squashes commits and grudges."]
+  },
+  {
+    handle: "@0xInsomniac",
+    league: "1B+",
+    bio: ["Token count is classified. Ask my therapist.", "Has never once respected a rate limit."]
+  },
+  {
+    handle: "@yolo_to_main",
+    league: "1M",
+    bio: ["No branches, no regrets, no CI.", "A green checkmark is a state of mind."]
+  },
+  {
+    handle: "@async_awaits_you",
+    league: "10M",
+    bio: ["Promises kept, unlike my sleep schedule.", "DMs are non-blocking. Replies eventually resolve."]
+  },
+  {
+    handle: "@nullish_and_void",
+    league: "5M",
+    bio: ["Coalescing since 2019.", "My love language is optional chaining."]
+  },
+  {
+    handle: "@ctrl_z_daddy",
+    league: "100M",
+    bio: ["Undo is my safe word.", "Refactors everything, including this bio, twice."]
+  },
+  {
+    handle: "@segfault_sonnet",
+    league: "1M",
+    bio: ["Writes poetry in stack traces.", "Core dumped. Heart, mostly, open."]
+  },
+  {
+    handle: "@the_lint_whisperer",
+    league: "10M",
+    bio: ["Zero warnings, zero regrets, zero chill.", "Will fix your semicolons without being asked."]
+  }
+];
+function matches(myLeague, candidates = CANDIDATES) {
+  const myIdx = leagueIndex(myLeague);
+  return candidates.filter((c) => {
+    const idx = leagueIndex(c.league);
+    if (idx < 0) return false;
+    return Math.abs(idx - myIdx) <= 1;
+  });
+}
+
+export {
+  LEAGUES,
+  BELOW_LEAGUE,
+  league,
+  leagueIndex,
+  TOKENS_ENV,
+  DEMO_TOTAL_TOKENS,
+  readUsage,
+  tryReadVerifiedUsage,
+  parseTokensEnv,
+  CANDIDATES,
+  matches,
+  createConsentLedger
+};

package/dist/cli.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/** Recognized top-level commands, plus the synthetic help/version. */
+type Command = 'connect' | 'matches' | 'open' | 'mcp' | 'help' | 'version' | null;
+interface ParsedArgs {
+    readonly command: Command;
+    /** Port for `open --port`; undefined means "let the OS pick". */
+    readonly port: number | undefined;
+}
+/**
+ * Parse argv (the slice AFTER the program name) into a command + options.
+ * Pure: no IO, no process access — trivially unit-testable.
+ */
+declare function parseArgs(argv: readonly string[]): ParsedArgs;
+
+export { type Command, type ParsedArgs, parseArgs };