vibescc 0.2.0

package/README.md

@@ -0,0 +1,77 @@
+# Vibes
+
+Branded Claude Code. Custom crab colors + spinner verbs. One command.
+
+```
+yc        →  orange crab     stripe    →  purple crab
+vercel    →  black crab      supabase  →  green crab
+```
+
+## Install
+
+```bash
+bunx vibes
+```
+
+Or with git:
+
+```bash
+git clone https://github.com/djessicatony/vibescc.git
+cd vibescc
+./install.sh
+```
+
+Pick packs, open a new tab, done:
+
+```bash
+yc                                    # orange crab
+stripe --resume                       # purple crab, resume session
+yc --verbs looksmaxxing               # orange crab, custom verbs
+yc --dangerously-skip-permissions     # all claude flags work
+```
+
+Uninstall: `bunx vibes uninstall` or `./uninstall.sh`
+
+## How it works
+
+A PTY wrapper intercepts Claude's ANSI output and swaps the crab's color bytes before they hit your terminal. No binary patching. Pixel-perfect to the original — same crab, different paint. Survives Claude Code updates.
+
+**Crab colors** = per tab. Different crabs in different tabs.
+
+**Spinner verbs** = global (`~/.claude/settings.json`). Last write wins. Use `--verbs <pack>` to switch.
+
+## Brand packs
+
+| Pack | Body | Eyes |
+|------|------|------|
+| **yc** | `#FB651E` | `#FFFFFF` |
+| **stripe** | `#635BFF` | `#FFFFFF` |
+| **vercel** | `#000000` | `#FFFFFF` |
+| **supabase** | `#3ECF8E` | `#FAFAFA` |
+| **looksmaxxing** | `#1A1A2E` | `#E94560` |
+
+### Create your own
+
+```bash
+mkdir packs/mycompany
+cat > packs/mycompany/pack.json << 'EOF'
+{
+  "name": "My Company",
+  "slug": "mycompany",
+  "colors": { "body": "#FF0000", "eyes": "#FFFFFF" },
+  "verbs": ["Shipping", "Building", "Deploying"]
+}
+EOF
+```
+
+Re-run installer to get the alias.
+
+## Requirements
+
+- Python 3.6+ (stdlib only)
+- Claude Code in PATH
+- macOS or Linux
+
+## License
+
+MIT

package/bin/vibes.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+import { execSync, spawnSync } from "child_process";
+import { existsSync, mkdirSync, cpSync, readFileSync, writeFileSync, readdirSync, readlinkSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+import { homedir } from "os";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, "..");
+const HOME = homedir();
+const INSTALL_DIR = join(HOME, ".vibes");
+const SETTINGS = join(HOME, ".claude", "settings.json");
+
+// ── Colors ──────────────────────────────────────────────────────────────
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+};
+
+const info = (msg) => console.log(`${c.green}▸${c.reset} ${msg}`);
+const warn = (msg) => console.log(`${c.yellow}▸${c.reset} ${msg}`);
+
+// ── Banner ──────────────────────────────────────────────────────────────
+function showBanner() {
+  try {
+    spawnSync("python3", [join(ROOT, "scripts", "banner.py"), "vibescc"], {
+      stdio: "inherit",
+    });
+  } catch {
+    console.log(`\n  ${c.bold}VIBESCC${c.reset}\n`);
+  }
+  console.log(`  ${c.dim}branded Claude Code${c.reset}\n`);
+}
+
+// ── Detect shell rc ─────────────────────────────────────────────────────
+function getShellRc() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh") || process.platform === "darwin") {
+    return join(HOME, ".zshrc");
+  }
+  return join(HOME, ".bashrc");
+}
+
+// ── Read packs ──────────────────────────────────────────────────────────
+function loadPacks() {
+  const packsDir = join(ROOT, "packs");
+  return readdirSync(packsDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => {
+      const packJson = JSON.parse(
+        readFileSync(join(packsDir, d.name, "pack.json"), "utf8")
+      );
+      return { slug: d.name, ...packJson };
+    })
+    .sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+// ── Prompt ──────────────────────────────────────────────────────────────
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// ── Install ─────────────────────────────────────────────────────────────
+async function main() {
+  showBanner();
+
+  const packs = loadPacks();
+
+  // Show packs
+  console.log("  Pick what to install:\n");
+  packs.forEach((p, i) => {
+    console.log(
+      `    ${c.bold}${i + 1})${c.reset}  ${p.slug}  ${c.dim}(${p.name}, ${p.colors.body})${c.reset}`
+    );
+  });
+  console.log(`\n    ${c.bold}a)${c.reset}  all of the above\n`);
+
+  const choice = (await ask(`  Choice [a]: `)) || "a";
+
+  // Parse selection
+  let selected;
+  if (choice.toLowerCase() === "a") {
+    selected = packs;
+  } else {
+    const nums = choice.split(/[,\s]+/).map(Number);
+    selected = nums
+      .filter((n) => n >= 1 && n <= packs.length)
+      .map((n) => packs[n - 1]);
+  }
+
+  if (selected.length === 0) {
+    console.log(`${c.red}Nothing selected.${c.reset}`);
+    process.exit(1);
+  }
+
+  console.log();
+
+  // ── Copy files to ~/.vibescc ────────────────────────────────────────
+  info(`Installing to ${c.bold}${INSTALL_DIR}${c.reset}`);
+  mkdirSync(INSTALL_DIR, { recursive: true });
+  cpSync(join(ROOT, "scripts"), join(INSTALL_DIR, "scripts"), { recursive: true });
+  cpSync(join(ROOT, "packs"), join(INSTALL_DIR, "packs"), { recursive: true });
+
+  // ── Shell rc ────────────────────────────────────────────────────────
+  const shellRc = getShellRc();
+  if (!existsSync(shellRc)) writeFileSync(shellRc, "");
+  let rcContent = readFileSync(shellRc, "utf8");
+
+  // Remove old vibescc aliases
+  rcContent = rcContent
+    .split("\n")
+    .filter((line) => !line.includes("# vibes:"))
+    .join("\n");
+
+  const launcher = join(INSTALL_DIR, "scripts", "vibescc-launch.py");
+
+  for (const pack of selected) {
+    // Show banner for each pack
+    try {
+      spawnSync("python3", [join(ROOT, "scripts", "banner.py"), pack.slug], {
+        stdio: "inherit",
+      });
+    } catch {}
+
+    // Add alias
+    const packDir = join(INSTALL_DIR, "packs", pack.slug);
+    const alias = `alias ${pack.slug}='python3 ${launcher} --config ${packDir}' # vibes:${pack.slug}`;
+    rcContent += `\n${alias}`;
+
+    info(`Installed ${c.bold}${pack.name}${c.reset} → type ${c.bold}${pack.slug}${c.reset} to launch`);
+  }
+
+  // Write verbs from last selected pack
+  const lastPack = selected[selected.length - 1];
+  if (existsSync(SETTINGS)) {
+    try {
+      const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
+      settings.spinnerVerbs = { mode: "replace", verbs: lastPack.verbs };
+      writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + "\n");
+    } catch {}
+  }
+
+  writeFileSync(shellRc, rcContent.replace(/\n{3,}/g, "\n\n") + "\n");
+
+  // ── Done ────────────────────────────────────────────────────────────
+  console.log();
+  console.log(`${c.green}${c.bold}Done!${c.reset} Open a new terminal tab, then:\n`);
+  for (const pack of selected) {
+    console.log(`  ${c.bold}${pack.slug}${c.reset}              launch with branded crab`);
+  }
+  console.log(
+    `\n  All claude flags work: ${c.bold}--resume${c.reset}, ${c.bold}--dangerously-skip-permissions${c.reset}, etc.`
+  );
+  console.log(`  Switch verbs: ${c.bold}yc --verbs looksmaxxing${c.reset}`);
+  console.log(`\n  To uninstall: ${c.bold}bunx vibes uninstall${c.reset}\n`);
+}
+
+// ── Uninstall ───────────────────────────────────────────────────────────
+function uninstall() {
+  const shellRc = getShellRc();
+  if (existsSync(shellRc)) {
+    const cleaned = readFileSync(shellRc, "utf8")
+      .split("\n")
+      .filter((line) => !line.includes("# vibes:"))
+      .join("\n");
+    writeFileSync(shellRc, cleaned.replace(/\n{3,}/g, "\n\n") + "\n");
+    info("Removed aliases from " + shellRc);
+  }
+
+  if (existsSync(SETTINGS)) {
+    try {
+      const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
+      delete settings.spinnerVerbs;
+      writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + "\n");
+      info("Removed spinner verbs");
+    } catch {}
+  }
+
+  console.log(`\n${c.green}${c.bold}Done!${c.reset} All vibescc aliases and verbs removed.\n`);
+}
+
+// ── Entry ───────────────────────────────────────────────────────────────
+if (process.argv[2] === "uninstall") {
+  uninstall();
+} else {
+  main().catch(console.error);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "vibescc",
+  "version": "0.2.0",
+  "description": "Branded Claude Code — custom crab colors and spinner verbs",
+  "bin": {
+    "vibes": "./bin/vibes.mjs"
+  },
+  "files": [
+    "bin/",
+    "packs/",
+    "scripts/"
+  ],
+  "keywords": [
+    "claude-code",
+    "branding",
+    "cli",
+    "crab",
+    "mascot",
+    "customization"
+  ],
+  "author": "djessicatony",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/djessicatony/vibescc"
+  }
+}

package/packs/looksmaxxing/pack.json

@@ -0,0 +1,43 @@
+{
+  "name": "Looksmaxxing",
+  "slug": "looksmaxxing",
+  "colors": {
+    "body": "#1A1A2E",
+    "eyes": "#E94560"
+  },
+  "verbs": [
+    "Looksmaxxing",
+    "Jestermaxxing",
+    "Bone smashing",
+    "Frauding",
+    "Coping",
+    "Larping",
+    "Ascending",
+    "Hardmaxxing",
+    "Softmaxxing",
+    "Claudemaxxing",
+    "Retatrutiding",
+    "GHK-Cu'ing",
+    "MT-2'ing",
+    "BPC-157'ing",
+    "MK-677'ing",
+    "Mogging",
+    "Frame mogging",
+    "Brutally mogging",
+    "Mogging to death",
+    "Injecting steroids",
+    "Injecting peptides",
+    "Balding",
+    "Height mogging",
+    "Black pilling",
+    "Mewing",
+    "Hard mewing",
+    "Chin tucking",
+    "Thumb pulling",
+    "Chewing",
+    "Minoxidiling",
+    "Taking accutane",
+    "Tanning",
+    "Leanmaxxing"
+  ]
+}

package/packs/stripe/pack.json

@@ -0,0 +1,30 @@
+{
+  "name": "Stripe",
+  "slug": "stripe",
+  "colors": {
+    "body": "#635BFF",
+    "eyes": "#FFFFFF"
+  },
+  "verbs": [
+    "Grabbing your laptop",
+    "Pasting seven lines",
+    "Making roads",
+    "Sending swag kits",
+    "Not scaling",
+    "Sweating the details",
+    "Growing the internet",
+    "Staying curious",
+    "Earning stripes",
+    "Moving money",
+    "Ordering pizza",
+    "Debating energetically",
+    "Dropping out",
+    "Calling a friend",
+    "Answering emails",
+    "Posting on HN",
+    "Not waiting",
+    "Building in-house",
+    "Pushing that button",
+    "Hiring friends"
+  ]
+}

package/packs/stripe/stripe.md

@@ -0,0 +1,34 @@
+# Stripe Spinner Verbs — Sources
+
+Every verb traces to a real Stripe / Collison brothers moment.
+
+| Verb | Source |
+|---|---|
+| Grabbing your laptop | The "Collison Install" — PG's *Do Things That Don't Scale*: "Right then, give me your laptop" and set them up on the spot |
+| Pasting seven lines | Stripe's origin: 7 lines of code any dev could paste to accept payments |
+| Making roads | Patrick Collison on Dwarkesh Podcast: "We make roads" — infrastructure, not glamour |
+| Sending swag kits | Early Stripe sent physical swag kits to every customer after their first transaction |
+| Not scaling | Paul Graham's 2013 essay *Do Things That Don't Scale* — Stripe is the central example |
+| Sweating the details | Stripe culture: "if we make just one mistake, somebody's paycheck is wrong" |
+| Growing the internet | Stripe's mission: "increase the GDP of the internet" |
+| Staying curious | Stripe operating principle — "always seeking to learn" |
+| Earning stripes | Wordplay on the company name |
+| Moving money | What Stripe does, in two words |
+| Ordering pizza | Free pizza and drinks at Stripe's monthly Capture The Flag hacking competitions |
+| Debating energetically | Stripe operating principle: "question assumptions, debate energetically, abandon ideas" |
+| Dropping out | Patrick left MIT his freshman year to build (after selling Auctomatic for $5M at 19) |
+| Calling a friend | Early hack: when users signed up, Patrick called a friend at a payments gateway to manually open merchant accounts |
+| Answering emails | Stripe engineers personally answered support emails within minutes in the early days |
+| Posting on HN | Garry Tan posted on Hacker News: "need payments processing? email us" — got 300-550 waitlist signups |
+| Not waiting | PG on the Collisons: "they weren't going to wait" — contrasted with diffident founders who'd say "we'll send you a link" |
+| Building in-house | After realizing they couldn't control the UX through partnerships, they brought the entire payment pipeline in-house |
+| Pushing that button | Patrick on Dwarkesh: "push the hell out of that button" — describing how eagerly they'd adopt better solutions |
+| Hiring friends | 8 of Stripe's first 10 employees came from founder networks; they only hired people they'd want to hang out with on a Saturday |
+
+## Key Sources
+
+- Paul Graham, [Do Things That Don't Scale](https://paulgraham.com/ds.html) (2013)
+- Ali Abouelatta, [Stripe — First 1000](https://read.first1000.co/p/-stripe-6bb)
+- Startup Grind, [The Collison Brothers: The Story Behind The Founding Of Stripe](https://medium.com/startup-grind/the-collison-brothers-the-story-behind-the-founding-of-stripe-ae013434c080)
+- Dwarkesh Patel, [Patrick Collison — Craft, Beauty, & The Future of Payments](https://www.dwarkesh.com/p/patrick-collison)
+- Stripe, [Operating Principles](https://stripe.com/jobs/culture)

package/packs/supabase/pack.json

@@ -0,0 +1,30 @@
+{
+  "name": "Supabase",
+  "slug": "supabase",
+  "colors": {
+    "body": "#3ECF8E",
+    "eyes": "#FAFAFA"
+  },
+  "verbs": [
+    "Querying Postgres",
+    "Applying migrations",
+    "Syncing realtime",
+    "Authenticating users",
+    "Signing JWTs",
+    "Storing objects",
+    "Triggering edge functions",
+    "Seeding databases",
+    "Row-level securing",
+    "Broadcasting channels",
+    "Generating types",
+    "Branching databases",
+    "Vectorizing embeddings",
+    "Indexing full-text",
+    "Pooling connections",
+    "Replicating data",
+    "Backing up tables",
+    "Publishing APIs",
+    "Self-hosting",
+    "Open sourcing"
+  ]
+}

package/packs/vercel/pack.json

@@ -0,0 +1,30 @@
+{
+  "name": "Vercel",
+  "slug": "vercel",
+  "colors": {
+    "body": "#000000",
+    "eyes": "#FFFFFF"
+  },
+  "verbs": [
+    "Deploying to edge",
+    "Building previews",
+    "Generating static",
+    "Server rendering",
+    "Incrementally regenerating",
+    "Streaming responses",
+    "Caching at the edge",
+    "Revalidating paths",
+    "Splitting bundles",
+    "Hydrating components",
+    "Prefetching routes",
+    "Optimizing images",
+    "Compiling middleware",
+    "Shipping to production",
+    "Rolling back deploys",
+    "Running turborepo",
+    "Connecting domains",
+    "Measuring web vitals",
+    "Tree shaking",
+    "Zero-config deploying"
+  ]
+}

package/packs/yc/pack.json

@@ -0,0 +1,38 @@
+{
+  "name": "Y Combinator",
+  "slug": "yc",
+  "colors": {
+    "body": "#FB651E",
+    "eyes": "#FFFFFF"
+  },
+  "verbs": [
+    "Making something people want",
+    "Doing things that don't scale",
+    "Talking to users",
+    "G-stacking",
+    "Writing code",
+    "Launching now",
+    "Shipping fast",
+    "Pivoting",
+    "Iterating",
+    "Finding product-market fit",
+    "Ramen profiting",
+    "Being relentlessly resourceful",
+    "Going default alive",
+    "Not dying",
+    "Being a cockroach",
+    "Surviving the Trough of Sorrow",
+    "Overcoming schlep blindness",
+    "Avoiding tarpit ideas",
+    "Finding the 90/10 solution",
+    "Measuring weekly growth",
+    "Living in the future",
+    "Keeping identity small",
+    "Ignoring competitors",
+    "Staying frighteningly ambitious",
+    "Demo day prepping",
+    "Office houring",
+    "Reading PG essays",
+    "Launching on HN"
+  ]
+}

package/scripts/banner.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+banner.py — Render brand names as gradient block-letter art.
+
+Usage:
+    python3 banner.py vibes                      # default gradient
+    python3 banner.py YC --from FB651E --to FFAA44
+    python3 banner.py STRIPE --from 635BFF --to 8B7FFF
+"""
+
+import sys
+
+# ── Block letter font (6 rows tall) ────────────────────────────────────
+FONT = {
+    "A": [
+        " █████╗ ",
+        "██╔══██╗",
+        "███████║",
+        "██╔══██║",
+        "██║  ██║",
+        "╚═╝  ╚═╝",
+    ],
+    "B": [
+        "██████╗ ",
+        "██╔══██╗",
+        "██████╔╝",
+        "██╔══██╗",
+        "██████╔╝",
+        "╚═════╝ ",
+    ],
+    "C": [
+        " ██████╗",
+        "██╔════╝",
+        "██║     ",
+        "██║     ",
+        "╚██████╗",
+        " ╚═════╝",
+    ],
+    "D": [
+        "██████╗ ",
+        "██╔══██╗",
+        "██║  ██║",
+        "██║  ██║",
+        "██████╔╝",
+        "╚═════╝ ",
+    ],
+    "E": [
+        "███████╗",
+        "██╔════╝",
+        "█████╗  ",
+        "██╔══╝  ",
+        "███████╗",
+        "╚══════╝",
+    ],
+    "F": [
+        "███████╗",
+        "██╔════╝",
+        "█████╗  ",
+        "██╔══╝  ",
+        "██║     ",
+        "╚═╝     ",
+    ],
+    "G": [
+        " ██████╗ ",
+        "██╔════╝ ",
+        "██║  ███╗",
+        "██║   ██║",
+        "╚██████╔╝",
+        " ╚═════╝ ",
+    ],
+    "H": [
+        "██╗  ██╗",
+        "██║  ██║",
+        "███████║",
+        "██╔══██║",
+        "██║  ██║",
+        "╚═╝  ╚═╝",
+    ],
+    "I": [
+        "██╗",
+        "██║",
+        "██║",
+        "██║",
+        "██║",
+        "╚═╝",
+    ],
+    "K": [
+        "██╗  ██╗",
+        "██║ ██╔╝",
+        "█████╔╝ ",
+        "██╔═██╗ ",
+        "██║  ██╗",
+        "╚═╝  ╚═╝",
+    ],
+    "L": [
+        "██╗     ",
+        "██║     ",
+        "██║     ",
+        "██║     ",
+        "███████╗",
+        "╚══════╝",
+    ],
+    "M": [
+        "███╗   ███╗",
+        "████╗ ████║",
+        "██╔████╔██║",
+        "██║╚██╔╝██║",
+        "██║ ╚═╝ ██║",
+        "╚═╝     ╚═╝",
+    ],
+    "N": [
+        "███╗   ██╗",
+        "████╗  ██║",
+        "██╔██╗ ██║",
+        "██║╚██╗██║",
+        "██║ ╚████║",
+        "╚═╝  ╚═══╝",
+    ],
+    "O": [
+        " ██████╗ ",
+        "██╔═══██╗",
+        "██║   ██║",
+        "██║   ██║",
+        "╚██████╔╝",
+        " ╚═════╝ ",
+    ],
+    "P": [
+        "██████╗ ",
+        "██╔══██╗",
+        "██████╔╝",
+        "██╔═══╝ ",
+        "██║     ",
+        "╚═╝     ",
+    ],
+    "R": [
+        "██████╗ ",
+        "██╔══██╗",
+        "██████╔╝",
+        "██╔══██╗",
+        "██║  ██║",
+        "╚═╝  ╚═╝",
+    ],
+    "S": [
+        "███████╗",
+        "██╔════╝",
+        "███████╗",
+        "╚════██║",
+        "███████║",
+        "╚══════╝",
+    ],
+    "T": [
+        "████████╗",
+        "╚══██╔══╝",
+        "   ██║   ",
+        "   ██║   ",
+        "   ██║   ",
+        "   ╚═╝   ",
+    ],
+    "U": [
+        "██╗   ██╗",
+        "██║   ██║",
+        "██║   ██║",
+        "██║   ██║",
+        "╚██████╔╝",
+        " ╚═════╝ ",
+    ],
+    "V": [
+        "██╗   ██╗",
+        "██║   ██║",
+        "██║   ██║",
+        "╚██╗ ██╔╝",
+        " ╚████╔╝ ",
+        "  ╚═══╝  ",
+    ],
+    "W": [
+        "██╗    ██╗",
+        "██║    ██║",
+        "██║ █╗ ██║",
+        "██║███╗██║",
+        "╚███╔███╔╝",
+        " ╚══╝╚══╝ ",
+    ],
+    "X": [
+        "██╗  ██╗",
+        "╚██╗██╔╝",
+        " ╚███╔╝ ",
+        " ██╔██╗ ",
+        "██╔╝ ██╗",
+        "╚═╝  ╚═╝",
+    ],
+    "Y": [
+        "██╗   ██╗",
+        "╚██╗ ██╔╝",
+        " ╚████╔╝ ",
+        "  ╚██╔╝  ",
+        "   ██║   ",
+        "   ╚═╝   ",
+    ],
+    "Z": [
+        "███████╗",
+        "╚══███╔╝",
+        "  ███╔╝ ",
+        " ███╔╝  ",
+        "███████╗",
+        "╚══════╝",
+    ],
+    " ": [
+        "   ",
+        "   ",
+        "   ",
+        "   ",
+        "   ",
+        "   ",
+    ],
+}
+
+
+def hex_to_rgb(h):
+    h = h.lstrip("#")
+    return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
+
+
+def lerp_color(c1, c2, t):
+    return tuple(int(a + (b - a) * t) for a, b in zip(c1, c2))
+
+
+def colorize_char(char, r, g, b):
+    if char in (" ", ""):
+        return char
+    return f"\033[38;2;{r};{g};{b}m{char}\033[0m"
+
+
+def render_banner(text, color_from, color_to, indent=4):
+    text = text.upper()
+    rows = [[] for _ in range(6)]
+
+    for ch in text:
+        glyph = FONT.get(ch, FONT[" "])
+        for i, line in enumerate(glyph):
+            rows[i].append(line)
+
+    # Join rows and apply horizontal gradient
+    output = []
+    for row_parts in rows:
+        full_line = "".join(row_parts)
+        total = max(len(full_line), 1)
+        colored = ""
+        pos = 0
+        for char in full_line:
+            t = pos / total
+            r, g, b = lerp_color(color_from, color_to, t)
+            colored += colorize_char(char, r, g, b)
+            pos += 1
+        output.append(" " * indent + colored)
+
+    return "\n".join(output)
+
+
+# ── Preset gradients per brand ──────────────────────────────────────────
+PRESETS = {
+    "vibes":    {"text": "VIBES",    "from": "FF6B6B", "to": "C084FC"},
+    "yc":       {"text": "YC",       "from": "FB651E", "to": "FFAA44"},
+    "stripe":   {"text": "STRIPE",   "from": "635BFF", "to": "A89BFF"},
+    "vercel":   {"text": "VERCEL",   "from": "888888", "to": "FFFFFF"},
+    "supabase": {"text": "SUPABASE", "from": "249361", "to": "3ECF8E"},
+}
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("name", help="Text to render (or preset name)")
+    parser.add_argument("--from", dest="color_from", default=None)
+    parser.add_argument("--to", dest="color_to", default=None)
+    parser.add_argument("--indent", type=int, default=4)
+    args = parser.parse_args()
+
+    name = args.name.lower()
+
+    if name in PRESETS and not args.color_from:
+        preset = PRESETS[name]
+        text = preset["text"]
+        c_from = hex_to_rgb(preset["from"])
+        c_to = hex_to_rgb(preset["to"])
+    else:
+        text = args.name.upper()
+        c_from = hex_to_rgb(args.color_from or "FFFFFF")
+        c_to = hex_to_rgb(args.color_to or args.color_from or "FFFFFF")
+
+    print()
+    print(render_banner(text, c_from, c_to, args.indent))
+    print()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/vibescc-launch.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+vibescc-launch.py — PTY wrapper that recolors the Claude Code crab.
+
+Spawns `claude` inside a pseudoterminal, intercepts the ANSI output stream,
+and replaces the crab's color codes with company branding colors.
+
+The crab itself is pixel-perfect — same characters, same poses, same animation.
+Only the paint changes.
+
+Usage:
+    python3 vibescc-launch.py                     # default YC orange
+    python3 vibescc-launch.py --body 255,102,0    # custom body RGB
+    python3 vibescc-launch.py --config packs/yc   # load from pack.json
+    python3 vibescc-launch.py -- --resume          # pass flags to claude
+"""
+
+import argparse
+import json
+import os
+import pty
+import re
+import signal
+import struct
+import sys
+import fcntl
+import termios
+
+# ── Original Clawd colors (consistent across CC versions) ──────────────
+# Match both semicolon (38;2;R;G;B) and colon (38:2:R:G:B) formats.
+# Ink/chalk may use either depending on version.
+ORIGINALS = [
+    # (pattern, is_shimmer, is_background)
+    # Theme A — claude/clawd_body: rgb(215,119,87)
+    (b"38;2;215;119;87", False, False),
+    (b"38:2:215:119:87", False, False),
+    (b"48;2;215;119;87", False, True),
+    (b"48:2:215:119:87", False, True),
+    # Theme A — claudeShimmer: rgb(245,149,117)
+    (b"38;2;245;149;117", True, False),
+    (b"38:2:245:149:117", True, False),
+    (b"48;2;245;149;117", True, True),
+    (b"48:2:245:149:117", True, True),
+    # Theme B — claude: rgb(255,153,51)
+    (b"38;2;255;153;51", False, False),
+    (b"38:2:255:153:51", False, False),
+    (b"48;2;255;153;51", False, True),
+    (b"48:2:255:153:51", False, True),
+    # Theme B — claudeShimmer: rgb(255,183,101)
+    (b"38;2;255;183;101", True, False),
+    (b"38:2:255:183:101", True, False),
+    (b"48;2;255;183;101", True, True),
+    (b"48:2:255:183:101", True, True),
+    # Theme C — claudeShimmer: rgb(235,159,127)
+    (b"38;2;235;159;127", True, False),
+    (b"38:2:235:159:127", True, False),
+    (b"48;2;235;159;127", True, True),
+    (b"48:2:235:159:127", True, True),
+]
+ORIGINAL_BG_SEMI = b"48;2;0;0;0"
+ORIGINAL_BG_COLON = b"48:2:0:0:0"
+
+
+def make_replacement(r, g, b):
+    """Build the replacement byte string for a color."""
+    return f"{r};{g};{b}".encode()
+
+
+def make_shimmer(r, g, b):
+    """Generate a lighter shimmer variant of a color (same offset as claude→claudeShimmer)."""
+    return (min(r + 30, 255), min(g + 30, 255), min(b + 30, 255))
+
+
+def build_filter(body_rgb, bg_rgb=None):
+    """Return a stateful function that replaces clawd colors in an ANSI byte stream.
+
+    Keeps a small overlap buffer between read() calls to catch color codes
+    that get split across chunk boundaries.
+    """
+    shimmer_rgb = make_shimmer(*body_rgb)
+
+    def rgb_semi(prefix, r, g, b):
+        return f"{prefix};2;{r};{g};{b}".encode()
+
+    def rgb_colon(prefix, r, g, b):
+        return f"{prefix}:2:{r}:{g}:{b}".encode()
+
+    replacements = []
+    for orig, is_shimmer, is_bg in ORIGINALS:
+        target_rgb = shimmer_rgb if is_shimmer else body_rgb
+        sep = ":" if b":" in orig else ";"
+        prefix = "48" if is_bg else "38"
+        new = f"{prefix}{sep}2{sep}{target_rgb[0]}{sep}{target_rgb[1]}{sep}{target_rgb[2]}".encode()
+        replacements.append((orig, new))
+
+    if bg_rgb:
+        new_bg_semi = rgb_semi("48", *bg_rgb)
+        new_bg_colon = rgb_colon("48", *bg_rgb)
+        replacements.append((ORIGINAL_BG_SEMI, new_bg_semi))
+        replacements.append((ORIGINAL_BG_COLON, new_bg_colon))
+
+    # Regex to strip terminal identification responses
+    strip_terminal_responses = re.compile(
+        rb"\x1bP[^\x1b]*\x1b\\|\x1b\[\?[0-9;]*c"
+    )
+
+    # Smart holdback: only keep tail bytes if they could be a partial
+    # match of a color pattern (contains digits/semicolons after ESC[).
+    # This avoids the latency of always holding back bytes.
+    max_pat = max(len(old) for old, _ in replacements)
+    partial_re = re.compile(rb"[34]8[;:]2[;:][\d;:]{0," + str(max_pat).encode() + rb"}$")
+    leftover = b""
+
+    def apply(data):
+        nonlocal leftover
+        buf = leftover + data
+
+        # Strip terminal ID sequences
+        buf = strip_terminal_responses.sub(b"", buf)
+
+        # Do replacements
+        for old, new in replacements:
+            buf = buf.replace(old, new)
+
+        # Smart holdback: only if tail looks like a partial color code
+        hold = 0
+        if len(buf) > max_pat:
+            tail = buf[-(max_pat):]
+            m = partial_re.search(tail)
+            if m:
+                hold = len(tail) - m.start()
+
+        if hold > 0:
+            leftover = buf[-hold:]
+            return buf[:-hold]
+        else:
+            leftover = b""
+            return buf
+
+    return apply
+
+
+def parse_rgb(s):
+    """Parse '255,102,0' or '#FF6600' into (r, g, b) tuple."""
+    s = s.strip()
+    if s.startswith("#"):
+        h = s.lstrip("#")
+        return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
+    parts = s.split(",")
+    return (int(parts[0]), int(parts[1]), int(parts[2]))
+
+
+def load_pack_colors(pack_dir):
+    """Load body and eyes colors from a vibescc pack.json."""
+    pack_json = os.path.join(pack_dir, "pack.json")
+    with open(pack_json) as f:
+        pack = json.load(f)
+    body = parse_rgb(pack["colors"]["body"])
+    eyes = parse_rgb(pack["colors"]["eyes"])
+    return body, eyes
+
+
+def resolve_pack_dir(name):
+    """Resolve a pack name to its directory. Accepts a path or just a slug."""
+    if os.path.isdir(name):
+        return name
+    # Try relative to script's packs/ directory
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    packs_dir = os.path.join(script_dir, "..", "packs")
+    candidate = os.path.join(packs_dir, name)
+    if os.path.isdir(candidate):
+        return candidate
+    return None
+
+
+def apply_verbs(pack_dir):
+    """Write a pack's verbs to ~/.claude/settings.json."""
+    pack_json = os.path.join(pack_dir, "pack.json")
+    with open(pack_json) as f:
+        pack = json.load(f)
+    verbs = pack.get("verbs", [])
+    if not verbs:
+        return
+
+    settings_path = os.path.expanduser("~/.claude/settings.json")
+    try:
+        with open(settings_path) as f:
+            settings = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        settings = {}
+
+    settings["spinnerVerbs"] = {"mode": "replace", "verbs": verbs}
+
+    with open(settings_path, "w") as f:
+        json.dump(settings, f, indent=2)
+        f.write("\n")
+
+
+def sync_window_size(master_fd):
+    """Copy the real terminal's window size to the PTY master."""
+    try:
+        size = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, b"\x00" * 8)
+        fcntl.ioctl(master_fd, termios.TIOCSWINSZ, size)
+    except OSError:
+        pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Launch Claude Code with custom crab colors")
+    parser.add_argument(
+        "--body",
+        default=None,
+        help="Body color as R,G,B or #hex (default: YC orange #FF6600)",
+    )
+    parser.add_argument(
+        "--eyes",
+        default=None,
+        help="Eye color as R,G,B or #hex (default: unchanged)",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Path to pack directory (reads colors from pack.json)",
+    )
+    parser.add_argument(
+        "--verbs",
+        default=None,
+        help="Pack name or path to load verbs from (e.g. looksmaxxing, stripe)",
+    )
+    args, claude_args = parser.parse_known_args()
+
+    # Apply verbs from a different pack if requested
+    if args.verbs:
+        verbs_dir = resolve_pack_dir(args.verbs)
+        if verbs_dir:
+            apply_verbs(verbs_dir)
+        else:
+            print(f"Warning: verb pack '{args.verbs}' not found, skipping", file=sys.stderr)
+
+    # Resolve colors
+    if args.config:
+        body_rgb, eyes_rgb = load_pack_colors(args.config)
+    else:
+        body_rgb = parse_rgb(args.body) if args.body else (255, 102, 0)
+        eyes_rgb = parse_rgb(args.eyes) if args.eyes else None
+
+    color_filter = build_filter(body_rgb, eyes_rgb)
+
+    # Build claude command — everything we didn't recognize goes to claude
+    claude_cmd = ["claude"] + claude_args
+
+    # ── PTY spawn with output filtering ────────────────────────────────
+    # pty.fork() handles setsid/TIOCSCTTY/dup2 correctly on macOS.
+    # We set window size immediately after fork, then SIGWINCH the child
+    # so claude/Ink re-reads the correct terminal dimensions.
+
+    pid, master_fd = pty.fork()
+
+    if pid == 0:
+        # Child: exec claude
+        os.environ.setdefault("TERM", "xterm-256color")
+        os.execvp(claude_cmd[0], claude_cmd)
+        sys.exit(1)
+
+    # Parent: set correct PTY size and tell child to re-read it
+    sync_window_size(master_fd)
+    import time
+    time.sleep(0.05)  # let child start before SIGWINCH
+    try:
+        os.kill(pid, signal.SIGWINCH)
+    except OSError:
+        pass
+
+    # Handle SIGWINCH (terminal resize) — propagate to PTY
+    def handle_winch(signum, frame):
+        sync_window_size(master_fd)
+        os.kill(pid, signal.SIGWINCH)
+
+    signal.signal(signal.SIGWINCH, handle_winch)
+
+    # Put stdin in raw mode so keypresses pass through immediately
+    old_tty = termios.tcgetattr(sys.stdin)
+    try:
+        import tty
+
+        tty.setraw(sys.stdin)
+
+        # I/O relay loop
+        import select
+
+        while True:
+            try:
+                rlist, _, _ = select.select([sys.stdin, master_fd], [], [], 0.1)
+            except (select.error, ValueError):
+                break
+
+            if master_fd in rlist:
+                try:
+                    data = os.read(master_fd, 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                # Coalesce: grab any immediately available data to avoid
+                # color codes splitting across chunk boundaries
+                while True:
+                    ready, _, _ = select.select([master_fd], [], [], 0)
+                    if not ready:
+                        break
+                    try:
+                        more = os.read(master_fd, 65536)
+                    except OSError:
+                        break
+                    if not more:
+                        break
+                    data += more
+                # Apply color filter
+                filtered = color_filter(data)
+                if filtered:
+                    os.write(sys.stdout.fileno(), filtered)
+
+            if sys.stdin in rlist:
+                try:
+                    data = os.read(sys.stdin.fileno(), 4096)
+                except OSError:
+                    break
+                if not data:
+                    break
+                # Strip terminal ID responses from stdin before they
+                # enter the PTY and get echoed back to the screen
+                data = re.sub(
+                    rb"\x1bP[^\x1b]*\x1b\\|\x1b\[\?[0-9;]*c",
+                    b"",
+                    data,
+                )
+                if data:
+                    os.write(master_fd, data)
+
+
+
+    finally:
+        # Restore terminal
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_tty)
+
+    # Wait for child and exit with its status
+    _, status = os.waitpid(pid, 0)
+    sys.exit(os.WEXITSTATUS(status) if os.WIFEXITED(status) else 1)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/yc-claude

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Launch Claude Code with YC-branded crab
+# Usage: yc-claude [claude args...]
+DIR="$(cd "$(dirname "$0")" && pwd)"
+exec python3 "$DIR/vibescc-launch.py" --config "$DIR/../packs/yc" -- "$@"