claude-scope 0.8.16 → 0.8.20

package/README.md

@@ -1,37 +1,77 @@
-# claude-scope
+<div align="center">
 
-Claude Code plugin for session status and analytics.
+  <img src="https://cdn.jsdelivr.net/gh/devicons/devicon/icons/typescript/typescript-original.svg" alt="TypeScript" width="80" height="80"/>
 
-**Requirements:**
-- Node.js 18 or higher
+  # claude-scope
 
-## Installation
+  ### Beautiful, customizable statusline for Claude Code CLI
 
-### Via npx (recommended)
+  [![npm version](https://badge.fury.io/js/claude-scope.svg)](https://www.npmjs.com/package/claude-scope)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.md)
+  [![Node.js Version](https://img.shields.io/node/v/claude-scope.svg)](https://github.com/YuriNachos/claude-scope)
+  [![GitHub Stars](https://img.shields.io/github/stars/YuriNachos/claude-scope?style=social)](https://github.com/YuriNachos/claude-scope)
+  [![codecov](https://codecov.io/gh/YuriNachos/claude-scope/branch/main/graph/badge.svg)](https://codecov.io/gh/YuriNachos/claude-scope)
 
-No installation required:
+  **Features** · [Installation](#-quick-start) · [Configuration](#-ai-powered-customization) · [Widgets](#-available-widgets) · [Themes](#-themes)
 
-```bash
-npx claude-scope@latest
-```
+</div>
 
-### Via npm globally
+---
 
-```bash
-npm install -g claude-scope
+<p align="center">
+  <i>Real-time session analytics in your terminal — zero runtime dependencies, 14 widgets, 17 themes</i>
+</p>
+
+---
+
+## What is it?
+
+**claude-scope** is a CLI plugin for [Claude Code](https://claude.ai/code) that displays real-time session information directly in your statusline. Track your context usage, session cost, git status, active tools, and more — all with beautiful customizable themes.
+
+- **Zero runtime dependencies** — pure TypeScript, native Node.js only
+- **14 customizable widgets** — model, context, cost, git, docker, and more
+- **17 built-in themes** — from Dracula to Nord to Cyberpunk
+- **12 display styles** — balanced, playful, compact, verbose, technical...
+- **AI-friendly configuration** — just ask Claude to customize it!
+
+---
+
+## Preview
+
+See how claude-scope looks with different themes:
+
+**Dracula Theme** (default)
+```
+Claude Opus 4.5  |  67% [████████]  |  +127/-42  |  $1.24  |  2h 15m
+main [+127 -42]  |  v0.8.16  |  💾 45.2k  |  📄 1 📜 2 🔌 3 🪝 2
+⚡ Nuxt (running)  |  🐳 3/5 🟢  |  Edits: 8 | Bash: 3 | Read: 12
 ```
 
-### Via bun
+**Tokyo Night Theme**
+```
+Claude Opus 4.5  |  67% [████████]  |  +127/-42  |  $1.24  |  2h 15m
+main [+127 -42]  |  v0.8.16  |  💾 45.2k  |  📄 1 📜 2 🔌 3 🪝 2
+⚡ Nuxt (running)  |  🐳 3/5 🟢  |  Edits: 8 | Bash: 3 | Read: 12
+```
 
-```bash
-bunx claude-scope@latest
+**Nord Theme**
+```
+Claude Opus 4.5  |  67% [████████]  |  +127/-42  |  $1.24  |  2h 15m
+main [+127 -42]  |  v0.8.16  |  💾 45.2k  |  📄 1 📜 2 🔌 3 🪝 2
+⚡ Nuxt (running)  |  🐳 3/5 🟢  |  Edits: 8 | Bash: 3 | Read: 12
 ```
 
-## Configuration
+---
 
-Add to your `~/.claude/settings.json`:
+## Quick Start
 
-```json
+Get up and running in 30 seconds:
+
+```bash
+# 1. Install via npx (no installation required)
+npx -y claude-scope@latest
+
+# 2. Add to your ~/.claude/settings.json
 {
   "statusLine": {
     "type": "command",
@@ -39,95 +79,196 @@ Add to your `~/.claude/settings.json`:
     "padding": 0
   }
 }
+
+# 3. Restart Claude Code — you're done! 🎉
 ```
 
-Or for global install:
+After the first run, a default config is automatically created at `~/.claude-scope/config.json` with:
+- **Layout**: `rich` (3 lines)
+- **Style**: `balanced`
+- **Theme**: `dracula`
+
+---
+
+## 🤖 AI-Powered Customization
+
+**claude-scope is built to work with AI!** Simply ask Claude to customize it:
+
+```
+➕ "Add the docker widget to the third line"
+🎨 "Switch theme to nord"
+😄 "Make it more playful"
+🎯 "Show only model and context"
+```
+
+**Example dialogue:**
+
+> **User:** Add poker widget and make everything playful
+>
+> **Claude:** Sure! Adding poker widget and changing styles to playful...
+>
+> ✅ Done! Your statusline now shows poker hands with emojis.
+
+Claude will automatically modify `~/.claude-scope/config.json` — changes take effect instantly.
+
+**How it works:**
+- Config contains `$aiDocs` field linking to [AI-CONFIG-GUIDE](AI-CONFIG-GUIDE.md)
+- AI understands all 14 widgets, 12 styles, and 17 themes
+- Just say what you want — no manual editing needed
+
+---
+
+## Available Widgets
+
+| Widget | Description | Balanced | Playful |
+|--------|-------------|----------|---------|
+| **model** | Current Claude model | `Claude Opus 4.5` | `🤖 Opus 4.5` |
+| **context** | Context usage with progress bar | `45% [████████░░░░░░░░░]` | `📊 45% [████████░░░░░░░░░]` |
+| **cost** | Session cost in USD | `$0.42` | `💰 $0.42` |
+| **duration** | Session duration | `1h 15m 30s` | `⌛ 1h 15m` |
+| **lines** | Lines added/removed | `+42/-18` | `➕42 ➖18` |
+| **git** | Git branch and changes | `main [+42 -18]` | `🔀 main ⬆42 ⬇18` |
+| **git-tag** | Latest git tag | `v0.8.16` | `🏷️ v0.8.16` |
+| **config-count** | Config file counts | `📄 1 CLAUDE.md │ 📜 2 rules │ 🔌 3 MCPs` | — |
+| **cache-metrics** | Cache statistics | `💾 35.0k cache` | `💾 35.0k cache` |
+| **active-tools** | Active tools tracking | `Edits: 5 │ Bash: 3 │ Read: 2` | `✏️ Edit 📖 Read 🐚 Bash` |
+| **dev-server** | Dev server status | `⚡ Nuxt (running)` | `🏃 Nuxt` |
+| **docker** | Docker containers | `Docker: 3/5 🟢` | `🐳 Docker: 3/5 🟢` |
+| **poker** | Poker hands (easter egg) | `Hand: A♠ K♠ │ One Pair!` | `🃏 A♠️ K♠️ │ One Pair!` |
+
+### Layout Presets
+
+| Preset | Lines | Widgets |
+|--------|-------|---------|
+| **Rich** (default) | 3 | Line 0: model, context, lines, cost, duration<br>Line 1: git, git-tag, cache-metrics, config-count<br>Line 2: dev-server, docker, active-tools |
+| **Balanced** | 2 | Line 0: model, context, lines, cost, duration<br>Line 1: git, git-tag, cache-metrics, config-count |
+| **Compact** | 1 | Line 0: model, context, cost, git, duration |
+
+---
+
+## Themes
+
+**Built-in themes** — from classic to futuristic:
+
+| Theme | Style | Colors |
+|-------|-------|--------|
+| `dracula` | Popular | Purple, pink, green |
+| `tokyo-night` | Modern | Blue, yellow, green |
+| `nord` | Cool | Arctic blues |
+| `monokai` | Vibrant | **DEFAULT** — bright accents |
+| `catppuccin-mocha` | Pastel | Soft dreamy colors |
+| `github-dark-dimmed` | Standard | GitHub's official dark |
+| `vscode-dark-plus` | Standard | VSCode's default |
+| `one-dark-pro` | IDE | Atom's iconic theme |
+| `solarized-dark` | Classic | Precise CIELAB lightness |
+| `rose-pine` | Pastel | Rose/violet themed |
+| `cyberpunk-neon` | Vibrant | Cyberpunk 2077 neon |
+| `professional-blue` | Professional | Business-oriented blue |
+| `gray` | Minimal | Neutral gray, minimal |
+| `muted-gray` | Muted | Very subtle grays |
+| `slate-blue` | Muted | Calm blue-grays |
+| `dusty-sage` | Muted | Earthy greens |
+| `semantic-classic` | Intuitive | Industry-standard colors |
+
+---
+
+## Configuration
+
+### Quick Config
+
+Interactive configuration menu:
+
+```bash
+claude-scope quick-config
+```
+
+Choose from:
+- **Layout**: Rich (3 lines), Balanced (2 lines), Compact (1 line)
+- **Theme**: 17 themes with live preview
+- **Style**: balanced, playful, compact, verbose, technical...
+
+### Manual Configuration
+
+Edit `~/.claude-scope/config.json` directly:
 
 ```json
 {
-  "statusLine": {
-    "type": "command",
-    "command": "claude-scope",
-    "padding": 0
+  "version": "1.0.0",
+  "$aiDocs": "https://github.com/YuriNachos/claude-scope/blob/main/AI-CONFIG-GUIDE.md",
+  "lines": {
+    "0": [
+      { "id": "model", "style": "balanced", "colors": { "name": "\\u001b[38;2;189;147;229m" } },
+      { "id": "context", "style": "balanced", "colors": { "low": "...", "medium": "...", "high": "..." } }
+    ]
   }
 }
 ```
 
-## Usage
+See [AI-CONFIG-GUIDE](AI-CONFIG-GUIDE.md) for complete configuration reference.
 
-Once configured, claude-scope displays real-time session information in your statusline including:
-- Git branch and changes
-- Model information
-- Context usage with progress bar
-- Session duration
-- Cost estimation
-- Lines added/removed
-- Configuration counts
-- Poker hand (entertainment)
+---
 
-### Widget Display Styles
+## Advanced Features
 
-Each widget supports multiple display styles for customization:
+<details>
+<summary><b>Zero Runtime Dependencies</b></summary>
 
-| Style | Description |
-|-------|-------------|
-| `balanced` | Default balanced style (minimalism + informativeness) |
-| `compact` | Maximally compact display |
-| `playful` | Fun style with informative emojis |
-| `verbose` | Detailed text descriptions |
-| `technical` | Technical details (model IDs, milliseconds, etc.) |
-| `symbolic` | Symbol-based representation |
-| `labeled` | Prefix labels for clarity |
-| `indicator` | Bullet indicator prefix |
-| `fancy` | Decorative formatting (brackets, quotes) |
-| `compact-verbose` | Compact with K-formatted numbers |
+claude-scope is written in pure TypeScript and uses only native Node.js modules. No external runtime dependencies — maximum performance and security.
+</details>
 
-**Note:** This is an early release with basic functionality. Additional features (repository status, session analytics, etc.) are planned for future releases.
+<details>
+<summary><b>Layout & Line System</b></summary>
 
-## Quick Config
+- **Line 0**: Primary info (model, context, cost, duration, lines, git, dev-server, docker)
+- **Line 1**: Extended (git-tag, config-count)
+- **Line 2**: Activity (cache-metrics, active-tools)
+- **Line 4**: Poker widget (easter egg)
+- **Line 5**: Empty line widget
+</details>
 
-Interactive configuration for widget style and theme:
+<details>
+<summary><b>Widget System</b></summary>
 
-```bash
-claude-scope quick-config
-```
+Each widget implements the `IWidget` interface with lifecycle methods:
+- `initialize()` — Set up the widget
+- `render()` — Generate output
+- `update()` — Handle new data
+- `isEnabled()` — Check if active
 
-This will launch an interactive menu where you can:
-1. Choose display style: balanced, playful, or compact
-2. Choose from 17 available themes
-3. See live preview as you make selections
+Widgets gracefully degrade on errors — if something fails, it returns `null`.
+</details>
 
-Configuration is saved to `~/.claude-scope/config.json`.
+---
 
-### Styles
+## Documentation
 
-- **Balanced**: Clean display with labels (default)
-- **Playful**: Fun display with emojis
-- **Compact**: Minimal, condensed display
+| Topic | Link |
+|-------|------|
+| Architecture, data flow, providers | [ARCHITECTURE.md](docs/ARCHITECTURE.md) |
+| All widgets, styles, examples | [WIDGETS.md](docs/WIDGETS.md) |
+| Theme system, customization | [THEME-SYSTEM.md](docs/THEME-SYSTEM.md) |
+| Formatters, ANSI colors | [FORMATTERS.md](docs/FORMATTERS.md) |
+| Version history, roadmap | [CHANGELOG.md](docs/CHANGELOG.md) |
 
-### Themes
+---
 
-17 built-in themes available: monokai, nord, dracula, dusty-sage, catppuccin-mocha, cyberpunk-neon, github-dark-dimmed, gray, muted-gray, one-dark-pro, professional-blue, rose-pine, semantic-classic, slate-blue, solarized-dark, tokyo-night, vscode-dark-plus.
+## Requirements
 
-## Releasing
+- **Node.js** 18 or higher
+- **Claude Code** CLI
 
-To create a new release:
+---
 
-1. Update version in `package.json`
-2. Commit changes
-3. Create and push tag:
+## License
 
-```bash
-git tag v0.1.0
-git push origin main
-git push origin v0.1.0
-```
+[MIT](LICENSE.md) — feel free to use this project in your own work!
+
+---
+
+<div align="center">
+
+  **Made with ❤️ by [YuriNachos](https://github.com/YuriNachos)**
 
-The GitHub Actions workflow will:
-- Run all tests
-- Build the project
-- Generate coverage report
-- Commit `dist/` to repository
-- Create GitHub Release with auto-generated notes
+  [GitHub](https://github.com/YuriNachos/claude-scope) · [Issues](https://github.com/YuriNachos/claude-scope/issues) · [Contributing](CONTRIBUTING.md)
 
-**Note:** If tests fail, the release will not be created.
+</div>

package/dist/claude-scope.cjs

@@ -38,12 +38,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 function colorize(text, color) {
   return `${color}${text}${reset}`;
 }
-var reset, gray;
+var reset, red, gray, lightGray, bold;
 var init_colors = __esm({
   "src/ui/utils/colors.ts"() {
     "use strict";
     reset = "\x1B[0m";
+    red = "\x1B[31m";
     gray = "\x1B[90m";
+    lightGray = "\x1B[37m";
+    bold = "\x1B[1m";
   }
 });
 
@@ -1378,7 +1381,7 @@ var init_theme = __esm({
 });
 
 // src/constants.ts
-var TIME, DEFAULTS, DEMO_DATA, DEFAULT_PROGRESS_BAR_WIDTH;
+var TIME, DEFAULTS, ANSI_COLORS, DEMO_DATA, DEFAULT_PROGRESS_BAR_WIDTH;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -1396,6 +1399,16 @@ var init_constants = __esm({
       /** Default width for progress bars in characters */
       PROGRESS_BAR_WIDTH: 20
     };
+    ANSI_COLORS = {
+      /** Green color */
+      GREEN: "\x1B[32m",
+      /** Yellow color */
+      YELLOW: "\x1B[33m",
+      /** Red color */
+      RED: "\x1B[31m",
+      /** Reset color */
+      RESET: "\x1B[0m"
+    };
     DEMO_DATA = {
       /** Demo session cost in USD */
       COST_USD: 0.42,
@@ -1516,24 +1529,27 @@ var init_widget_registry = __esm({
   "src/core/widget-registry.ts"() {
     "use strict";
     WidgetRegistry = class {
-      widgets = /* @__PURE__ */ new Map();
+      widgets = [];
       /**
        * Register a widget
        */
       async register(widget, context) {
-        if (this.widgets.has(widget.id)) {
-          throw new Error(`Widget with id '${widget.id}' already registered`);
-        }
         if (context) {
           await widget.initialize(context);
         }
-        this.widgets.set(widget.id, widget);
+        this.widgets.push(widget);
       }
       /**
        * Unregister a widget
+       * @param widgetOrId Widget instance or widget id
        */
-      async unregister(id) {
-        const widget = this.widgets.get(id);
+      async unregister(widgetOrId) {
+        let widget;
+        if (typeof widgetOrId === "string") {
+          widget = this.widgets.find((w) => w.id === widgetOrId);
+        } else {
+          widget = this.widgets.find((w) => w === widgetOrId);
+        }
         if (!widget) {
           return;
         }
@@ -1542,26 +1558,29 @@ var init_widget_registry = __esm({
             await widget.cleanup();
           }
         } finally {
-          this.widgets.delete(id);
+          const index = this.widgets.indexOf(widget);
+          if (index !== -1) {
+            this.widgets.splice(index, 1);
+          }
         }
       }
       /**
        * Get a widget by id
        */
       get(id) {
-        return this.widgets.get(id);
+        return this.widgets.find((w) => w.id === id);
       }
       /**
        * Check if widget is registered
        */
       has(id) {
-        return this.widgets.has(id);
+        return this.widgets.some((w) => w.id === id);
       }
       /**
        * Get all registered widgets
        */
       getAll() {
-        return Array.from(this.widgets.values());
+        return [...this.widgets];
       }
       /**
        * Get only enabled widgets
@@ -1573,12 +1592,12 @@ var init_widget_registry = __esm({
        * Clear all widgets
        */
       async clear() {
-        for (const widget of this.widgets.values()) {
+        for (const widget of this.widgets) {
           if (widget.cleanup) {
             await widget.cleanup();
           }
         }
-        this.widgets.clear();
+        this.widgets = [];
       }
     };
   }
@@ -2349,6 +2368,9 @@ function formatDuration(ms) {
 function formatCostUSD(usd) {
   return `$${usd.toFixed(2)}`;
 }
+function colorize2(text, color) {
+  return `${color}${text}${ANSI_COLORS.RESET}`;
+}
 function formatK(n) {
   const absN = Math.abs(n);
   if (absN < 1e3) {
@@ -7489,6 +7511,7 @@ function generateBalancedLayout(style, themeName) {
   const theme = getThemeByName(themeName).colors;
   return {
     version: "1.0.0",
+    $aiDocs: "https://github.com/YuriNachos/claude-scope/blob/main/AI-CONFIG-GUIDE.md",
     lines: {
       "0": [
         {
@@ -7557,6 +7580,7 @@ function generateCompactLayout(style, themeName) {
   const theme = getThemeByName(themeName).colors;
   return {
     version: "1.0.0",
+    $aiDocs: "https://github.com/YuriNachos/claude-scope/blob/main/AI-CONFIG-GUIDE.md",
     lines: {
       "0": [
         {
@@ -7597,6 +7621,7 @@ function generateRichLayout(style, themeName) {
   const theme = getThemeByName(themeName).colors;
   return {
     version: "1.0.0",
+    $aiDocs: "https://github.com/YuriNachos/claude-scope/blob/main/AI-CONFIG-GUIDE.md",
     lines: {
       "0": [
         {
@@ -8063,6 +8088,9 @@ async function ensureDefaultConfig() {
 
 // src/config/config-loader.ts
 function getConfigPath() {
+  if (process.env.CLAUDE_SCOPE_CONFIG) {
+    return process.env.CLAUDE_SCOPE_CONFIG;
+  }
   return (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".claude-scope", "config.json");
 }
 async function loadWidgetConfig() {
@@ -8109,10 +8137,704 @@ init_docker_widget();
 
 // src/core/widget-factory.ts
 init_duration_widget();
+
+// src/widgets/empty-line-widget.ts
+init_widget_types();
+init_stdin_data_widget();
+var EmptyLineWidget = class extends StdinDataWidget {
+  id = "empty-line";
+  metadata = createWidgetMetadata(
+    "Empty Line",
+    "Empty line separator",
+    "1.0.0",
+    "claude-scope",
+    5
+    // Sixth line (0-indexed)
+  );
+  _lineOverride;
+  /**
+   * All styles return the same value (Braille Pattern Blank).
+   * This method exists for API consistency with other widgets.
+   */
+  setStyle(_style) {
+  }
+  setLine(line) {
+    this._lineOverride = line;
+  }
+  getLine() {
+    return this._lineOverride ?? this.metadata.line ?? 0;
+  }
+  /**
+   * Return Braille Pattern Blank to create a visible empty separator line.
+   * U+2800 occupies cell width but appears blank, ensuring the line renders.
+   */
+  renderWithData(_data, _context) {
+    return "\u2800";
+  }
+};
+
+// src/core/widget-factory.ts
 init_git_tag_widget();
 init_git_widget();
 init_lines_widget();
 init_model_widget();
+
+// src/widgets/poker-widget.ts
+init_style_types();
+init_widget_types();
+init_theme();
+init_stdin_data_widget();
+
+// src/widgets/poker/deck.ts
+var import_node_crypto = require("node:crypto");
+
+// src/widgets/poker/types.ts
+var Suit = {
+  Spades: "spades",
+  Hearts: "hearts",
+  Diamonds: "diamonds",
+  Clubs: "clubs"
+};
+var SUIT_SYMBOLS = {
+  spades: "\u2660",
+  hearts: "\u2665",
+  diamonds: "\u2666",
+  clubs: "\u2663"
+};
+var EMOJI_SYMBOLS = {
+  spades: "\u2660\uFE0F",
+  // ♠️
+  hearts: "\u2665\uFE0F",
+  // ♥️
+  diamonds: "\u2666\uFE0F",
+  // ♦️
+  clubs: "\u2663\uFE0F"
+  // ♣️
+};
+function isRedSuit(suit) {
+  return suit === "hearts" || suit === "diamonds";
+}
+var Rank = {
+  Two: "2",
+  Three: "3",
+  Four: "4",
+  Five: "5",
+  Six: "6",
+  Seven: "7",
+  Eight: "8",
+  Nine: "9",
+  Ten: "10",
+  Jack: "J",
+  Queen: "Q",
+  King: "K",
+  Ace: "A"
+};
+function getRankValue(rank) {
+  const values = {
+    "2": 2,
+    "3": 3,
+    "4": 4,
+    "5": 5,
+    "6": 6,
+    "7": 7,
+    "8": 8,
+    "9": 9,
+    "10": 10,
+    J: 11,
+    Q: 12,
+    K: 13,
+    A: 14
+  };
+  return values[rank];
+}
+function formatCard(card) {
+  return `${card.rank}${SUIT_SYMBOLS[card.suit]}`;
+}
+function formatCardEmoji(card) {
+  return `${card.rank}${EMOJI_SYMBOLS[card.suit]}`;
+}
+
+// src/widgets/poker/deck.ts
+var ALL_SUITS = [Suit.Spades, Suit.Hearts, Suit.Diamonds, Suit.Clubs];
+var ALL_RANKS = [
+  Rank.Two,
+  Rank.Three,
+  Rank.Four,
+  Rank.Five,
+  Rank.Six,
+  Rank.Seven,
+  Rank.Eight,
+  Rank.Nine,
+  Rank.Ten,
+  Rank.Jack,
+  Rank.Queen,
+  Rank.King,
+  Rank.Ace
+];
+var Deck = class {
+  cards = [];
+  constructor() {
+    this.initialize();
+    this.shuffle();
+  }
+  /**
+   * Create a standard 52-card deck
+   */
+  initialize() {
+    this.cards = [];
+    for (const suit of ALL_SUITS) {
+      for (const rank of ALL_RANKS) {
+        this.cards.push({ rank, suit });
+      }
+    }
+  }
+  /**
+   * Shuffle deck using Fisher-Yates algorithm with crypto.random
+   */
+  shuffle() {
+    for (let i = this.cards.length - 1; i > 0; i--) {
+      const j = (0, import_node_crypto.randomInt)(0, i + 1);
+      [this.cards[i], this.cards[j]] = [this.cards[j], this.cards[i]];
+    }
+  }
+  /**
+   * Deal one card from the top of the deck
+   * @throws Error if deck is empty
+   */
+  deal() {
+    if (this.cards.length === 0) {
+      throw new Error("Deck is empty");
+    }
+    return this.cards.pop();
+  }
+  /**
+   * Get number of remaining cards in deck
+   */
+  remaining() {
+    return this.cards.length;
+  }
+};
+
+// src/widgets/poker/hand-evaluator.ts
+var HAND_DISPLAY = {
+  [10 /* RoyalFlush */]: { name: "Royal Flush", emoji: "\u{1F3C6}" },
+  [9 /* StraightFlush */]: { name: "Straight Flush", emoji: "\u{1F525}" },
+  [8 /* FourOfAKind */]: { name: "Four of a Kind", emoji: "\u{1F48E}" },
+  [7 /* FullHouse */]: { name: "Full House", emoji: "\u{1F3E0}" },
+  [6 /* Flush */]: { name: "Flush", emoji: "\u{1F4A7}" },
+  [5 /* Straight */]: { name: "Straight", emoji: "\u{1F4C8}" },
+  [4 /* ThreeOfAKind */]: { name: "Three of a Kind", emoji: "\u{1F3AF}" },
+  [3 /* TwoPair */]: { name: "Two Pair", emoji: "\u270C\uFE0F" },
+  [2 /* OnePair */]: { name: "One Pair", emoji: "\u{1F44D}" },
+  [1 /* HighCard */]: { name: "High Card", emoji: "\u{1F0CF}" }
+};
+function countRanks(cards) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    const value = getRankValue(card.rank);
+    counts.set(value, (counts.get(value) || 0) + 1);
+  }
+  return counts;
+}
+function countSuits(cards) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    counts.set(card.suit, (counts.get(card.suit) || 0) + 1);
+  }
+  return counts;
+}
+function findCardsOfRank(cards, targetRank) {
+  const indices = [];
+  for (let i = 0; i < cards.length; i++) {
+    if (getRankValue(cards[i].rank) === targetRank) {
+      indices.push(i);
+    }
+  }
+  return indices;
+}
+function findCardsOfSuit(cards, targetSuit) {
+  const indices = [];
+  for (let i = 0; i < cards.length; i++) {
+    if (cards[i].suit === targetSuit) {
+      indices.push(i);
+    }
+  }
+  return indices;
+}
+function findFlushSuit(cards) {
+  const suitCounts = countSuits(cards);
+  for (const [suit, count] of suitCounts.entries()) {
+    if (count >= 5) return suit;
+  }
+  return null;
+}
+function getStraightIndices(cards, highCard) {
+  const uniqueValues = /* @__PURE__ */ new Set();
+  const cardIndicesByRank = /* @__PURE__ */ new Map();
+  for (let i = 0; i < cards.length; i++) {
+    const value = getRankValue(cards[i].rank);
+    if (!cardIndicesByRank.has(value)) {
+      cardIndicesByRank.set(value, []);
+      uniqueValues.add(value);
+    }
+    cardIndicesByRank.get(value)?.push(i);
+  }
+  const sortedValues = Array.from(uniqueValues).sort((a, b) => b - a);
+  if (sortedValues.includes(14)) {
+    sortedValues.push(1);
+  }
+  for (let i = 0; i <= sortedValues.length - 5; i++) {
+    const current = sortedValues[i];
+    const next1 = sortedValues[i + 1];
+    const next2 = sortedValues[i + 2];
+    const next3 = sortedValues[i + 3];
+    const next4 = sortedValues[i + 4];
+    if (current - next1 === 1 && current - next2 === 2 && current - next3 === 3 && current - next4 === 4) {
+      if (current === highCard) {
+        const indices = [];
+        indices.push(cardIndicesByRank.get(current)[0]);
+        indices.push(cardIndicesByRank.get(next1)[0]);
+        indices.push(cardIndicesByRank.get(next2)[0]);
+        indices.push(cardIndicesByRank.get(next3)[0]);
+        const rank4 = next4 === 1 ? 14 : next4;
+        indices.push(cardIndicesByRank.get(rank4)[0]);
+        return indices;
+      }
+    }
+  }
+  return [];
+}
+function getStraightFlushHighCard(cards, suit) {
+  const suitCards = cards.filter((c) => c.suit === suit);
+  return getStraightHighCard(suitCards);
+}
+function getStraightFlushIndices(cards, highCard, suit) {
+  const _suitCards = cards.filter((c) => c.suit === suit);
+  const suitCardIndices = [];
+  const indexMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < cards.length; i++) {
+    if (cards[i].suit === suit) {
+      indexMap.set(suitCardIndices.length, i);
+      suitCardIndices.push(cards[i]);
+    }
+  }
+  const indices = getStraightIndices(suitCardIndices, highCard);
+  return indices.map((idx) => indexMap.get(idx));
+}
+function getFullHouseIndices(cards) {
+  const rankCounts = countRanks(cards);
+  let tripsRank = 0;
+  for (const [rank, count] of rankCounts.entries()) {
+    if (count === 3) {
+      tripsRank = rank;
+      break;
+    }
+  }
+  let pairRank = 0;
+  for (const [rank, count] of rankCounts.entries()) {
+    if (count >= 2 && rank !== tripsRank) {
+      pairRank = rank;
+      break;
+    }
+  }
+  if (pairRank === 0) {
+    const tripsRanks = [];
+    for (const [rank, count] of rankCounts.entries()) {
+      if (count === 3) {
+        tripsRanks.push(rank);
+      }
+    }
+    if (tripsRanks.length >= 2) {
+      tripsRanks.sort((a, b) => b - a);
+      tripsRank = tripsRanks[0];
+      pairRank = tripsRanks[1];
+    }
+  }
+  const tripsIndices = findCardsOfRank(cards, tripsRank);
+  const pairIndices = findCardsOfRank(cards, pairRank);
+  return [...tripsIndices.slice(0, 3), ...pairIndices.slice(0, 2)];
+}
+function isFlush(cards) {
+  const suitCounts = countSuits(cards);
+  for (const count of suitCounts.values()) {
+    if (count >= 5) return true;
+  }
+  return false;
+}
+function getStraightHighCard(cards) {
+  const uniqueValues = /* @__PURE__ */ new Set();
+  for (const card of cards) {
+    uniqueValues.add(getRankValue(card.rank));
+  }
+  const sortedValues = Array.from(uniqueValues).sort((a, b) => b - a);
+  if (sortedValues.includes(14)) {
+    sortedValues.push(1);
+  }
+  for (let i = 0; i <= sortedValues.length - 5; i++) {
+    const current = sortedValues[i];
+    const next1 = sortedValues[i + 1];
+    const next2 = sortedValues[i + 2];
+    const next3 = sortedValues[i + 3];
+    const next4 = sortedValues[i + 4];
+    if (current - next1 === 1 && current - next2 === 2 && current - next3 === 3 && current - next4 === 4) {
+      return current;
+    }
+  }
+  return null;
+}
+function getMaxCount(cards) {
+  const rankCounts = countRanks(cards);
+  let maxCount = 0;
+  for (const count of rankCounts.values()) {
+    if (count > maxCount) {
+      maxCount = count;
+    }
+  }
+  return maxCount;
+}
+function getPairCount(cards) {
+  const rankCounts = countRanks(cards);
+  let pairCount = 0;
+  for (const count of rankCounts.values()) {
+    if (count === 2) {
+      pairCount++;
+    }
+  }
+  return pairCount;
+}
+function getMostCommonRank(cards) {
+  const rankCounts = countRanks(cards);
+  let bestRank = 0;
+  let bestCount = 0;
+  for (const [rank, count] of rankCounts.entries()) {
+    if (count > bestCount) {
+      bestCount = count;
+      bestRank = rank;
+    }
+  }
+  return bestRank > 0 ? bestRank : null;
+}
+function getTwoPairRanks(cards) {
+  const rankCounts = countRanks(cards);
+  const pairRanks = [];
+  for (const [rank, count] of rankCounts.entries()) {
+    if (count >= 2) {
+      pairRanks.push(rank);
+    }
+  }
+  pairRanks.sort((a, b) => b - a);
+  return pairRanks.slice(0, 2);
+}
+function getHighestCardIndex(cards) {
+  let highestIdx = 0;
+  let highestValue = 0;
+  for (let i = 0; i < cards.length; i++) {
+    const value = getRankValue(cards[i].rank);
+    if (value > highestValue) {
+      highestValue = value;
+      highestIdx = i;
+    }
+  }
+  return highestIdx;
+}
+function evaluateHand(hole, board) {
+  const allCards = [...hole, ...board];
+  const flush = isFlush(allCards);
+  const straightHighCard = getStraightHighCard(allCards);
+  const maxCount = getMaxCount(allCards);
+  const pairCount = getPairCount(allCards);
+  if (flush && straightHighCard === 14) {
+    const flushSuit = findFlushSuit(allCards);
+    const sfHighCard = getStraightFlushHighCard(allCards, flushSuit);
+    if (sfHighCard === 14) {
+      const participatingCards = getStraightFlushIndices(allCards, 14, flushSuit);
+      return {
+        rank: 10 /* RoyalFlush */,
+        ...HAND_DISPLAY[10 /* RoyalFlush */],
+        participatingCards
+      };
+    }
+  }
+  if (flush) {
+    const flushSuit = findFlushSuit(allCards);
+    const sfHighCard = getStraightFlushHighCard(allCards, flushSuit);
+    if (sfHighCard !== null) {
+      const participatingCards = getStraightFlushIndices(allCards, sfHighCard, flushSuit);
+      return {
+        rank: 9 /* StraightFlush */,
+        ...HAND_DISPLAY[9 /* StraightFlush */],
+        participatingCards
+      };
+    }
+  }
+  if (maxCount === 4) {
+    const rank = getMostCommonRank(allCards);
+    const participatingCards = findCardsOfRank(allCards, rank);
+    return {
+      rank: 8 /* FourOfAKind */,
+      ...HAND_DISPLAY[8 /* FourOfAKind */],
+      participatingCards
+    };
+  }
+  if (maxCount === 3 && pairCount >= 1) {
+    const participatingCards = getFullHouseIndices(allCards);
+    return { rank: 7 /* FullHouse */, ...HAND_DISPLAY[7 /* FullHouse */], participatingCards };
+  }
+  if (flush) {
+    const flushSuit = findFlushSuit(allCards);
+    const suitIndices = findCardsOfSuit(allCards, flushSuit);
+    const participatingCards = suitIndices.slice(0, 5);
+    return { rank: 6 /* Flush */, ...HAND_DISPLAY[6 /* Flush */], participatingCards };
+  }
+  if (straightHighCard !== null) {
+    const participatingCards = getStraightIndices(allCards, straightHighCard);
+    return { rank: 5 /* Straight */, ...HAND_DISPLAY[5 /* Straight */], participatingCards };
+  }
+  if (maxCount === 3) {
+    const rank = getMostCommonRank(allCards);
+    const participatingCards = findCardsOfRank(allCards, rank);
+    return {
+      rank: 4 /* ThreeOfAKind */,
+      ...HAND_DISPLAY[4 /* ThreeOfAKind */],
+      participatingCards
+    };
+  }
+  if (pairCount >= 2) {
+    const [rank1, rank2] = getTwoPairRanks(allCards);
+    const pair1Indices = findCardsOfRank(allCards, rank1);
+    const pair2Indices = findCardsOfRank(allCards, rank2);
+    const participatingCards = [...pair1Indices, ...pair2Indices];
+    return { rank: 3 /* TwoPair */, ...HAND_DISPLAY[3 /* TwoPair */], participatingCards };
+  }
+  if (pairCount === 1) {
+    const rank = getMostCommonRank(allCards);
+    const participatingCards = findCardsOfRank(allCards, rank);
+    return { rank: 2 /* OnePair */, ...HAND_DISPLAY[2 /* OnePair */], participatingCards };
+  }
+  const highestIdx = getHighestCardIndex(allCards);
+  return {
+    rank: 1 /* HighCard */,
+    ...HAND_DISPLAY[1 /* HighCard */],
+    participatingCards: [highestIdx]
+  };
+}
+
+// src/widgets/poker/styles.ts
+init_colors();
+init_formatters();
+var HAND_ABBREVIATIONS = {
+  "Royal Flush": "RF",
+  "Straight Flush": "SF",
+  "Four of a Kind": "4K",
+  "Full House": "FH",
+  Flush: "FL",
+  Straight: "ST",
+  "Three of a Kind": "3K",
+  "Two Pair": "2P",
+  "One Pair": "1P",
+  "High Card": "HC",
+  Nothing: "\u2014"
+};
+function formatCardByParticipation(cardData, isParticipating) {
+  const color = isRedSuit(cardData.card.suit) ? red : gray;
+  const cardText = formatCard(cardData.card);
+  if (isParticipating) {
+    return `${color}${bold}(${cardText})${reset} `;
+  } else {
+    return `${color}${cardText}${reset} `;
+  }
+}
+function formatCardCompact(cardData, isParticipating) {
+  const color = isRedSuit(cardData.card.suit) ? red : gray;
+  const cardText = formatCardTextCompact(cardData.card);
+  if (isParticipating) {
+    return `${color}${bold}(${cardText})${reset}`;
+  } else {
+    return `${color}${cardText}${reset}`;
+  }
+}
+function formatCardTextCompact(card) {
+  const rankSymbols = {
+    "10": "T",
+    "11": "J",
+    "12": "Q",
+    "13": "K",
+    "14": "A"
+  };
+  const rank = String(card.rank);
+  const rankSymbol = rankSymbols[rank] ?? rank;
+  return `${rankSymbol}${card.suit}`;
+}
+function formatCardEmojiByParticipation(cardData, isParticipating) {
+  const cardText = formatCardEmoji(cardData.card);
+  if (isParticipating) {
+    return `${bold}(${cardText})${reset} `;
+  } else {
+    return `${cardText} `;
+  }
+}
+function formatHandResult(handResult, colors2) {
+  if (!handResult) {
+    return "\u2014";
+  }
+  const playerParticipates = handResult.participatingIndices.some((idx) => idx < 2);
+  const resultText = !playerParticipates ? `Nothing \u{1F0CF}` : `${handResult.name}! ${handResult.emoji}`;
+  if (!colors2) return resultText;
+  return colorize2(resultText, colors2.result);
+}
+function getHandAbbreviation(handResult) {
+  if (!handResult) {
+    return "\u2014 (\u2014)";
+  }
+  const abbreviation = HAND_ABBREVIATIONS[handResult.name] ?? "\u2014";
+  return `${abbreviation} (${handResult.name})`;
+}
+function balancedStyle2(data, colors2) {
+  const { holeCards, boardCards, handResult } = data;
+  const participatingSet = new Set(handResult?.participatingIndices || []);
+  const handStr = holeCards.map((hc, idx) => formatCardByParticipation(hc, participatingSet.has(idx))).join("");
+  const boardStr = boardCards.map((bc, idx) => formatCardByParticipation(bc, participatingSet.has(idx + 2))).join("");
+  const labelColor = colors2?.participating ?? lightGray;
+  const handLabel = colorize2("Hand:", labelColor);
+  const boardLabel = colorize2("Board:", labelColor);
+  return `${handLabel} ${handStr}| ${boardLabel} ${boardStr}\u2192 ${formatHandResult(handResult, colors2)}`;
+}
+var pokerStyles = {
+  balanced: balancedStyle2,
+  compact: balancedStyle2,
+  playful: balancedStyle2,
+  "compact-verbose": (data, colors2) => {
+    const { holeCards, boardCards, handResult } = data;
+    const participatingSet = new Set(handResult?.participatingIndices || []);
+    const handStr = holeCards.map((hc, idx) => formatCardCompact(hc, participatingSet.has(idx))).join("");
+    const boardStr = boardCards.map((bc, idx) => formatCardCompact(bc, participatingSet.has(idx + 2))).join("");
+    const abbreviation = getHandAbbreviation(handResult);
+    const result = `${handStr}| ${boardStr}\u2192 ${abbreviation}`;
+    if (!colors2) return result;
+    return colorize2(result, colors2.result);
+  },
+  emoji: (data, colors2) => {
+    const { holeCards, boardCards, handResult } = data;
+    const participatingSet = new Set(handResult?.participatingIndices || []);
+    const handStr = holeCards.map((hc, idx) => formatCardEmojiByParticipation(hc, participatingSet.has(idx))).join("");
+    const boardStr = boardCards.map((bc, idx) => formatCardEmojiByParticipation(bc, participatingSet.has(idx + 2))).join("");
+    const labelColor = colors2?.participating ?? lightGray;
+    const handLabel = colorize2("Hand:", labelColor);
+    const boardLabel = colorize2("Board:", labelColor);
+    return `${handLabel} ${handStr}| ${boardLabel} ${boardStr}\u2192 ${formatHandResult(handResult, colors2)}`;
+  }
+};
+
+// src/widgets/poker-widget.ts
+var PokerWidget = class extends StdinDataWidget {
+  id = "poker";
+  metadata = createWidgetMetadata(
+    "Poker",
+    "Displays random Texas Hold'em hands for entertainment",
+    "1.0.0",
+    "claude-scope",
+    4
+    // Fifth line (0-indexed)
+  );
+  holeCards = [];
+  boardCards = [];
+  handResult = null;
+  lastUpdateTimestamp = 0;
+  THROTTLE_MS = 5e3;
+  // 5 seconds
+  colors;
+  _lineOverride;
+  styleFn = pokerStyles.balanced;
+  setStyle(style = DEFAULT_WIDGET_STYLE) {
+    const fn = pokerStyles[style];
+    if (fn) {
+      this.styleFn = fn;
+    }
+  }
+  setLine(line) {
+    this._lineOverride = line;
+  }
+  getLine() {
+    return this._lineOverride ?? this.metadata.line ?? 0;
+  }
+  constructor(colors2) {
+    super();
+    this.colors = colors2 ?? DEFAULT_THEME;
+  }
+  /**
+   * Generate new poker hand on each update
+   */
+  async update(data) {
+    await super.update(data);
+    const now = Date.now();
+    if (this.lastUpdateTimestamp > 0 && now - this.lastUpdateTimestamp < this.THROTTLE_MS) {
+      return;
+    }
+    const deck = new Deck();
+    const hole = [deck.deal(), deck.deal()];
+    const board = [deck.deal(), deck.deal(), deck.deal(), deck.deal(), deck.deal()];
+    const result = evaluateHand(hole, board);
+    this.holeCards = hole.map((card) => ({
+      card,
+      formatted: this.formatCardColor(card)
+    }));
+    this.boardCards = board.map((card) => ({
+      card,
+      formatted: this.formatCardColor(card)
+    }));
+    const playerParticipates = result.participatingCards.some((idx) => idx < 2);
+    if (!playerParticipates) {
+      this.handResult = {
+        text: `Nothing \u{1F0CF}`,
+        participatingIndices: result.participatingCards
+      };
+    } else {
+      this.handResult = {
+        text: `${result.name}! ${result.emoji}`,
+        participatingIndices: result.participatingCards
+      };
+    }
+    this.lastUpdateTimestamp = now;
+  }
+  /**
+   * Format card with appropriate color (red for ♥♦, gray for ♠♣)
+   */
+  formatCardColor(card) {
+    const _color = isRedSuit(card.suit) ? "red" : "gray";
+    return formatCard(card);
+  }
+  renderWithData(_data, _context) {
+    const holeCardsData = this.holeCards.map((hc, idx) => ({
+      card: hc.card,
+      isParticipating: (this.handResult?.participatingIndices || []).includes(idx)
+    }));
+    const boardCardsData = this.boardCards.map((bc, idx) => ({
+      card: bc.card,
+      isParticipating: (this.handResult?.participatingIndices || []).includes(idx + 2)
+    }));
+    const handResult = this.handResult ? {
+      name: this.getHandName(this.handResult.text),
+      emoji: this.getHandEmoji(this.handResult.text),
+      participatingIndices: this.handResult.participatingIndices
+    } : null;
+    const renderData = {
+      holeCards: holeCardsData,
+      boardCards: boardCardsData,
+      handResult
+    };
+    return this.styleFn(renderData, this.colors.poker);
+  }
+  getHandName(text) {
+    const match = text.match(/^([^!]+)/);
+    return match ? match[1].trim() : "Nothing";
+  }
+  getHandEmoji(text) {
+    const match = text.match(/([🃏♠️♥️♦️♣️🎉✨🌟])/u);
+    return match ? match[1] : "\u{1F0CF}";
+  }
+};
+
+// src/core/widget-factory.ts
 var WidgetFactory = class {
   transcriptProvider;
   constructor() {
@@ -8149,6 +8871,10 @@ var WidgetFactory = class {
         return new DevServerWidget(DEFAULT_THEME);
       case "docker":
         return new DockerWidget(DEFAULT_THEME);
+      case "poker":
+        return new PokerWidget(DEFAULT_THEME);
+      case "empty-line":
+        return new EmptyLineWidget();
       default:
         return null;
     }
@@ -8169,7 +8895,9 @@ var WidgetFactory = class {
       "cache-metrics",
       "active-tools",
       "dev-server",
-      "docker"
+      "docker",
+      "poker",
+      "empty-line"
     ];
   }
 };
@@ -8360,18 +9088,12 @@ async function readStdin() {
   }
   return Buffer.concat(chunks).toString("utf8");
 }
-function applyWidgetConfig(widget, widgetId, config) {
-  for (const [lineNum, widgets] of Object.entries(config.lines)) {
-    const widgetConfig = widgets.find((w) => w.id === widgetId);
-    if (widgetConfig) {
-      if (typeof widget.setStyle === "function" && isValidWidgetStyle(widgetConfig.style)) {
-        widget.setStyle(widgetConfig.style);
-      }
-      if (typeof widget.setLine === "function") {
-        widget.setLine(parseInt(lineNum, 10));
-      }
-      break;
-    }
+function applyWidgetConfig(widget, widgetConfig) {
+  if (typeof widget.setStyle === "function" && isValidWidgetStyle(widgetConfig.style)) {
+    widget.setStyle(widgetConfig.style);
+  }
+  if (typeof widget.setLine === "function" && typeof widgetConfig.line === "number") {
+    widget.setLine(widgetConfig.line);
   }
 }
 async function main() {
@@ -8392,11 +9114,14 @@ async function main() {
     const widgetConfig = await loadWidgetConfig();
     const factory = new WidgetFactory();
     if (widgetConfig) {
-      for (const [_lineNum, widgets] of Object.entries(widgetConfig.lines)) {
+      for (const [lineNum, widgets] of Object.entries(widgetConfig.lines)) {
         for (const widgetConfigItem of widgets) {
           const widget = factory.createWidget(widgetConfigItem.id);
           if (widget) {
-            applyWidgetConfig(widget, widgetConfigItem.id, widgetConfig);
+            applyWidgetConfig(widget, {
+              ...widgetConfigItem,
+              line: parseInt(lineNum, 10)
+            });
             await registry.register(widget);
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-scope",
-  "version": "0.8.16",
+  "version": "0.8.20",
   "description": "Claude Code plugin for session status and analytics",
   "license": "MIT",
   "type": "module",