git-slot-machine 2.3.2 → 2.4.0

package/src/config.ts

@@ -1,189 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync } from 'child_process';
-
-interface Config {
-  githubUsername?: string;
-  playAsUsername?: string; // Per-repo override: play as this username instead
-  apiUrl?: string;
-  apiToken?: string;
-  syncEnabled?: boolean;
-  privateRepo?: boolean;
-}
-
-// Get repo-specific config path
-function getRepoConfigPath(): string {
-  return path.join(process.cwd(), '.git', 'slot-machine-config.json');
-}
-
-// Get global config path
-function getGlobalConfigPath(): string {
-  const homeDir = os.homedir();
-  const configDir = path.join(homeDir, '.git-slot-machine');
-
-  // Ensure config directory exists
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-
-  return path.join(configDir, 'config.json');
-}
-
-// Get merged config (repo-specific overrides global)
-export function getConfig(): Config {
-  const globalConfig = getGlobalConfig();
-  const repoConfig = getRepoConfig();
-
-  return { ...globalConfig, ...repoConfig };
-}
-
-// Get only repo-specific config
-export function getRepoConfig(): Config {
-  const configPath = getRepoConfigPath();
-
-  if (!fs.existsSync(configPath)) {
-    return {};
-  }
-
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-
-// Get only global config
-export function getGlobalConfig(): Config {
-  const configPath = getGlobalConfigPath();
-
-  if (!fs.existsSync(configPath)) {
-    return {};
-  }
-
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-
-// Save repo-specific config
-export function saveRepoConfig(config: Config): void {
-  const configPath = getRepoConfigPath();
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-// Save global config
-export function saveGlobalConfig(config: Config): void {
-  const configPath = getGlobalConfigPath();
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-export function getGitHubUsername(): string | null {
-  const config = getConfig();
-  // Check for per-repo override first, then fall back to global username
-  return config.playAsUsername || config.githubUsername || null;
-}
-
-export function setGitHubUsername(username: string): void {
-  const config = getGlobalConfig();
-  config.githubUsername = username;
-  saveGlobalConfig(config);
-}
-
-export function getApiUrl(): string {
-  const config = getConfig();
-  return config.apiUrl || process.env.GIT_SLOT_MACHINE_API_URL || 'https://gitslotmachine.com/api';
-}
-
-export function setApiUrl(url: string): void {
-  const config = getGlobalConfig();
-  config.apiUrl = url;
-  saveGlobalConfig(config);
-}
-
-export function getApiToken(): string | null {
-  const config = getConfig();
-  return config.apiToken || null;
-}
-
-export function setApiToken(token: string): void {
-  const config = getGlobalConfig();
-  config.apiToken = token;
-  saveGlobalConfig(config);
-}
-
-export function clearApiToken(): void {
-  const config = getGlobalConfig();
-  delete config.apiToken;
-  saveGlobalConfig(config);
-}
-
-export function isSyncEnabled(): boolean {
-  const config = getConfig();
-  return config.syncEnabled !== false; // Default to true
-}
-
-export function setSyncEnabled(enabled: boolean): void {
-  const config = getGlobalConfig();
-  config.syncEnabled = enabled;
-  saveGlobalConfig(config);
-}
-
-export function isPrivateRepo(): boolean {
-  const config = getRepoConfig();
-  return config.privateRepo === true;
-}
-
-export function setPrivateRepo(isPrivate: boolean): void {
-  const config = getRepoConfig();
-  config.privateRepo = isPrivate;
-  saveRepoConfig(config);
-}
-
-export function setPlayAsUsername(username: string): void {
-  const config = getRepoConfig();
-  config.playAsUsername = username;
-  saveRepoConfig(config);
-}
-
-export function getPlayAsUsername(): string | null {
-  const config = getRepoConfig();
-  return config.playAsUsername || null;
-}
-
-export function getRepoInfo(): { owner: string; name: string; url: string } | null {
-  try {
-    const remoteUrl = execSync('git config --get remote.origin.url', { encoding: 'utf-8' }).trim();
-
-    // Parse GitHub URL (supports both HTTPS and SSH)
-    const match = remoteUrl.match(/github\.com[:/](.+?)\/(.+?)(\.git)?$/);
-
-    if (match) {
-      const owner = match[1];
-      const name = match[2];
-
-      // If privacy mode is enabled, return obfuscated info
-      if (isPrivateRepo()) {
-        return {
-          owner: 'private',
-          name: 'private',
-          url: 'private',
-        };
-      }
-
-      return {
-        owner,
-        name,
-        url: `https://github.com/${owner}/${name}`,
-      };
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}

package/src/index.ts

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { playCommand } from './commands/play.js';
-import { spinCommand } from './commands/spin.js';
-import { initCommand } from './commands/init.js';
-import { balanceCommand } from './commands/balance.js';
-import { testCommand } from './commands/test.js';
-import { authLoginCommand, authLogoutCommand, authStatusCommand } from './commands/auth.js';
-import { syncCommand } from './commands/sync.js';
-import { configGetCommand, configSetCommand } from './commands/config.js';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-const { version } = require('../package.json');
-
-const program = new Command();
-
-program
-  .name('git-slot-machine')
-  .description('Git commit hash slot machine')
-  .version(version, '-v, --version', 'Output the current version');
-
-program
-  .command('play')
-  .description('Play the slot machine with a git hash')
-  .argument('<hash>', '7-character git commit hash')
-  .option('-s, --small', 'Single line output')
-  .action(async (hash: string, options: any) => {
-    await playCommand(hash, options);
-  });
-
-program
-  .command('spin')
-  .description('Play with the current git commit hash')
-  .option('-s, --small', 'Single line output')
-  .action(async (options: any) => {
-    await spinCommand(options);
-  });
-
-program
-  .command('init')
-  .description('Install post-commit hook in current repository')
-  .action(async () => {
-    await initCommand();
-  });
-
-program
-  .command('balance')
-  .description('Show current repository balance and stats')
-  .action(balanceCommand);
-
-program
-  .command('test')
-  .description('Play with a random 7-character hash')
-  .option('-s, --small', 'Single line output')
-  .action(async (options: any) => {
-    await testCommand(options);
-  });
-
-// Auth commands (top-level)
-program
-  .command('login')
-  .description('Login with GitHub username to join the leaderboard')
-  .argument('<github-username>', 'Your GitHub username')
-  .action(async (githubUsername: string) => {
-    await authLoginCommand(githubUsername);
-  });
-
-program
-  .command('logout')
-  .description('Logout and clear authentication')
-  .action(async () => {
-    await authLogoutCommand();
-  });
-
-program
-  .command('status')
-  .description('Show authentication and sync status')
-  .action(async () => {
-    await authStatusCommand();
-  });
-
-// Sync commands
-program
-  .command('sync')
-  .description('Sync balance with API')
-  .action(async () => {
-    await syncCommand();
-  });
-
-program
-  .command('sync:enable')
-  .description('Enable automatic API sync')
-  .action(async () => {
-    await configSetCommand('sync-enabled', 'true');
-  });
-
-program
-  .command('sync:disable')
-  .description('Disable automatic API sync')
-  .action(async () => {
-    await configSetCommand('sync-enabled', 'false');
-  });
-
-// Username commands
-program
-  .command('username:set')
-  .description('Set GitHub username')
-  .argument('<username>', 'Your GitHub username')
-  .action(async (username: string) => {
-    const { setGitHubUsername } = await import('./config.js');
-    setGitHubUsername(username);
-    console.log(chalk.green(`GitHub username set to: ${username}`));
-  });
-
-// Config commands (advanced - hidden from main help)
-program
-  .command('config:get', { hidden: true })
-  .description('Get configuration value (advanced)')
-  .argument('<key>', 'Configuration key (api-url, sync-enabled, all)')
-  .action(async (key: string) => {
-    await configGetCommand(key);
-  });
-
-program
-  .command('config:set', { hidden: true })
-  .description('Set configuration value (advanced)')
-  .argument('<key>', 'Configuration key (api-url, sync-enabled)')
-  .argument('<value>', 'Configuration value')
-  .action(async (key: string, value: string) => {
-    await configSetCommand(key, value);
-  });
-
-program.parse();

package/src/patterns.test.ts

@@ -1,44 +0,0 @@
-import { detectPattern, PatternType } from './patterns.js';
-
-describe('Pattern Detection', () => {
-  it('detects all same character', () => {
-    const result = detectPattern('aaaaaaa');
-    expect(result.type).toBe(PatternType.ALL_SAME);
-    expect(result.name).toBe('JACKPOT');
-  });
-
-  it('detects 4 of a kind', () => {
-    const result = detectPattern('aaaa123');
-    expect(result.type).toBe(PatternType.FOUR_OF_KIND);
-    expect(result.payout).toBeGreaterThan(0);
-  });
-
-  it('detects fullest house (4-3)', () => {
-    const result = detectPattern('aaaabbb');
-    expect(result.type).toBe(PatternType.FULLEST_HOUSE);
-  });
-
-  it('detects three pair', () => {
-    const result = detectPattern('aabbcc1');
-    expect(result.type).toBe(PatternType.THREE_PAIR);
-  });
-
-  it('detects one pair', () => {
-    const result = detectPattern('aa12345');
-    expect(result.type).toBe(PatternType.ONE_PAIR);
-  });
-
-  it('detects no win', () => {
-    const result = detectPattern('1234567');
-    expect(result.type).toBe(PatternType.NO_WIN);
-    expect(result.payout).toBe(0);
-  });
-
-  it('validates hash length', () => {
-    expect(() => detectPattern('abc')).toThrow('Hash must be 7 characters');
-  });
-
-  it('validates hex characters', () => {
-    expect(() => detectPattern('gggggg1')).toThrow('Hash must contain only hex characters');
-  });
-});

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)
-  };
-}