claude-scope 0.3.2 → 0.4.1

package/dist/claude-scope.cjs

@@ -440,6 +440,7 @@ function colorize(text, color) {
 }
 
 // src/ui/utils/colors.ts
+var red = "\x1B[31m";
 var gray = "\x1B[90m";
 
 // src/ui/theme/default-theme.ts
@@ -823,6 +824,486 @@ var ConfigCountWidget = class {
   }
 };
 
+// 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"
+};
+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]}`;
+}
+
+// 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]);
+        indices.push(cardIndicesByRank.get(next4)[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-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",
+    2
+    // Third line (0-indexed)
+  );
+  holeCards = [];
+  boardCards = [];
+  handResult = null;
+  constructor() {
+    super();
+  }
+  /**
+   * Generate new poker hand on each update
+   */
+  async update(data) {
+    await super.update(data);
+    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
+      };
+    }
+  }
+  /**
+   * Format card with appropriate color (red for ♥♦, gray for ♠♣)
+   */
+  formatCardColor(card) {
+    const color = isRedSuit(card.suit) ? red : gray;
+    return colorize(`[${formatCard(card)}]`, color);
+  }
+  /**
+   * Format card based on participation in best hand
+   * Participating cards: [K♠] (with brackets)
+   * Non-participating cards:  K♠  (spaces instead of brackets)
+   */
+  formatCardByParticipation(cardData, isParticipating) {
+    if (isParticipating) {
+      return cardData.formatted;
+    } else {
+      const inner = cardData.formatted.match(/\[(.+)\]/)?.[1] || cardData.formatted;
+      const colorMatch = cardData.formatted.match(/^(\x1b\[\d+m)/);
+      const color = colorMatch ? colorMatch[1] : "";
+      const reset = cardData.formatted.match(/\x1b\[0m$/) ? "\x1B[0m" : "";
+      return ` ${color}${inner}${reset} `;
+    }
+  }
+  renderWithData(_data, _context) {
+    const participatingSet = new Set(this.handResult?.participatingIndices || []);
+    const handStr = this.holeCards.map((hc, idx) => this.formatCardByParticipation(hc, participatingSet.has(idx))).join("");
+    const boardStr = this.boardCards.map((bc, idx) => this.formatCardByParticipation(bc, participatingSet.has(idx + 2))).join("");
+    const handLabel = colorize("Hand:", gray);
+    const boardLabel = colorize("Board:", gray);
+    return `${handLabel} ${handStr} | ${boardLabel} ${boardStr} \u2192 ${this.handResult?.text}`;
+  }
+};
+
 // src/validation/result.ts
 function success(data) {
   return { success: true, data };
@@ -1026,6 +1507,7 @@ async function main() {
     await registry.register(new GitWidget());
     await registry.register(new GitChangesWidget());
     await registry.register(new ConfigCountWidget());
+    await registry.register(new PokerWidget());
     const renderer = new Renderer({
       separator: " \u2502 ",
       onError: (error, widget) => {

package/package.json

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