git-slot-machine 2.3.1 → 2.4.0

package/src/patterns.ts

@@ -1,313 +0,0 @@
-export enum PatternType {
-  SECRET = 'SECRET', // Hidden combos
-  LUCKY_SEVENS = 'LUCKY_SEVENS', // Secret: 7777777
-  ALL_SAME = 'ALL_SAME',
-  SIX_OF_KIND = 'SIX_OF_KIND',
-  STRAIGHT_7 = 'STRAIGHT_7',
-  FULLEST_HOUSE = 'FULLEST_HOUSE', // 4-3
-  FIVE_OF_KIND = 'FIVE_OF_KIND',
-  STRAIGHT_6 = 'STRAIGHT_6',
-  FOUR_OF_KIND = 'FOUR_OF_KIND',
-  ALL_LETTERS = 'ALL_LETTERS',
-  STRAIGHT_5 = 'STRAIGHT_5',
-  THREE_OF_KIND_PLUS_THREE = 'THREE_OF_KIND_PLUS_THREE', // 3-3-1
-  FULLER_HOUSE = 'FULLER_HOUSE', // 3-2-2
-  FULL_HOUSE = 'FULL_HOUSE', // 3-2-1-1
-  THREE_PAIR = 'THREE_PAIR',
-  THREE_OF_KIND = 'THREE_OF_KIND',
-  TWO_PAIR = 'TWO_PAIR',
-  ALL_NUMBERS = 'ALL_NUMBERS',
-  ONE_PAIR = 'ONE_PAIR',
-  NO_WIN = 'NO_WIN'
-}
-
-export interface PatternResult {
-  type: PatternType;
-  name: string;
-  payout: number;
-  description: string;
-  highlightIndices: number[]; // Indices of characters to highlight
-}
-
-const PAYOUTS: Record<PatternType, { name: string; payout: number; description: string }> = {
-  [PatternType.SECRET]: { name: 'SECRET', payout: 0, description: '???' }, // Placeholder, actual values from secrets.ts
-  [PatternType.LUCKY_SEVENS]: { name: 'LUCKY SEVENS', payout: 1000000, description: 'The ultimate jackpot: 7777777' },
-  [PatternType.ALL_SAME]: { name: 'JACKPOT', payout: 100000, description: 'All same character' },
-  [PatternType.STRAIGHT_7]: { name: 'LUCKY SEVEN', payout: 50000, description: 'Seven sequential hex digits' },
-  [PatternType.STRAIGHT_6]: { name: 'BIG STRAIGHT', payout: 25000, description: 'Six sequential hex digits' },
-  [PatternType.SIX_OF_KIND]: { name: 'HEXTET', payout: 10000, description: 'Six of a kind' },
-  [PatternType.FULLEST_HOUSE]: { name: 'FULLEST HOUSE', payout: 5000, description: '4 + 3 of a kind' },
-  [PatternType.STRAIGHT_5]: { name: 'STRAIGHT', payout: 2500, description: 'Five sequential hex digits' },
-  [PatternType.FIVE_OF_KIND]: { name: 'FIVE OF A KIND', payout: 2000, description: 'Five of a kind' },
-  [PatternType.THREE_OF_KIND_PLUS_THREE]: { name: 'DOUBLE TRIPLE', payout: 1000, description: 'Two three of a kinds' },
-  [PatternType.THREE_PAIR]: { name: 'THREE PAIR', payout: 500, description: 'Three consecutive pairs' },
-  [PatternType.FULLER_HOUSE]: { name: 'FULLER HOUSE', payout: 400, description: '3 + 2 + 2 of a kind' },
-  [PatternType.FULL_HOUSE]: { name: 'FULL HOUSE', payout: 50, description: '3 + 2 of a kind' },
-  [PatternType.ALL_LETTERS]: { name: 'ALPHABET SOUP', payout: 250, description: 'Only letters (a-f)' },
-  [PatternType.FOUR_OF_KIND]: { name: 'FOUR OF A KIND', payout: 200, description: 'Four of a kind' },
-  [PatternType.THREE_OF_KIND]: { name: 'THREE OF A KIND', payout: 25, description: 'Three of a kind' },
-  [PatternType.ALL_NUMBERS]: { name: 'ALL NUMBERS', payout: 50, description: 'Only numbers (0-9)' },
-  [PatternType.TWO_PAIR]: { name: 'TWO PAIR', payout: 25, description: 'Two consecutive pairs' },
-  [PatternType.ONE_PAIR]: { name: 'ONE PAIR', payout: 10, description: 'One consecutive pair' },
-  [PatternType.NO_WIN]: { name: 'NO WIN', payout: 0, description: 'No winning pattern' }
-};
-
-function countCharacters(hash: string): Map<string, number> {
-  const counts = new Map<string, number>();
-  for (const char of hash) {
-    counts.set(char, (counts.get(char) || 0) + 1);
-  }
-  return counts;
-}
-
-function getCountDistribution(counts: Map<string, number>): number[] {
-  return Array.from(counts.values()).sort((a, b) => b - a);
-}
-
-function hasSequentialRun(hash: string, length: number): boolean {
-  const hexValues = '0123456789abcdef';
-
-  for (let i = 0; i <= hash.length - length; i++) {
-    const substring = hash.substring(i, i + length);
-
-    // Check ascending
-    let isAscending = true;
-    for (let j = 0; j < substring.length - 1; j++) {
-      const currentIndex = hexValues.indexOf(substring[j]);
-      const nextIndex = hexValues.indexOf(substring[j + 1]);
-      if (nextIndex !== currentIndex + 1) {
-        isAscending = false;
-        break;
-      }
-    }
-    if (isAscending) return true;
-
-    // Check descending
-    let isDescending = true;
-    for (let j = 0; j < substring.length - 1; j++) {
-      const currentIndex = hexValues.indexOf(substring[j]);
-      const nextIndex = hexValues.indexOf(substring[j + 1]);
-      if (nextIndex !== currentIndex - 1) {
-        isDescending = false;
-        break;
-      }
-    }
-    if (isDescending) return true;
-  }
-
-  return false;
-}
-
-function isAllLetters(hash: string): boolean {
-  return /^[a-f]+$/i.test(hash);
-}
-
-function isAllNumbers(hash: string): boolean {
-  return /^[0-9]+$/.test(hash);
-}
-
-function countConsecutivePairs(hash: string): number {
-  // Count pairs of consecutive identical characters (e.g., "33" or "bb")
-  let pairCount = 0;
-  let i = 0;
-
-  while (i < hash.length - 1) {
-    if (hash[i] === hash[i + 1]) {
-      pairCount++;
-      i += 2; // Skip both characters of the pair
-    } else {
-      i++;
-    }
-  }
-
-  return pairCount;
-}
-
-function getHighlightIndices(hash: string, type: PatternType): number[] {
-  const lowerHash = hash.toLowerCase();
-
-  // For straights, highlight all characters in the sequential run
-  if (type === PatternType.STRAIGHT_7 || type === PatternType.STRAIGHT_6 || type === PatternType.STRAIGHT_5) {
-    const length = type === PatternType.STRAIGHT_7 ? 7 : type === PatternType.STRAIGHT_6 ? 6 : 5;
-    const hexValues = '0123456789abcdef';
-
-    for (let i = 0; i <= lowerHash.length - length; i++) {
-      const substring = lowerHash.substring(i, i + length);
-      let isSequential = true;
-
-      // Check ascending
-      for (let j = 0; j < substring.length - 1; j++) {
-        const currentIndex = hexValues.indexOf(substring[j]);
-        const nextIndex = hexValues.indexOf(substring[j + 1]);
-        if (nextIndex !== currentIndex + 1 && nextIndex !== currentIndex - 1) {
-          isSequential = false;
-          break;
-        }
-      }
-
-      if (isSequential) {
-        return Array.from({ length }, (_, idx) => i + idx);
-      }
-    }
-  }
-
-  // For all letters, all numbers, all same, or lucky sevens - highlight everything
-  if (type === PatternType.ALL_LETTERS || type === PatternType.ALL_NUMBERS ||
-      type === PatternType.ALL_SAME || type === PatternType.LUCKY_SEVENS) {
-    return [0, 1, 2, 3, 4, 5, 6];
-  }
-
-  // For frequency-based patterns, highlight characters that appear in the pattern
-  const counts = countCharacters(lowerHash);
-  const indices: number[] = [];
-
-  if (type === PatternType.SIX_OF_KIND || type === PatternType.FIVE_OF_KIND ||
-      type === PatternType.FOUR_OF_KIND || type === PatternType.THREE_OF_KIND) {
-    // Find the character with the highest count and highlight all occurrences
-    const targetCount = type === PatternType.SIX_OF_KIND ? 6 :
-                        type === PatternType.FIVE_OF_KIND ? 5 :
-                        type === PatternType.FOUR_OF_KIND ? 4 : 3;
-
-    for (const [char, count] of counts.entries()) {
-      if (count === targetCount) {
-        for (let i = 0; i < lowerHash.length; i++) {
-          if (lowerHash[i] === char) {
-            indices.push(i);
-          }
-        }
-        break;
-      }
-    }
-  }
-  else if (type === PatternType.FULLEST_HOUSE || type === PatternType.FULLER_HOUSE ||
-           type === PatternType.FULL_HOUSE || type === PatternType.THREE_OF_KIND_PLUS_THREE) {
-    // Highlight all paired/tripled characters
-    for (const [char, count] of counts.entries()) {
-      if (count >= 2) {
-        for (let i = 0; i < lowerHash.length; i++) {
-          if (lowerHash[i] === char) {
-            indices.push(i);
-          }
-        }
-      }
-    }
-  }
-  else if (type === PatternType.THREE_PAIR || type === PatternType.TWO_PAIR || type === PatternType.ONE_PAIR) {
-    // Highlight consecutive pairs only (e.g., "aa" and "bb" in "aa1bb2c")
-    let i = 0;
-    while (i < lowerHash.length - 1) {
-      if (lowerHash[i] === lowerHash[i + 1]) {
-        indices.push(i);
-        indices.push(i + 1);
-        i += 2; // Skip both characters of the pair
-      } else {
-        i++;
-      }
-    }
-  }
-
-  return indices.sort((a, b) => a - b);
-}
-
-export function detectPattern(hash: string): PatternResult {
-  // Validate input
-  if (hash.length !== 7) {
-    throw new Error('Hash must be 7 characters');
-  }
-  if (!/^[0-9a-f]+$/i.test(hash)) {
-    throw new Error('Hash must contain only hex characters');
-  }
-
-  const lowerHash = hash.toLowerCase();
-  const counts = countCharacters(lowerHash);
-  const distribution = getCountDistribution(counts);
-
-  // Detect pattern - check in order of rarity/value
-  let type: PatternType;
-
-  // Check for the secret ultimate jackpot: 7777777
-  if (lowerHash === '7777777') {
-    type = PatternType.LUCKY_SEVENS;
-  }
-  // Check for all same first (highest value)
-  else if (distribution[0] === 7) {
-    type = PatternType.ALL_SAME;
-  }
-  // Check for 6 of a kind
-  else if (distribution[0] === 6) {
-    type = PatternType.SIX_OF_KIND;
-  }
-  // Check for straight 7 (very rare)
-  else if (hasSequentialRun(lowerHash, 7)) {
-    type = PatternType.STRAIGHT_7;
-  }
-  // Check for fullest house (4-3)
-  else if (distribution[0] === 4 && distribution[1] === 3) {
-    type = PatternType.FULLEST_HOUSE;
-  }
-  // Check for 5 of a kind
-  else if (distribution[0] === 5) {
-    type = PatternType.FIVE_OF_KIND;
-  }
-  // Check for straight 6
-  else if (hasSequentialRun(lowerHash, 6)) {
-    type = PatternType.STRAIGHT_6;
-  }
-  // Check for 4 of a kind
-  else if (distribution[0] === 4) {
-    type = PatternType.FOUR_OF_KIND;
-  }
-  // Check for all letters
-  else if (isAllLetters(lowerHash)) {
-    type = PatternType.ALL_LETTERS;
-  }
-  // Check for straight 5
-  else if (hasSequentialRun(lowerHash, 5)) {
-    type = PatternType.STRAIGHT_5;
-  }
-  // Check for double triple (3-3-1)
-  else if (distribution[0] === 3 && distribution[1] === 3) {
-    type = PatternType.THREE_OF_KIND_PLUS_THREE;
-  }
-  // Check for fuller house (3-2-2)
-  else if (distribution[0] === 3 && distribution[1] === 2 && distribution[2] === 2) {
-    type = PatternType.FULLER_HOUSE;
-  }
-  // Check for full house (3-2-1-1)
-  else if (distribution[0] === 3 && distribution[1] === 2) {
-    type = PatternType.FULL_HOUSE;
-  }
-  // Check for 3 of a kind
-  else if (distribution[0] === 3) {
-    type = PatternType.THREE_OF_KIND;
-  }
-  // Check for three consecutive pairs
-  else if (countConsecutivePairs(lowerHash) === 3) {
-    type = PatternType.THREE_PAIR;
-  }
-  // Check for two consecutive pairs
-  else if (countConsecutivePairs(lowerHash) === 2) {
-    type = PatternType.TWO_PAIR;
-  }
-  // Check for all numbers
-  else if (isAllNumbers(lowerHash)) {
-    type = PatternType.ALL_NUMBERS;
-  }
-  // Check for one consecutive pair
-  else if (countConsecutivePairs(lowerHash) === 1) {
-    type = PatternType.ONE_PAIR;
-  }
-  // Everything else is no win
-  else {
-    type = PatternType.NO_WIN;
-  }
-
-  const config = PAYOUTS[type];
-  return {
-    type,
-    name: config.name,
-    payout: config.payout,
-    description: config.description,
-    highlightIndices: getHighlightIndices(hash, type)
-  };
-}

package/src/secrets.ts

@@ -1,44 +0,0 @@
-import { createHash } from 'crypto';
-
-interface S {
-  h: string;  // sha256 hash
-  p: number;  // payout
-  n: number[];  // name as char codes
-  e?: number;  // emoji code point
-  f?: number;  // flood flag
-}
-
-// Sorted by payout descending
-const _: S[] = [
-  // Legendary tier (42069)
-  { h: '56379c14419d2363ce258293ed6adc3684ae4926aba335a49b75d7483b9f85ae', p: 42069, n: [66,65,68,32,70,79,79,68], e: 0x1F922, f: 1 },
-  { h: '475fbf8c77411b86a660c8d61f181e464a50572e8f1ff4ffb28e75289625d494', p: 42069, n: [67,79,70,70,69,69,83], e: 0x2615, f: 1 },
-  { h: 'a0d9961dc6d7e4059ec746b8ab9a20f330c1308266c5197da77e7bda839457b9', p: 42069, n: [68,69,65,68,32,66,69,68], e: 0x1F480, f: 1 },
-  { h: 'a3fe33e094647d5071cb6d3719bd7b55eb1ad1fb06f2c33923e66363fd805020', p: 42069, n: [68,73,83,69,65,83,69], e: 0x1F9A0, f: 1 },
-  // Great tier (6969)
-  { h: '011a1a79ee662806e273538d1a0036b8090f939efd05e312f402ed9fdcaf5f25', p: 6969, n: [73,67,69,32,67,79,76,68], e: 0x1F976, f: 1 },
-  { h: '432fe036b0239c1551947f5a1f93006f2f62e4c5512909453e539eba348b678f', p: 6969, n: [83,65,68,32,70,65,67,69], e: 0x1F622, f: 1 },
-  { h: 'dcf79a973cb6e6d4567c17e24865d39370db2bc6a167ebdcbeaedcda83906350', p: 6969, n: [66,79,65,83,84,69,68], e: 0x1F525, f: 1 },
-  // Good tier (1337)
-  { h: '70d8dec01053bbf890288c8927f605f209533b52512dafd9f145e891d6d3f0ae', p: 1337, n: [66,65,68,32,67,65,70,69] },
-  { h: '2c8d79f36c7758d1268998039ca8a565cb6687958516f370e10086b45c2a1ea7', p: 1337, n: [68,69,70,65,67,69,68] },
-];
-
-export interface SecretResult {
-  name: string;
-  payout: number;
-  emoji?: string;
-  flood: boolean;
-}
-
-export function checkSecret(hash: string): SecretResult | null {
-  const h = createHash('sha256').update(hash.toLowerCase()).digest('hex');
-  const m = _.find(s => s.h === h);
-  if (!m) return null;
-  return {
-    name: String.fromCharCode(...m.n),
-    payout: m.p,
-    emoji: m.e ? String.fromCodePoint(m.e) : undefined,
-    flood: m.f === 1,
-  };
-}

package/src/templates/post-commit.ts

@@ -1,23 +0,0 @@
-export const POST_COMMIT_HOOK = `#!/bin/sh
-# Git Slot Machine post-commit hook
-
-# Get the commit hash
-HASH=$(git rev-parse --short=7 HEAD)
-
-# Find git-slot-machine binary
-if command -v git-slot-machine >/dev/null 2>&1; then
-  GSM=git-slot-machine
-elif [ -f "./node_modules/.bin/git-slot-machine" ]; then
-  GSM=./node_modules/.bin/git-slot-machine
-else
-  echo "git-slot-machine not found, skipping animation"
-  exit 0
-fi
-
-# In Claude Code, skip animation frames and show only the result line
-if [ -n "$CLAUDECODE" ]; then
-  "$GSM" play "$HASH" --small 2>/dev/null | tail -1
-else
-  "$GSM" play "$HASH" --small
-fi
-`;

package/src/utils/amendDetector.ts

@@ -1,74 +0,0 @@
-import { execSync } from 'child_process';
-
-interface AmendDetectionResult {
-  isAmended: boolean;
-  recentAmendCount: number;
-  suspiciousActivity: boolean;
-  recentAmendHashes: string[];
-}
-
-/**
- * Detects if the current commit appears to be the result of hash grinding
- * by checking git reflog for suspicious amend patterns
- */
-export function detectAmendGrinding(timeWindowMinutes: number = 5, suspiciousThreshold: number = 5): AmendDetectionResult {
-  try {
-    // Get reflog entries from the last timeWindowMinutes
-    // Format: %gd = reflog selector, %gs = reflog subject, %H = commit hash, %ct = committer timestamp
-    const reflogOutput = execSync(
-      `git reflog --since="${timeWindowMinutes} minutes ago" --format="%gs|%H|%ct"`,
-      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }
-    ).trim();
-
-    if (!reflogOutput) {
-      return {
-        isAmended: false,
-        recentAmendCount: 0,
-        suspiciousActivity: false,
-        recentAmendHashes: [],
-      };
-    }
-
-    const entries = reflogOutput.split('\n');
-    const amendEntries = entries.filter(entry => entry.includes('commit (amend)'));
-    const amendHashes = amendEntries.map(entry => {
-      const parts = entry.split('|');
-      return parts[1]?.substring(0, 7) || '';
-    }).filter(hash => hash.length === 7);
-
-    const recentAmendCount = amendEntries.length;
-    const suspiciousActivity = recentAmendCount >= suspiciousThreshold;
-
-    // Check if the most recent action was an amend
-    const isAmended = entries.length > 0 && entries[0].includes('commit (amend)');
-
-    return {
-      isAmended,
-      recentAmendCount,
-      suspiciousActivity,
-      recentAmendHashes: amendHashes,
-    };
-  } catch (error) {
-    // If git reflog fails, assume no amending
-    return {
-      isAmended: false,
-      recentAmendCount: 0,
-      suspiciousActivity: false,
-      recentAmendHashes: [],
-    };
-  }
-}
-
-/**
- * Get a warning message for suspicious amend activity
- */
-export function getAmendWarningMessage(result: AmendDetectionResult): string | null {
-  if (!result.suspiciousActivity) {
-    return null;
-  }
-
-  return `⚠️  Suspicious Activity Detected\n` +
-    `   ${result.recentAmendCount} commit amends in the last 5 minutes\n` +
-    `   This pattern suggests hash grinding/gaming\n` +
-    `   Your commit will be flagged for review`;
-}

package/src/utils/fetch-polyfill.ts

@@ -1,13 +0,0 @@
-// Polyfill fetch for Node.js < 18
-// Node 18+ has native fetch, older versions need node-fetch
-
-export async function getFetch(): Promise<typeof fetch> {
-  // Check if native fetch exists (Node 18+)
-  if (typeof globalThis.fetch !== 'undefined') {
-    return globalThis.fetch;
-  }
-
-  // Fall back to node-fetch for Node < 18
-  const nodeFetch = await import('node-fetch');
-  return nodeFetch.default as unknown as typeof fetch;
-}

package/src/utils/git.ts

@@ -1,88 +0,0 @@
-import { execSync } from 'child_process';
-
-export function getCurrentCommitHash(): string {
-  try {
-    const fullHash = execSync('git rev-parse HEAD', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    return fullHash.substring(0, 7);
-  } catch (error) {
-    throw new Error('Not a git repository or no commits yet');
-  }
-}
-
-export function getCurrentCommitFullHash(): string {
-  try {
-    const fullHash = execSync('git rev-parse HEAD', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    return fullHash;
-  } catch (error) {
-    throw new Error('Not a git repository or no commits yet');
-  }
-}
-
-export function isGitRepo(): boolean {
-  try {
-    execSync('git rev-parse --is-inside-work-tree', {
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function detectGitHubUsername(): string | null {
-  // Try 1: Check GitHub CLI (gh)
-  try {
-    const ghUser = execSync('gh api user --jq .login', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    if (ghUser) {
-      return ghUser;
-    }
-  } catch {
-    // gh not installed or not authenticated, continue to next method
-  }
-
-  // Try 2: Check git config github.user
-  try {
-    const githubUser = execSync('git config github.user', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    if (githubUser) {
-      return githubUser;
-    }
-  } catch {
-    // github.user not set, continue to next method
-  }
-
-  // Try 3: Extract from GitHub noreply email
-  try {
-    const email = execSync('git config user.email', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    // Match patterns like:
-    // - username@users.noreply.github.com
-    // - 12345+username@users.noreply.github.com (with ID prefix)
-    const match = email.match(/^(?:\d+\+)?(.+)@users\.noreply\.github\.com$/);
-    if (match) {
-      return match[1];
-    }
-  } catch {
-    // user.email not set or no match
-  }
-
-  return null;
-}

package/test.txt

@@ -1,2 +0,0 @@
-test
-test 

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}