git-slot-machine 1.0.0

package/src/animation/slotMachine.ts

@@ -0,0 +1,159 @@
+import chalk from 'chalk';
+import { PatternResult } from '../patterns';
+
+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 || [];
+
+  // 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));
+  }
+
+  // Final reveal with flashing
+  const finalChars = finalHash.split('');
+
+  // Flash 3 times if there are highlighted characters
+  if (highlightIndices.length > 0) {
+    for (let flashCount = 0; flashCount < 3; flashCount++) {
+      // Flash on
+      console.clear();
+      drawSlotMachine(finalChars, false, highlightIndices, true);
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      // Flash off
+      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 || [];
+
+  // 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));
+  }
+
+  // Final with highlighting - don't add newline, let the caller add result info
+  clearLine();
+  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

@@ -0,0 +1,203 @@
+import { getApiUrl, getApiToken, isSyncEnabled } from './config';
+
+// 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();
+
+  // 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 fetch(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) {
+      return null;
+    }
+
+    const result = await response.json() as ApiResponse<{ token: string }>;
+    return result.data?.token || null;
+  } catch (error) {
+    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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import { createToken, logout as apiLogout, verifyToken } from '../api';
+import { setApiToken, clearApiToken, getApiToken, getApiUrl, setGitHubUsername } from '../config';
+
+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

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { getRepoStats } from '../balance';
+
+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

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import {
+  getApiUrl,
+  setApiUrl,
+  isSyncEnabled,
+  setSyncEnabled,
+  getConfig
+} from '../config';
+
+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);
+  }
+}