git-slot-machine 2.3.2 → 2.4.0

package/jest.config.js

@@ -1,12 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/src'],
-  testMatch: ['**/*.test.ts'],
-  moduleFileExtensions: ['ts', 'js'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.test.ts',
-    '!src/**/*.d.ts'
-  ]
-};

package/src/animation/slotMachine.ts

@@ -1,164 +0,0 @@
-import chalk from 'chalk';
-import { PatternResult } from '../patterns.js';
-
-const HEX_CHARS = '0123456789abcdef'.split('');
-const ANIMATION_SPEED = 50; // ms per frame
-const SPIN_DURATION = 2000; // total animation time
-const FRAMES = SPIN_DURATION / ANIMATION_SPEED;
-
-export interface SlotConfig {
-  finalHash: string;
-  small: boolean;
-  patternResult?: PatternResult;
-}
-
-function getRandomHexChar(): string {
-  return HEX_CHARS[Math.floor(Math.random() * HEX_CHARS.length)];
-}
-
-function clearLine(): void {
-  process.stdout.write('\r\x1b[K');
-}
-
-function drawSlotMachine(chars: string[], spinning: boolean, highlightIndices: number[] = [], flash: boolean = false): void {
-  // Casino color palette: red borders, white title
-  const borderColor = chalk.rgb(220, 20, 60); // Crimson red
-  const titleColor = chalk.white; // White
-
-  const borderWidth = 39;
-  const border = '═'.repeat(borderWidth);
-  const topBorder = borderColor('╔' + border + '╗');
-  const middleBorder = borderColor('╠' + border + '╣');
-  const bottomBorder = borderColor('╚' + border + '╝');
-
-  // Title line - emojis count as 2 visual chars each
-  const titleText = 'GIT SLOT MACHINE';
-  const titleVisualWidth = 2 + 2 + titleText.length + 2 + 2; // emoji + spaces + text + spaces + emoji
-  const titlePadding = Math.floor((borderWidth - titleVisualWidth) / 2);
-  const titleRightPad = borderWidth - titleVisualWidth - titlePadding;
-  const titleLine = borderColor('║') + ' '.repeat(titlePadding) + chalk.rgb(255, 255, 255)('🎰  ' + titleText + '  🎰') + ' '.repeat(titleRightPad) + borderColor('║');
-
-  console.log(topBorder);
-  console.log(titleLine);
-  console.log(middleBorder);
-
-  // Display the 7 characters as slot reels
-  const display = chars.map((char, i) => {
-    if (spinning) {
-      // Spinning - white blur
-      return chalk.rgb(255, 255, 255).bold(char);
-    } else {
-      // Check if this character should be highlighted
-      const isHighlighted = highlightIndices.includes(i);
-
-      if (isHighlighted && flash) {
-        // Flash state - yellow inverse (yellow background, black text)
-        return chalk.bgRgb(255, 255, 0).rgb(0, 0, 0).bold(char);
-      } else if (isHighlighted) {
-        // Normal highlighted state - yellow inverse (yellow background, black text)
-        return chalk.bgRgb(255, 255, 0).rgb(0, 0, 0).bold(char);
-      } else {
-        // Not highlighted - white text
-        return chalk.rgb(255, 255, 255)(char);
-      }
-    }
-  }).join('  ');
-
-  // Calculate padding for character display (7 chars + 6 double-space separators = 19 visual chars)
-  const displayVisualWidth = 7 + 12; // 7 chars + 6*2 spaces
-  const displayPadding = Math.floor((borderWidth - displayVisualWidth) / 2);
-  const displayRightPad = borderWidth - displayVisualWidth - displayPadding;
-  const displayLine = borderColor('║') + ' '.repeat(displayPadding) + display + ' '.repeat(displayRightPad) + borderColor('║');
-
-  console.log(displayLine);
-  console.log(bottomBorder);
-}
-
-export async function animateSlotMachine(config: SlotConfig): Promise<void> {
-  const { finalHash, patternResult } = config;
-  const highlightIndices = patternResult?.highlightIndices || [];
-  const isCI = !!process.env.CLAUDECODE || !!process.env.CI;
-
-  const finalChars = finalHash.split('');
-
-  if (!isCI) {
-    // Clear screen
-    console.clear();
-
-    // Initialize with random characters
-    let currentChars = Array(7).fill(0).map(() => getRandomHexChar());
-
-    // Animate spinning
-    for (let frame = 0; frame < FRAMES; frame++) {
-      // Gradually slow down and settle on final hash
-      const progress = frame / FRAMES;
-
-      if (progress < 0.9) {
-        // Still spinning - show random
-        currentChars = currentChars.map(() => getRandomHexChar());
-      } else {
-        // Start settling - reveal characters one by one
-        const revealIndex = Math.floor((progress - 0.9) / 0.1 * 7);
-        for (let i = 0; i < revealIndex; i++) {
-          currentChars[i] = finalHash[i];
-        }
-      }
-
-      // Redraw
-      console.clear();
-      drawSlotMachine(currentChars, progress < 0.9);
-
-      // Wait for next frame
-      await new Promise(resolve => setTimeout(resolve, ANIMATION_SPEED));
-    }
-
-    // Flash 3 times if there are highlighted characters
-    if (highlightIndices.length > 0) {
-      for (let flashCount = 0; flashCount < 3; flashCount++) {
-        console.clear();
-        drawSlotMachine(finalChars, false, highlightIndices, true);
-        await new Promise(resolve => setTimeout(resolve, 200));
-
-        console.clear();
-        drawSlotMachine(finalChars, false, highlightIndices, false);
-        await new Promise(resolve => setTimeout(resolve, 200));
-      }
-    }
-
-    // Steady state
-    console.clear();
-  }
-
-  drawSlotMachine(finalChars, false, highlightIndices, false);
-}
-
-export async function animateSmallMode(config: SlotConfig): Promise<void> {
-  const { finalHash, patternResult } = config;
-  const highlightIndices = patternResult?.highlightIndices || [];
-  const isCI = !!process.env.CLAUDECODE || !!process.env.CI;
-
-  if (!isCI) {
-    // Single line, rapid character flicker
-    process.stdout.write(chalk.cyan('🎰 '));
-
-    for (let frame = 0; frame < 20; frame++) {
-      const chars = Array(7).fill(0).map(() => getRandomHexChar()).join('');
-      clearLine();
-      process.stdout.write(chalk.cyan('🎰 ') + chalk.rgb(255, 255, 255)(chars));
-      await new Promise(resolve => setTimeout(resolve, 50));
-    }
-
-    clearLine();
-  }
-
-  // Final with highlighting - don't add newline, let the caller add result info
-  const display = finalHash.split('').map((char, i) => {
-    if (highlightIndices.includes(i)) {
-      return chalk.bgRgb(255, 255, 0).rgb(0, 0, 0).bold(char);
-    } else {
-      return chalk.rgb(255, 255, 255)(char);
-    }
-  }).join('');
-  process.stdout.write(chalk.cyan('🎰 ') + display);
-  // Don't write newline - let caller continue on same line
-}

package/src/api.ts

@@ -1,207 +0,0 @@
-import { getApiUrl, getApiToken, isSyncEnabled } from './config.js';
-import { getFetch } from './utils/fetch-polyfill.js';
-
-// Fallback domains to try in order (if primary fails)
-const FALLBACK_DOMAINS = [
-  'https://gitslotmachinecom-main-vilmm1.laravel.cloud',
-];
-
-export interface PlayData {
-  commit_hash: string;
-  commit_full_hash: string;
-  pattern_type: string;
-  pattern_name: string;
-  payout: number;
-  wager: number;
-  balance_before: number;
-  balance_after: number;
-  repo_url: string;
-  github_username: string;
-  repo_owner: string;
-  repo_name: string;
-}
-
-export interface ApiResponse<T = any> {
-  success: boolean;
-  data?: T;
-  message?: string;
-}
-
-export interface BalanceResponse {
-  balance: number;
-  total_commits: number;
-  total_winnings: number;
-  biggest_win: number;
-  biggest_win_pattern?: string;
-  biggest_win_hash?: string;
-}
-
-// Helper to build headers with authentication
-function getHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    'Accept': 'application/json',
-  };
-
-  const token = getApiToken();
-  if (token) {
-    headers['Authorization'] = `Bearer ${token}`;
-  }
-
-  return headers;
-}
-
-// Check if API sync is enabled and available
-export function isApiAvailable(): boolean {
-  return isSyncEnabled() && getApiToken() !== null;
-}
-
-export interface PlayResponse {
-  balance: number;
-  payout: number;
-  pattern_name: string;
-  share_url?: string;
-}
-
-// Helper to try API call with fallback domains
-async function fetchWithFallback(endpoint: string, options: RequestInit): Promise<Response | null> {
-  const configuredUrl = getApiUrl();
-  const fetchFn = await getFetch();
-
-  // Build list of URLs to try: configured URL first, then fallbacks (excluding duplicates)
-  const urlsToTry = [
-    configuredUrl,
-    ...FALLBACK_DOMAINS.filter(domain => !configuredUrl.startsWith(domain))
-  ];
-
-  for (const baseUrl of urlsToTry) {
-    try {
-      const url = `${baseUrl.replace(/\/api$/, '')}/api${endpoint}`;
-      const response = await fetchFn(url, options);
-
-      if (response.ok) {
-        return response;
-      }
-
-      // If not ok, try next domain
-      continue;
-    } catch (error) {
-      // Network error, try next domain
-      continue;
-    }
-  }
-
-  return null;
-}
-
-// Send play data to API
-export async function sendPlayToAPI(data: PlayData): Promise<PlayResponse | null> {
-  if (!isApiAvailable()) {
-    return null;
-  }
-
-  try {
-    const response = await fetchWithFallback('/play', {
-      method: 'POST',
-      headers: getHeaders(),
-      body: JSON.stringify(data),
-    });
-
-    if (!response) {
-      return null;
-    }
-
-    const result = await response.json() as ApiResponse<PlayResponse>;
-    return result.data || null;
-  } catch (error) {
-    // Silently fail if offline or API unavailable
-    // The user still gets local feedback
-    return null;
-  }
-}
-
-// Get balance from API
-export async function getBalance(): Promise<BalanceResponse | null> {
-  if (!isApiAvailable()) {
-    return null;
-  }
-
-  try {
-    const response = await fetchWithFallback('/balance', {
-      method: 'GET',
-      headers: getHeaders(),
-    });
-
-    if (!response) {
-      return null;
-    }
-
-    const result = await response.json() as ApiResponse<BalanceResponse>;
-    return result.data || null;
-  } catch (error) {
-    return null;
-  }
-}
-
-// Create API token (simplified - just pass github username)
-export async function createToken(githubUsername: string): Promise<string | null> {
-  try {
-    const response = await fetchWithFallback('/auth/token', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json',
-      },
-      body: JSON.stringify({
-        github_username: githubUsername,
-      }),
-    });
-
-    if (!response) {
-      console.error('Failed to reach API server. Please check your network connection.');
-      return null;
-    }
-
-    const result = await response.json() as ApiResponse<{ token: string }>;
-    return result.data?.token || null;
-  } catch (error) {
-    console.error('API request failed:', (error as Error).message);
-    return null;
-  }
-}
-
-// Verify token is valid
-export async function verifyToken(token: string): Promise<boolean> {
-  try {
-    const response = await fetchWithFallback('/auth/user', {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json',
-        'Authorization': `Bearer ${token}`,
-      },
-    });
-
-    return response !== null && response.ok;
-  } catch (error) {
-    return false;
-  }
-}
-
-// Logout (revoke token)
-export async function logout(): Promise<boolean> {
-  if (!getApiToken()) {
-    return true;
-  }
-
-  try {
-    const response = await fetchWithFallback('/auth/token', {
-      method: 'DELETE',
-      headers: getHeaders(),
-    });
-
-    return response !== null && response.ok;
-  } catch (error) {
-    return false;
-  }
-}

package/src/balance.ts

@@ -1,118 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-interface BalanceData {
-  repos: Record<string, {
-    balance: number;
-    totalCommits: number;
-    totalWinnings: number;
-    biggestWin: number;
-    lastCommit: string;
-  }>;
-}
-
-const BALANCE_FILE = path.join(os.homedir(), '.git-slot-machine-balance.json');
-
-function getRepoPath(): string | null {
-  try {
-    const { execSync } = require('child_process');
-    return execSync('git rev-parse --show-toplevel', {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-  } catch {
-    // Not in a git repo - use global balance instead
-    return null;
-  }
-}
-
-function loadBalance(): BalanceData {
-  if (!fs.existsSync(BALANCE_FILE)) {
-    return { repos: {} };
-  }
-
-  const data = fs.readFileSync(BALANCE_FILE, 'utf-8');
-  return JSON.parse(data);
-}
-
-function saveBalance(data: BalanceData): void {
-  fs.writeFileSync(BALANCE_FILE, JSON.stringify(data, null, 2));
-}
-
-export function getBalance(): number {
-  const repoPath = getRepoPath() || 'global';
-  const data = loadBalance();
-
-  if (!data.repos[repoPath]) {
-    // Initialize new repo
-    data.repos[repoPath] = {
-      balance: 100,
-      totalCommits: 0,
-      totalWinnings: 0,
-      biggestWin: 0,
-      lastCommit: ''
-    };
-    saveBalance(data);
-  }
-
-  return data.repos[repoPath].balance;
-}
-
-export function updateBalance(hash: string, payout: number): number {
-  const repoPath = getRepoPath() || 'global';
-  const data = loadBalance();
-
-  if (!data.repos[repoPath]) {
-    data.repos[repoPath] = {
-      balance: 100,
-      totalCommits: 0,
-      totalWinnings: 0,
-      biggestWin: 0,
-      lastCommit: ''
-    };
-  }
-
-  const repo = data.repos[repoPath];
-
-  // Deduct cost
-  repo.balance -= 10;
-  repo.totalCommits += 1;
-
-  // Add winnings
-  if (payout > 0) {
-    repo.balance += payout;
-    repo.totalWinnings += payout;
-    repo.biggestWin = Math.max(repo.biggestWin, payout);
-  }
-
-  repo.lastCommit = hash;
-
-  saveBalance(data);
-  return repo.balance;
-}
-
-export function setBalance(newBalance: number): void {
-  const repoPath = getRepoPath() || 'global';
-  const data = loadBalance();
-
-  if (!data.repos[repoPath]) {
-    data.repos[repoPath] = {
-      balance: newBalance,
-      totalCommits: 0,
-      totalWinnings: 0,
-      biggestWin: 0,
-      lastCommit: ''
-    };
-  } else {
-    data.repos[repoPath].balance = newBalance;
-  }
-
-  saveBalance(data);
-}
-
-export function getRepoStats() {
-  const repoPath = getRepoPath() || 'global';
-  const data = loadBalance();
-  return data.repos[repoPath] || null;
-}

package/src/commands/auth.ts

@@ -1,92 +0,0 @@
-import chalk from 'chalk';
-import { createToken, logout as apiLogout, verifyToken } from '../api.js';
-import { setApiToken, clearApiToken, getApiToken, getApiUrl, setGitHubUsername } from '../config.js';
-
-export async function authLoginCommand(githubUsername: string): Promise<void> {
-  try {
-    console.log(chalk.dim(`Generating token for ${githubUsername}...`));
-
-    // Generate token from GitHub username
-    const token = await createToken(githubUsername);
-
-    if (!token) {
-      console.error(chalk.red('Failed to generate token. Please check your GitHub username.'));
-      process.exit(1);
-    }
-
-    // Save token and username
-    setApiToken(token);
-    setGitHubUsername(githubUsername);
-
-    console.log(chalk.green('Successfully authenticated!'));
-    console.log(chalk.dim(`Token saved. API URL: ${getApiUrl()}`));
-    console.log(chalk.dim(`GitHub Username: ${githubUsername}`));
-    console.log();
-    console.log(chalk.yellow('Data sent to server on each commit:'));
-    console.log(chalk.dim('  • Commit hash (7 and 40 character versions)'));
-    console.log(chalk.dim('  • Repository URL, owner, and name'));
-    console.log(chalk.dim('  • GitHub username'));
-    console.log(chalk.dim('  • Pattern type, payout, and balance'));
-    console.log();
-    console.log(chalk.dim('To disable sync: git-slot-machine config set sync-enabled false'));
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}
-
-export async function authLogoutCommand(): Promise<void> {
-  try {
-    const token = getApiToken();
-
-    if (!token) {
-      console.log(chalk.yellow('Not currently authenticated.'));
-      return;
-    }
-
-    // Try to revoke token on server
-    await apiLogout();
-
-    // Clear local token
-    clearApiToken();
-
-    console.log(chalk.green('Successfully logged out.'));
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}
-
-export async function authStatusCommand(): Promise<void> {
-  try {
-    const token = getApiToken();
-    const apiUrl = getApiUrl();
-
-    if (!token) {
-      console.log(chalk.yellow('Not authenticated.'));
-      console.log(chalk.dim(`API URL: ${apiUrl}`));
-      console.log();
-      console.log('To authenticate, run:');
-      console.log(chalk.cyan('  git-slot-machine auth login <your-github-username>'));
-      return;
-    }
-
-    // Verify token is still valid
-    const isValid = await verifyToken(token);
-
-    if (isValid) {
-      console.log(chalk.green('Authenticated'));
-      console.log(chalk.dim(`API URL: ${apiUrl}`));
-      console.log(chalk.dim(`Token: ${token.substring(0, 10)}...`));
-    } else {
-      console.log(chalk.red('Authentication expired or invalid.'));
-      console.log(chalk.dim(`API URL: ${apiUrl}`));
-      console.log();
-      console.log('Please login again:');
-      console.log(chalk.cyan('  git-slot-machine auth login <your-github-username>'));
-    }
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}

package/src/commands/balance.ts

@@ -1,28 +0,0 @@
-import chalk from 'chalk';
-import { getRepoStats } from '../balance.js';
-
-export function balanceCommand(): void {
-  try {
-    const stats = getRepoStats();
-
-    if (!stats) {
-      console.log(chalk.yellow('No balance data for this repository'));
-      console.log(chalk.dim('Run a commit or use "git-slot-machine spin" to start playing'));
-      return;
-    }
-
-    console.log();
-    console.log(chalk.cyan.bold('Repository Stats'));
-    console.log(chalk.dim('━'.repeat(40)));
-    console.log(chalk.white(`Balance:        ${stats.balance >= 0 ? chalk.green(stats.balance) : chalk.red(stats.balance)} points`));
-    console.log(chalk.white(`Total Commits:  ${stats.totalCommits}`));
-    console.log(chalk.white(`Total Winnings: ${chalk.yellow(stats.totalWinnings)} points`));
-    console.log(chalk.white(`Biggest Win:    ${chalk.yellow(stats.biggestWin)} points`));
-    console.log(chalk.white(`Last Commit:    ${chalk.dim(stats.lastCommit)}`));
-    console.log();
-
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}

package/src/commands/config.ts

@@ -1,59 +0,0 @@
-import chalk from 'chalk';
-import {
-  getApiUrl,
-  setApiUrl,
-  isSyncEnabled,
-  setSyncEnabled,
-  getConfig
-} from '../config.js';
-
-export async function configGetCommand(key: string): Promise<void> {
-  try {
-    const config = getConfig();
-
-    switch (key) {
-      case 'api-url':
-        console.log(getApiUrl());
-        break;
-      case 'sync-enabled':
-        console.log(isSyncEnabled());
-        break;
-      case 'all':
-        console.log(chalk.bold('Configuration:'));
-        console.log(`  API URL: ${chalk.cyan(getApiUrl())}`);
-        console.log(`  Sync Enabled: ${chalk.cyan(isSyncEnabled())}`);
-        console.log(`  Has Token: ${chalk.cyan(config.apiToken ? 'yes' : 'no')}`);
-        break;
-      default:
-        console.error(chalk.red(`Unknown config key: ${key}`));
-        console.log('Available keys: api-url, sync-enabled, all');
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}
-
-export async function configSetCommand(key: string, value: string): Promise<void> {
-  try {
-    switch (key) {
-      case 'api-url':
-        setApiUrl(value);
-        console.log(chalk.green(`API URL set to: ${value}`));
-        break;
-      case 'sync-enabled':
-        const enabled = value.toLowerCase() === 'true' || value === '1';
-        setSyncEnabled(enabled);
-        console.log(chalk.green(`Sync ${enabled ? 'enabled' : 'disabled'}`));
-        break;
-      default:
-        console.error(chalk.red(`Unknown config key: ${key}`));
-        console.log('Available keys: api-url, sync-enabled');
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(chalk.red(`Error: ${(error as Error).message}`));
-    process.exit(1);
-  }
-}