claude-bingo 0.1.0__tar.gz

claude_bingo-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,16 @@
+{
+  "name": "claude-bingo",
+  "owner": { "name": "Marc Lavallee" },
+  "description": "Bingo for LLM-isms, scored against your own Claude transcripts.",
+  "plugins": [
+    {
+      "name": "claude-bingo",
+      "displayName": "Claude Bingo",
+      "description": "Generate a bingo board of LLM verbal tics and score it against your local Claude Code transcripts.",
+      "source": { "source": "github", "repo": "lavallee/claude-bingo" },
+      "version": "0.1.0",
+      "license": "MIT",
+      "category": "fun"
+    }
+  ]
+}

claude_bingo-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "claude-bingo",
+  "displayName": "Claude Bingo",
+  "version": "0.1.0",
+  "description": "Bingo for LLM-isms, scored against your own Claude transcripts.",
+  "author": { "name": "Marc Lavallee" },
+  "repository": "https://github.com/lavallee/claude-bingo",
+  "license": "MIT",
+  "keywords": ["fun", "analysis", "transcripts"]
+}

claude_bingo-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,50 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.11", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Phrase bank loads and every regex compiles
+        run: |
+          python -c "
+          from claude_bingo import phrases
+          b = phrases.load()
+          assert b['labels'], 'empty phrase bank'
+          assert len(b['labels']) == len(set(b['labels'])), 'duplicate labels'
+          print(f\"{len(b['labels'])} phrases ok\")
+          "
+
+      - name: Board generates and renders
+        run: |
+          python -m claude_bingo board --seed 1
+          python -m claude_bingo board --size 4 --seed 2
+          python -m claude_bingo phrases > /dev/null
+
+      - name: Score fails gracefully with no transcripts
+        run: |
+          if python -m claude_bingo score > out.txt 2>&1; then
+            echo "expected a nonzero exit with no transcripts present" >&2
+            exit 1
+          fi
+          grep -q "no transcripts" out.txt
+
+      - name: Package builds and installs
+        run: |
+          pip install --quiet build
+          python -m build --wheel
+          pip install --quiet dist/*.whl
+          claude-bingo phrases > /dev/null

claude_bingo-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,47 @@
+name: publish
+
+# Publishes to PyPI when a GitHub release is published.
+# Auth is via PyPI Trusted Publishing (OIDC) — no API token stored anywhere.
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Check tag matches pyproject version
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          version=$(python3 -c \
+            "import tomllib;print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          if [ "$tag" != "$version" ]; then
+            echo "tag $tag != pyproject version $version" >&2
+            exit 1
+          fi
+
+      - run: uv build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

claude_bingo-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+dist/
+build/
+*.egg-info/
+.venv/
+venv/
+
+# Board state lives in XDG_DATA_HOME now, but don't let a stray one in —
+# it's a fingerprint of your own transcripts.
+board.json

claude_bingo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marc Lavallee
+
+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 OTHER DEALINGS IN THE
+SOFTWARE.

claude_bingo-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: claude-bingo
+Version: 0.1.0
+Summary: Bingo for LLM-isms, scored against your own Claude transcripts.
+Project-URL: Homepage, https://github.com/lavallee/claude-bingo
+Project-URL: Issues, https://github.com/lavallee/claude-bingo/issues
+Author: Marc Lavallee
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bingo,claude,cli,llm
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# claude-bingo
+
+A 5×5 bingo board of LLM verbal tics, scored against your own Claude Code
+transcripts.
+
+```
+         B               I               N               G               O
+  ┌───────────────┬───────────────┬───────────────┬───────────────┬───────────────┐
+  │   I hear you  │   Good catch  │ battle-tested │  load-bearing │  worth naming │
+  │       ×2      │       ×9      │       —       │      ×71      │       ×3      │
+  ├───────────────┼───────────────┼───────────────┼───────────────┼───────────────┤
+  │    Happy to   │   Let me be   │   Hope this   │   Excellent!  │     Let me    │
+  │       ×4      │     direct    │     helps     │       —       │      ×74      │
+  │               │       ×2      │       —       │               │               │
+  └───────────────┴───────────────┴───────────────┴───────────────┴───────────────┘
+
+  BINGO! row 1, diagonal ↘
+  18/25 squares · 201 utterances · 1,534 transcripts
+
+  ── worst offenders ────────────────────────────────────────
+     74  Let me
+         …before changing anything. Let me check what the config actual…
+     71  load-bearing
+         …that assumption is doing a lot of load-bearing work here.
+```
+
+Everything runs locally. It reads `~/.claude/projects/**/*.jsonl` and prints to
+your terminal. There are no network calls and no dependencies beyond the Python
+standard library.
+
+## Install
+
+**As a Claude Code plugin** — then just ask Claude to play bingo:
+
+```
+/plugin marketplace add lavallee/claude-bingo
+/plugin install claude-bingo@claude-bingo
+```
+
+**As a CLI:**
+
+```bash
+uvx claude-bingo board     # no install
+pipx install claude-bingo  # or keep it around
+```
+
+**From source:**
+
+```bash
+git clone https://github.com/lavallee/claude-bingo
+cd claude-bingo
+python3 -m claude_bingo board
+```
+
+Requires Python 3.11+ (for `tomllib`).
+
+## Use
+
+```bash
+claude-bingo board              # generate a fresh board
+claude-bingo board --size 3     # smaller, for a quick round
+claude-bingo board --seed 12345 # reproduce a specific board
+claude-bingo score              # score it against the last 7 days
+claude-bingo score --days 30    # ...or however far back you dare look
+claude-bingo score --no-quotes  # skip the receipts
+claude-bingo phrases            # list the phrase bank
+```
+
+The board is saved to `$XDG_DATA_HOME/claude-bingo/board.json` (default
+`~/.local/share/claude-bingo/board.json`), so `score` picks up whatever you last
+generated.
+
+A given `--seed` reproduces a given board only for a given phrase bank — add
+phrases and the same seed deals a different hand.
+
+## The phrase bank
+
+65 phrases across 9 categories, in
+[`claude_bingo/phrases.toml`](claude_bingo/phrases.toml). Each entry is a board
+label and the regex that hunts for it:
+
+```toml
+[linkedin-brain]
+"delve" = "\\bdelv(?:e|es|ing)\\b"
+"tapestry" = "\\btapestry\\b"
+```
+
+Patterns are matched case-insensitively and in multiline mode, so `^` anchors to
+the start of any line.
+
+Add your own without touching the package in
+`~/.config/claude-bingo/phrases.toml` — same format. A label that collides with
+a bundled one overrides its pattern.
+
+## Contributing
+
+PRs to the phrase bank are the point of this repo. Add to an existing category
+or start a new one. Two things make a good entry:
+
+- **The label reads at a glance.** It lands in a 13-column cell.
+- **The regex is specific enough to mean something.** `\bjust\b` will match
+  everything and tell you nothing; `you'?re absolutely right` earns its square.
+
+Run `claude-bingo phrases` to check yours loaded, and `claude-bingo score` to
+see whether it actually catches anything.
+
+## License
+
+MIT

claude_bingo-0.1.0/README.md

@@ -0,0 +1,109 @@
+# claude-bingo
+
+A 5×5 bingo board of LLM verbal tics, scored against your own Claude Code
+transcripts.
+
+```
+         B               I               N               G               O
+  ┌───────────────┬───────────────┬───────────────┬───────────────┬───────────────┐
+  │   I hear you  │   Good catch  │ battle-tested │  load-bearing │  worth naming │
+  │       ×2      │       ×9      │       —       │      ×71      │       ×3      │
+  ├───────────────┼───────────────┼───────────────┼───────────────┼───────────────┤
+  │    Happy to   │   Let me be   │   Hope this   │   Excellent!  │     Let me    │
+  │       ×4      │     direct    │     helps     │       —       │      ×74      │
+  │               │       ×2      │       —       │               │               │
+  └───────────────┴───────────────┴───────────────┴───────────────┴───────────────┘
+
+  BINGO! row 1, diagonal ↘
+  18/25 squares · 201 utterances · 1,534 transcripts
+
+  ── worst offenders ────────────────────────────────────────
+     74  Let me
+         …before changing anything. Let me check what the config actual…
+     71  load-bearing
+         …that assumption is doing a lot of load-bearing work here.
+```
+
+Everything runs locally. It reads `~/.claude/projects/**/*.jsonl` and prints to
+your terminal. There are no network calls and no dependencies beyond the Python
+standard library.
+
+## Install
+
+**As a Claude Code plugin** — then just ask Claude to play bingo:
+
+```
+/plugin marketplace add lavallee/claude-bingo
+/plugin install claude-bingo@claude-bingo
+```
+
+**As a CLI:**
+
+```bash
+uvx claude-bingo board     # no install
+pipx install claude-bingo  # or keep it around
+```
+
+**From source:**
+
+```bash
+git clone https://github.com/lavallee/claude-bingo
+cd claude-bingo
+python3 -m claude_bingo board
+```
+
+Requires Python 3.11+ (for `tomllib`).
+
+## Use
+
+```bash
+claude-bingo board              # generate a fresh board
+claude-bingo board --size 3     # smaller, for a quick round
+claude-bingo board --seed 12345 # reproduce a specific board
+claude-bingo score              # score it against the last 7 days
+claude-bingo score --days 30    # ...or however far back you dare look
+claude-bingo score --no-quotes  # skip the receipts
+claude-bingo phrases            # list the phrase bank
+```
+
+The board is saved to `$XDG_DATA_HOME/claude-bingo/board.json` (default
+`~/.local/share/claude-bingo/board.json`), so `score` picks up whatever you last
+generated.
+
+A given `--seed` reproduces a given board only for a given phrase bank — add
+phrases and the same seed deals a different hand.
+
+## The phrase bank
+
+65 phrases across 9 categories, in
+[`claude_bingo/phrases.toml`](claude_bingo/phrases.toml). Each entry is a board
+label and the regex that hunts for it:
+
+```toml
+[linkedin-brain]
+"delve" = "\\bdelv(?:e|es|ing)\\b"
+"tapestry" = "\\btapestry\\b"
+```
+
+Patterns are matched case-insensitively and in multiline mode, so `^` anchors to
+the start of any line.
+
+Add your own without touching the package in
+`~/.config/claude-bingo/phrases.toml` — same format. A label that collides with
+a bundled one overrides its pattern.
+
+## Contributing
+
+PRs to the phrase bank are the point of this repo. Add to an existing category
+or start a new one. Two things make a good entry:
+
+- **The label reads at a glance.** It lands in a 13-column cell.
+- **The regex is specific enough to mean something.** `\bjust\b` will match
+  everything and tell you nothing; `you'?re absolutely right` earns its square.
+
+Run `claude-bingo phrases` to check yours loaded, and `claude-bingo score` to
+see whether it actually catches anything.
+
+## License
+
+MIT

claude_bingo-0.1.0/claude_bingo/__init__.py

@@ -0,0 +1,3 @@
+"""claude-bingo — a board of LLM-isms, scored against your own transcripts."""
+
+__version__ = "0.1.0"

claude_bingo-0.1.0/claude_bingo/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

claude_bingo-0.1.0/claude_bingo/cli.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""claude-bingo — a board of LLM-isms, scored against your own transcripts.
+
+    claude-bingo board                 generate a fresh 5x5 board
+    claude-bingo score                 score it against the last 7 days of logs
+    claude-bingo score --days 30       ...or however far back you dare look
+    claude-bingo phrases               list the phrase bank
+
+Everything runs locally. Transcripts are read, never sent anywhere.
+"""
+
+import argparse
+import json
+import os
+import random
+import re
+import sys
+import textwrap
+import time
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from . import phrases
+
+LOG_ROOT = Path.home() / ".claude" / "projects"
+
+CELL_W = 15
+FREE = "FREE SPACE"
+
+# ANSI, kept minimal so it degrades to noise-free plain text when piped.
+RESET, BOLD, DIM = "\033[0m", "\033[1m", "\033[2m"
+GREEN, YELLOW, RED, CYAN, MAGENTA = (
+    "\033[32m", "\033[33m", "\033[31m", "\033[36m", "\033[35m",
+)
+
+_BANK = None
+
+
+def bank():
+    """Phrase bank, loaded once per process (workers re-import this module)."""
+    global _BANK
+    if _BANK is None:
+        _BANK = phrases.load()
+    return _BANK
+
+
+def board_path():
+    base = os.environ.get("XDG_DATA_HOME")
+    root = Path(base) if base else Path.home() / ".local" / "share"
+    return root / "claude-bingo" / "board.json"
+
+
+def color(s, c):
+    return s if not sys.stdout.isatty() else f"{c}{s}{RESET}"
+
+
+# ---------------------------------------------------------------- board gen
+
+def make_board(size, seed):
+    labels = bank()["labels"]
+    needed = size * size - (1 if size % 2 else 0)
+    if needed > len(labels):
+        sys.exit(f"only {len(labels)} phrases in the bank; {size}x{size} needs "
+                 f"{needed}")
+    rng = random.Random(seed)
+    picks = rng.sample(labels, needed)
+    if size % 2:
+        picks.insert(size * size // 2, FREE)
+    return {
+        "seed": seed,
+        "size": size,
+        "created": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "cells": picks,
+    }
+
+
+# ---------------------------------------------------------------- scanning
+
+def recent_logs(days):
+    cutoff = time.time() - days * 86400
+    for path in LOG_ROOT.rglob("*.jsonl"):
+        try:
+            if path.stat().st_mtime >= cutoff:
+                yield path
+        except OSError:
+            continue
+
+
+def _scan_file(args):
+    """Worker: return {label: (count, first_example)} for one transcript."""
+    path, cutoff_iso, wanted = args
+    by_label = bank()["by_label"]
+    pats = [(label, by_label[label]) for label in wanted if label in by_label]
+    hits = {}
+    try:
+        with open(path, "r", errors="replace") as fh:
+            for line in fh:
+                if '"assistant"' not in line:
+                    continue
+                try:
+                    rec = json.loads(line)
+                except ValueError:
+                    continue
+                if rec.get("type") != "assistant":
+                    continue
+                if (rec.get("timestamp") or "") < cutoff_iso:
+                    continue
+                content = rec.get("message", {}).get("content")
+                if not isinstance(content, list):
+                    continue
+                for block in content:
+                    if not isinstance(block, dict) or block.get("type") != "text":
+                        continue
+                    text = block.get("text") or ""
+                    for label, pat in pats:
+                        found = pat.findall(text)
+                        if not found:
+                            continue
+                        count, example = hits.get(label, (0, None))
+                        hits[label] = (
+                            count + len(found),
+                            example or _snippet(text, pat),
+                        )
+    except OSError:
+        pass
+    return hits
+
+
+def _snippet(text, pat, width=64):
+    m = pat.search(text)
+    if not m:
+        return None
+    start = max(0, m.start() - width // 3)
+    end = min(len(text), m.end() + width // 2)
+    frag = " ".join(text[start:end].split())
+    return ("…" if start else "") + frag + ("…" if end < len(text) else "")
+
+
+def scan(days, wanted, jobs):
+    if not LOG_ROOT.exists():
+        sys.exit(f"no transcripts found — {LOG_ROOT} doesn't exist.\n"
+                 "claude-bingo scores your local Claude Code logs; you need "
+                 "some history first.")
+    cutoff_iso = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
+    files = list(recent_logs(days))
+    if not files:
+        sys.exit(f"no transcripts touched in the last {days} days under {LOG_ROOT}")
+
+    totals = {}
+    work = [(f, cutoff_iso, wanted) for f in files]
+    done = 0
+    with ProcessPoolExecutor(max_workers=jobs) as pool:
+        for hits in pool.map(_scan_file, work, chunksize=8):
+            done += 1
+            if sys.stderr.isatty() and done % 50 == 0:
+                pct = 100 * done // len(files)
+                print(f"\r  scanning… {done}/{len(files)} ({pct}%)",
+                      end="", file=sys.stderr)
+            for label, (count, example) in hits.items():
+                prev_count, prev_example = totals.get(label, (0, None))
+                totals[label] = (prev_count + count, prev_example or example)
+    if sys.stderr.isatty():
+        print("\r" + " " * 40 + "\r", end="", file=sys.stderr)
+    return totals, len(files)
+
+
+# ---------------------------------------------------------------- rendering
+
+def wrap_cell(label, count=None):
+    lines = textwrap.wrap(label, CELL_W - 2) or [""]
+    if count is not None:
+        lines.append(f"×{count}" if count else "—")
+    lines = lines[:4]
+    return lines + [""] * (4 - len(lines))
+
+
+def render(board, totals=None):
+    size = board["size"]
+    cells = board["cells"]
+    marked = set()
+    if totals is not None:
+        for i, label in enumerate(cells):
+            if label == FREE or totals.get(label, (0, None))[0]:
+                marked.add(i)
+
+    header = "BINGO"[:size] if size <= 5 else "".join(
+        chr(65 + i) for i in range(size))
+    top = "┌" + "┬".join("─" * CELL_W for _ in range(size)) + "┐"
+    mid = "├" + "┼".join("─" * CELL_W for _ in range(size)) + "┤"
+    bot = "└" + "┴".join("─" * CELL_W for _ in range(size)) + "┘"
+
+    out = []
+    out.append("  " + "".join(
+        color(ch.center(CELL_W + 1), BOLD + MAGENTA) for ch in header))
+    out.append("  " + top)
+    for r in range(size):
+        if r:
+            out.append("  " + mid)
+        rows = []
+        for c in range(size):
+            i = r * size + c
+            label = cells[i]
+            count = None if totals is None else totals.get(label, (0, None))[0]
+            if label == FREE:
+                rows.append((["", "FREE", "SPACE", ""], True))
+            else:
+                rows.append((wrap_cell(label, count), i in marked))
+        for line_no in range(4):
+            parts = []
+            for lines, is_marked in rows:
+                text = lines[line_no].center(CELL_W)
+                if is_marked:
+                    text = color(text, GREEN + BOLD)
+                elif totals is not None:
+                    text = color(text, DIM)
+                parts.append(text)
+            out.append("  │" + "│".join(parts) + "│")
+    out.append("  " + bot)
+    return "\n".join(out)
+
+
+def find_bingos(board, marked):
+    size = board["size"]
+    lines = []
+    for r in range(size):
+        lines.append(("row %d" % (r + 1), [r * size + c for c in range(size)]))
+    for c in range(size):
+        name = "BINGO"[c] if size <= 5 else chr(65 + c)
+        lines.append(("col %s" % name, [r * size + c for r in range(size)]))
+    lines.append(("diagonal ↘", [i * size + i for i in range(size)]))
+    lines.append(("diagonal ↙", [i * size + (size - 1 - i) for i in range(size)]))
+    return [name for name, idx in lines if all(i in marked for i in idx)]
+
+
+# ---------------------------------------------------------------- commands
+
+def cmd_board(args):
+    seed = args.seed if args.seed is not None else random.randrange(1 << 30)
+    board = make_board(args.size, seed)
+    path = board_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(board, indent=2) + "\n")
+    print()
+    print(render(board))
+    print()
+    print(color(f"  board #{seed}", DIM) + color(f"  →  {path}", DIM))
+    print(color("  score it:  claude-bingo score", DIM))
+    print()
+
+
+def cmd_score(args):
+    path = board_path()
+    if not path.exists():
+        sys.exit("no board yet — run:  claude-bingo board")
+    board = json.loads(path.read_text())
+    wanted = [c for c in board["cells"] if c != FREE]
+
+    print(color(f"\n  scanning {LOG_ROOT} — last {args.days} days…", DIM),
+          file=sys.stderr)
+    totals, n_files = scan(args.days, wanted, args.jobs)
+
+    print()
+    print(render(board, totals))
+    print()
+
+    marked = {i for i, label in enumerate(board["cells"])
+              if label == FREE or totals.get(label, (0, None))[0]}
+    bingos = find_bingos(board, marked)
+    squares = len(marked)
+    total_hits = sum(c for c, _ in totals.values())
+
+    verdict = (color("BLACKOUT — every square. Seek help.", RED + BOLD)
+               if squares == len(board["cells"])
+               else color("BINGO! " + ", ".join(bingos), GREEN + BOLD)
+               if bingos else color("no bingo — suspiciously well-behaved", YELLOW))
+    print(f"  {verdict}")
+    print(color(f"  {squares}/{len(board['cells'])} squares · {total_hits:,} "
+                f"utterances · {n_files:,} transcripts", DIM))
+    print()
+
+    ranked = sorted(totals.items(), key=lambda kv: -kv[1][0])[:args.top]
+    if ranked:
+        print(color("  ── worst offenders " + "─" * 40, DIM))
+        for label, (count, example) in ranked:
+            if not count:
+                continue
+            print(f"  {color(str(count).rjust(5), CYAN + BOLD)}  "
+                  f"{color(label, BOLD)}")
+            if example and args.quotes:
+                for line in textwrap.wrap(example, 68):
+                    print(color(f"         {line}", DIM))
+        print()
+
+
+def cmd_phrases(args):
+    b = bank()
+    by_category = {}
+    for label in b["labels"]:
+        by_category.setdefault(b["categories"][label], []).append(label)
+
+    if args.category:
+        wanted = {c.lower() for c in args.category}
+        by_category = {k: v for k, v in by_category.items() if k.lower() in wanted}
+        if not by_category:
+            sys.exit("no such category. try:  claude-bingo phrases")
+
+    print()
+    for category, labels in by_category.items():
+        print(f"  {color(category, BOLD + MAGENTA)}")
+        for label in labels:
+            print(f"    {label}")
+        print()
+    print(color(f"  {len(b['labels'])} phrases · bundled: {phrases.BUNDLED}", DIM))
+    print(color(f"  add your own:  {phrases.USER_PHRASES}", DIM))
+    print()
+
+
+def main():
+    p = argparse.ArgumentParser(
+        prog="claude-bingo",
+        description="Bingo for LLM-isms, scored against your Claude transcripts. "
+                    "Reads local logs only; nothing is uploaded.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("board", help="generate a fresh board")
+    b.add_argument("--size", type=int, default=5, help="board dimension (default 5)")
+    b.add_argument("--seed", type=int,
+                   help="reproduce a specific board (only stable for a given "
+                        "phrase bank)")
+    b.set_defaults(func=cmd_board)
+
+    s = sub.add_parser("score", help="score the board against your logs")
+    s.add_argument("--days", type=int, default=7, help="how far back (default 7)")
+    s.add_argument("--top", type=int, default=12, help="offenders to list")
+    s.add_argument("--jobs", type=int, default=min(8, (os.cpu_count() or 4)))
+    s.add_argument("--no-quotes", dest="quotes", action="store_false",
+                   help="skip the receipts")
+    s.set_defaults(func=cmd_score)
+
+    ph = sub.add_parser("phrases", help="list the phrase bank")
+    ph.add_argument("--category", action="append",
+                    help="limit to a category (repeatable)")
+    ph.set_defaults(func=cmd_phrases)
+
+    args = p.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

claude_bingo-0.1.0/claude_bingo/phrases.py

@@ -0,0 +1,66 @@
+"""Loads the phrase bank from TOML.
+
+The bundled bank lives next to this module. Users can add their own in
+$XDG_CONFIG_HOME/claude-bingo/phrases.toml (same format); entries there are
+merged in, and a duplicate label overrides the bundled pattern.
+"""
+
+import os
+import re
+import sys
+import tomllib
+from pathlib import Path
+
+BUNDLED = Path(__file__).parent / "phrases.toml"
+
+
+def _config_dir():
+    base = os.environ.get("XDG_CONFIG_HOME")
+    return Path(base) if base else Path.home() / ".config"
+
+
+USER_PHRASES = _config_dir() / "claude-bingo" / "phrases.toml"
+
+
+def _load_file(path):
+    """Return [(category, label, compiled_pattern)] from one TOML file."""
+    try:
+        with open(path, "rb") as fh:
+            data = tomllib.load(fh)
+    except tomllib.TOMLDecodeError as e:
+        sys.exit(f"{path}: malformed TOML — {e}")
+    except OSError as e:
+        sys.exit(f"{path}: {e.strerror}")
+
+    out = []
+    for category, entries in data.items():
+        if not isinstance(entries, dict):
+            sys.exit(f"{path}: [{category}] must be a table of label = \"regex\"")
+        for label, pattern in entries.items():
+            if not isinstance(pattern, str):
+                sys.exit(f"{path}: [{category}] {label!r} must be a string regex")
+            try:
+                compiled = re.compile(pattern, re.IGNORECASE | re.MULTILINE)
+            except re.error as e:
+                sys.exit(f"{path}: [{category}] {label!r} has a bad regex — {e}")
+            out.append((category, label, compiled))
+    return out
+
+
+def load():
+    entries = _load_file(BUNDLED)
+    if USER_PHRASES.exists():
+        entries += _load_file(USER_PHRASES)
+
+    # Later entries win, but keep first-seen ordering so boards stay stable.
+    by_label, order = {}, []
+    for category, label, pattern in entries:
+        if label not in by_label:
+            order.append(label)
+        by_label[label] = (category, pattern)
+
+    return {
+        "labels": order,
+        "by_label": {label: by_label[label][1] for label in order},
+        "categories": {label: by_label[label][0] for label in order},
+    }

claude_bingo-0.1.0/claude_bingo/phrases.toml

@@ -0,0 +1,96 @@
+# The phrase bank: things Claude says, catalogued for sport.
+#
+# Each entry is  label = "regex".
+#
+# The label is what lands on the board, so it has to read at a glance in a
+# 13-column cell. The regex is what hunts through the logs, so it can be as
+# pedantic as it likes. Patterns are matched case-insensitively and in
+# multiline mode, so ^ anchors to the start of any line.
+#
+# Table names are categories. They don't affect scoring — they're for
+# organising the bank and for `claude-bingo phrases --category`.
+#
+# PRs welcome. Add to an existing category or start a new one.
+
+[sycophancy]
+"You're absolutely right" = "you'?re absolutely right"
+"You're right" = "you'?re (?:so )?right\\b(?! to)"
+"Great question!" = "(?:great|good|excellent) question"
+"Good catch" = "good catch"
+"You're right to push back" = "you'?re right to push back"
+"Perfect!" = "^\\s*perfect[!.]"
+"Excellent!" = "^\\s*excellent[!.]"
+
+[honesty-performance]
+"honest" = "\\b(?:to be honest|honestly|i'?ll be honest|let me be honest)\\b"
+"Let me be direct" = "let me be direct"
+"To be clear" = "to be clear"
+"I want to be careful" = "i want to be (?:careful|precise)"
+"I should be upfront" = "i (?:should|want to) be upfront"
+
+[therapy-register]
+"sit with" = "\\bsit with (?:it|this|that)\\b"
+"that's a real" = "that'?s a real\\b"
+"I hear you" = "i hear you\\b"
+"worth naming" = "worth naming\\b"
+"the tension here" = "the tension (?:here|is)\\b"
+
+[load-bearing-vocabulary]
+"load-bearing" = "load[- ]bearing"
+"does the heavy lifting" = "(?:does|doing) the heavy lifting"
+"single source of truth" = "single source of truth"
+"footgun" = "\\bfootgun"
+"escape hatch" = "escape hatch"
+"happy path" = "happy path"
+"belt and suspenders" = "belt[- ]and[- ]suspenders"
+"blast radius" = "blast radius"
+"surface area" = "surface area"
+"sharp edges" = "sharp edges"
+
+[linkedin-brain]
+"robust" = "\\brobust\\b"
+"seamless" = "\\bseamless(?:ly)?\\b"
+"leverage" = "\\bleverag(?:e|es|ing)\\b"
+"comprehensive" = "\\bcomprehensive\\b"
+"elegant" = "\\belegant(?:ly)?\\b"
+"delve" = "\\bdelv(?:e|es|ing)\\b"
+"nuanced" = "\\bnuanced?\\b"
+"meaningful" = "\\bmeaningful(?:ly)?\\b"
+"crucially" = "\\b(?:crucially|importantly|notably)\\b"
+"tapestry" = "\\btapestry\\b"
+
+[structural-tics]
+"not just X, but Y" = "not (?:just|only) .{3,40}?,? but\\b"
+"It's worth noting" = "it'?s worth noting"
+"Here's the thing" = "here'?s the (?:thing|kicker|rub)"
+"That said," = "\\bthat said,"
+"At the end of the day" = "at the end of the day"
+"The key insight" = "the key (?:insight|question|thing)"
+"Let me" = "^\\s*let me\\b"
+"I'll go ahead and" = "i'?ll go ahead and"
+"Let's dig in" = "let'?s (?:dig in|dive in|take a look)"
+
+[engineering-theater]
+"production-ready" = "production[- ]ready"
+"battle-tested" = "battle[- ]tested"
+"first-class" = "first[- ]class\\b"
+"under the hood" = "under the hood"
+"out of the box" = "out of the box"
+"root cause" = "root cause"
+"sanity check" = "sanity check"
+"surgical" = "\\bsurgical(?:ly)?\\b"
+"idiomatic" = "\\bidiomatic(?:ally)?\\b"
+
+[confession-booth]
+"I apologize" = "i apologi[sz]e"
+"You're absolutely correct" = "you'?re absolutely correct"
+"I made an error" = "i (?:made an error|was wrong|got that wrong)"
+"Let me reconsider" = "let me (?:reconsider|rethink|take another look)"
+"Wait," = "^\\s*wait[,.]"
+"Hmm" = "^\\s*hmm+\\b"
+
+[closers]
+"Let me know if" = "let me know if"
+"Hope this helps" = "hope (?:this|that) helps"
+"Would you like me to" = "would you like me to"
+"Happy to" = "\\bhappy to\\b"

claude_bingo-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "claude-bingo"
+version = "0.1.0"
+description = "Bingo for LLM-isms, scored against your own Claude transcripts."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "Marc Lavallee" }]
+keywords = ["claude", "llm", "bingo", "cli"]
+classifiers = [
+    "Environment :: Console",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Games/Entertainment",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/lavallee/claude-bingo"
+Issues = "https://github.com/lavallee/claude-bingo/issues"
+
+[project.scripts]
+claude-bingo = "claude_bingo.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["claude_bingo"]

claude_bingo-0.1.0/skills/bingo/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: bingo
+description: Play LLM-ism bingo — generate a board of Claude's verbal tics ("delve", "You're absolutely right", "load-bearing") and score it against the user's own local Claude Code transcripts. Use when the user asks to play bingo, wants to see which LLM-isms or verbal tics they've been subjected to, asks how often Claude says a given phrase, or wants their transcripts analysed for slop.
+allowed-tools: Bash(python3 ${CLAUDE_PLUGIN_ROOT}/*)
+---
+
+# Claude Bingo
+
+A 5×5 board of LLM verbal tics, scored against the user's local Claude Code
+transcripts under `~/.claude/projects`.
+
+This is a game. Keep the tone light, and don't get defensive about the results —
+the phrases on the board are things *you* say, and the user finding that funny is
+the entire point.
+
+## Running it
+
+The tool is pure stdlib, so it runs straight from the plugin directory with no
+install step:
+
+```bash
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo board
+```
+
+Generate a fresh board:
+
+```bash
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo board
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo board --size 3
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo board --seed 12345
+```
+
+Score the saved board against recent history:
+
+```bash
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo score
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo score --days 30
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo score --no-quotes
+```
+
+Inspect the phrase bank:
+
+```bash
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo phrases
+PYTHONPATH="${CLAUDE_PLUGIN_ROOT}" python3 -m claude_bingo phrases --category linkedin-brain
+```
+
+## How to respond
+
+- The output is already formatted for a terminal — box-drawing board, colour,
+  a ranked "worst offenders" list with real quotes. **Show it as-is** in a code
+  block. Don't re-render the board as a markdown table or re-summarise every
+  cell; that throws away the thing the user asked for.
+- Add a short reaction after the output, not before it.
+- If there's no board yet, `score` will say so. Run `board` first, then score.
+- `score` walks every transcript in the window, so a wide `--days` on a heavy
+  user takes a few seconds. That's expected.
+
+## Adding phrases
+
+The bank is TOML at `${CLAUDE_PLUGIN_ROOT}/claude_bingo/phrases.toml`. Users can
+add their own without touching the plugin, in
+`~/.config/claude-bingo/phrases.toml`:
+
+```toml
+[my-category]
+"the label on the board" = "the regex that hunts for it"
+```
+
+Patterns are matched case-insensitively and in multiline mode. A label that
+collides with a bundled one overrides its pattern.
+
+## Privacy
+
+Everything is local. The tool reads transcript files and prints to the terminal;
+it makes no network calls. If a user asks what it touches, the honest answer is
+`~/.claude/projects/**/*.jsonl`, read-only.