git-slot-machine 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,121 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { isGitRepo } from '../utils/git';
+import { POST_COMMIT_HOOK } from '../templates/post-commit';
+import { getRepoInfo, setGitHubUsername, getGitHubUsername } from '../config';
+
+async function isRepoPublic(owner: string, repo: string): Promise<boolean | null> {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+      headers: {
+        'Accept': 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json() as { private: boolean };
+      return data.private === false;
+    }
+
+    // 404 could mean private or doesn't exist
+    return null;
+  } catch (error) {
+    // Network error or API unavailable
+    return null;
+  }
+}
+
+export async function initCommand(): Promise<void> {
+  // Check if git repo
+  if (!isGitRepo()) {
+    console.error(chalk.red('Error: Not a git repository'));
+    console.log(chalk.dim('Run this command from the root of a git repository'));
+    process.exit(1);
+  }
+
+  // Extract and save GitHub username from remote URL (do this first)
+  const repoInfo = getRepoInfo();
+
+  if (!repoInfo) {
+    console.log();
+    console.error(chalk.red('Error: No GitHub remote detected'));
+    console.log();
+    console.log(chalk.yellow('Git Slot Machine requires a public GitHub repository.'));
+    console.log();
+    console.log(chalk.dim('Add a GitHub remote to this repo:'));
+    console.log(chalk.cyan('  git remote add origin https://github.com/username/repo.git'));
+    console.log();
+    console.log(chalk.dim('This prevents farming points in private/local repos.'));
+    console.log(chalk.dim('Your commits must be publicly verifiable.'));
+    process.exit(1);
+  }
+
+  const existingUsername = getGitHubUsername();
+  if (!existingUsername) {
+    setGitHubUsername(repoInfo.owner);
+    console.log(chalk.dim(`Detected GitHub username: ${repoInfo.owner}`));
+  }
+
+  // Check if repository is public
+  console.log(chalk.dim('Checking repository visibility...'));
+  const isPublic = await isRepoPublic(repoInfo.owner, repoInfo.name);
+
+  if (isPublic === false) {
+    console.log();
+    console.error(chalk.red('Error: Private repository detected'));
+    console.log();
+    console.log(chalk.yellow('Git Slot Machine only supports public repositories.'));
+    console.log();
+    console.log(chalk.dim('Why? Your commit hashes would be visible on the public'));
+    console.log(chalk.dim('leaderboard, which could expose information about your'));
+    console.log(chalk.dim('private repository.'));
+    console.log();
+    console.log(chalk.dim('Please use git-slot-machine with a public repository.'));
+    process.exit(1);
+  }
+
+  if (isPublic === null) {
+    console.log(chalk.yellow('⚠️  Could not verify repository visibility'));
+    console.log(chalk.dim('Proceeding with installation...'));
+  } else {
+    console.log(chalk.green('✓ Public repository confirmed'));
+  }
+
+  const hookPath = path.join(process.cwd(), '.git', 'hooks', 'post-commit');
+
+  // Check if hook already exists
+  if (fs.existsSync(hookPath)) {
+    console.log(chalk.yellow('Warning: post-commit hook already exists'));
+    console.log(chalk.dim(`Location: ${hookPath}`));
+
+    // TODO: Could add merge logic or backup existing hook
+    console.log(chalk.red('Aborting to avoid overwriting existing hook'));
+    console.log(chalk.dim('Manually add git-slot-machine to your existing hook'));
+    process.exit(1);
+  }
+
+  // Write the hook
+  fs.writeFileSync(hookPath, POST_COMMIT_HOOK, { mode: 0o755 });
+
+  console.log(chalk.green('✓ Post-commit hook installed'));
+  console.log();
+  console.log(chalk.cyan('Git Slot Machine is ready!'));
+  console.log(chalk.dim('Every commit will now spin the slot machine.'));
+  console.log();
+  console.log('Try it out:');
+  console.log(chalk.dim('  git commit --allow-empty -m "test"'));
+  console.log();
+  console.log(chalk.cyan('Optional: Sync with the API'));
+  console.log(chalk.dim(`  git-slot-machine auth login ${repoInfo?.owner || 'your-github-username'}`));
+  console.log();
+  console.log(chalk.yellow('What gets sent to the server:'));
+  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('You can disable API sync anytime:'));
+  console.log(chalk.dim('  git-slot-machine config set sync-enabled false'));
+}

package/src/commands/play.ts

@@ -0,0 +1,150 @@
+import { detectPattern } from '../patterns';
+import { animateSlotMachine, animateSmallMode } from '../animation/slotMachine';
+import { getBalance, updateBalance, setBalance } from '../balance';
+import { sendPlayToAPI } from '../api';
+import { getRepoInfo, getGitHubUsername } from '../config';
+import chalk from 'chalk';
+
+interface PlayOptions {
+  small?: boolean;
+  fullHash?: string;  // Optional full hash for CLI integration
+}
+
+export async function playCommand(hash: string, options: PlayOptions): Promise<void> {
+  try {
+    // Get balance before playing
+    const balanceBefore = getBalance();
+
+    // Detect pattern
+    const result = detectPattern(hash);
+
+    // Animate based on mode
+    const config = {
+      finalHash: hash.toLowerCase(),
+      small: options.small || false,
+      patternResult: result
+    };
+
+    if (options.small) {
+      await animateSmallMode(config);
+    } else {
+      await animateSlotMachine(config);
+    }
+
+    // Show result
+    if (!options.small) {
+      console.log();
+
+      // Center the text below the box (box width is 41 chars)
+      const boxWidth = 41;
+
+      if (result.payout > 0) {
+        const resultText = `${result.name}!`;
+        const resultPadding = Math.floor((boxWidth - resultText.length) / 2);
+        console.log(' '.repeat(resultPadding) + chalk.cyan.bold(resultText));
+
+        const payoutText = `+${result.payout} points`;
+        const payoutPadding = Math.floor((boxWidth - payoutText.length) / 2);
+        console.log(' '.repeat(payoutPadding) + chalk.white.bold(payoutText));
+      } else {
+        const noWinText = 'No win';
+        const noWinPadding = Math.floor((boxWidth - noWinText.length) / 2);
+        console.log(' '.repeat(noWinPadding) + chalk.red.bold(noWinText));
+
+        const lossText = '-10 points';
+        const lossPadding = Math.floor((boxWidth - lossText.length) / 2);
+        console.log(' '.repeat(lossPadding) + chalk.white.bold(lossText));
+      }
+
+      console.log();
+      const descText = result.description;
+      const descPadding = Math.floor((boxWidth - descText.length) / 2);
+      console.log(' '.repeat(descPadding) + chalk.dim(descText));
+    }
+
+    // Validate GitHub remote for API sync
+    const repoInfo = getRepoInfo();
+    const githubUsername = getGitHubUsername();
+
+    if (!repoInfo && githubUsername) {
+      console.log();
+      console.log(chalk.yellow.bold('⚠ Warning: No GitHub remote detected'));
+      console.log(chalk.dim('This repo will not sync to the leaderboard.'));
+      console.log(chalk.dim('To sync, add a GitHub remote:'));
+      console.log(chalk.cyan('  git remote add origin https://github.com/username/repo.git'));
+      console.log();
+    }
+
+    // Update balance locally
+    let newBalance = updateBalance(hash.toLowerCase(), result.payout);
+
+    // Send to API and sync balance with server
+    let shareUrl: string | undefined;
+
+    if (repoInfo && githubUsername) {
+      const playData: any = {
+        commit_hash: hash.toLowerCase(),
+        pattern_type: result.type,
+        pattern_name: result.name,
+        payout: result.payout,
+        wager: 10,
+        balance_before: balanceBefore,
+        balance_after: newBalance,
+        repo_url: repoInfo.url,
+        github_username: githubUsername,
+        repo_owner: repoInfo.owner,
+        repo_name: repoInfo.name,
+      };
+
+      // Only send full hash if we have one (not in test mode)
+      if (options.fullHash && options.fullHash.length === 40) {
+        playData.commit_full_hash = options.fullHash;
+      }
+
+      try {
+        const apiResponse = await sendPlayToAPI(playData);
+        // Sync local balance to match server's balance
+        if (apiResponse && apiResponse.balance !== undefined) {
+          setBalance(apiResponse.balance);
+          newBalance = apiResponse.balance;
+          shareUrl = apiResponse.share_url;
+        }
+      } catch (error) {
+        // Silently fail - local play already succeeded
+      }
+    }
+
+    // Show result and balance
+    if (options.small) {
+      // Small mode - everything on one line (animateSmallMode already wrote the hash without newline)
+      if (result.payout > 0) {
+        console.log(chalk.dim(' • ') + chalk.cyan.bold(`${result.name} +${result.payout}`) + chalk.dim(' • ') + chalk.white(`Balance: ${chalk.green.bold(newBalance)}`));
+      } else {
+        console.log(chalk.dim(' • ') + chalk.red('No win -10') + chalk.dim(' • ') + chalk.white(`Balance: ${newBalance >= 0 ? chalk.green.bold(newBalance) : chalk.red.bold(newBalance)}`));
+      }
+    } else {
+      console.log();
+      const boxWidth = 41;
+      // Note: we can't measure the exact length with color codes, so estimate based on text content
+      const balanceText = `Balance: ${newBalance} points`;
+      const balancePadding = Math.floor((boxWidth - balanceText.length) / 2);
+      console.log(' '.repeat(balancePadding) + chalk.white.bold(`Balance: ${newBalance >= 0 ? chalk.green.bold(newBalance) : chalk.red.bold(newBalance)} points`));
+    }
+
+    // Show share URL for wins
+    if (shareUrl && result.payout > 0 && !options.small) {
+      console.log();
+      const boxWidth = 41;
+      const shareText = 'Share your win:';
+      const sharePadding = Math.floor((boxWidth - shareText.length) / 2);
+      console.log(' '.repeat(sharePadding) + chalk.dim(shareText));
+
+      const urlPadding = Math.floor((boxWidth - shareUrl.length) / 2);
+      console.log(' '.repeat(urlPadding) + chalk.green.underline(shareUrl));
+    }
+
+  } catch (error) {
+    console.error(chalk.red(`Error: ${(error as Error).message}`));
+    process.exit(1);
+  }
+}

package/src/commands/spin.ts

@@ -0,0 +1,17 @@
+import { getCurrentCommitHash, getCurrentCommitFullHash } from '../utils/git';
+import { playCommand } from './play';
+
+interface SpinOptions {
+  small?: boolean;
+}
+
+export async function spinCommand(options: SpinOptions): Promise<void> {
+  try {
+    const hash = getCurrentCommitHash();
+    const fullHash = getCurrentCommitFullHash();
+    await playCommand(hash, { ...options, fullHash });
+  } catch (error) {
+    console.error(`Error: ${(error as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { getBalance as getApiBalance } from '../api';
+import { getBalance as getLocalBalance } from '../balance';
+
+export async function syncCommand(): Promise<void> {
+  try {
+    console.log(chalk.dim('Syncing with API...'));
+
+    const apiBalance = await getApiBalance();
+
+    if (!apiBalance) {
+      console.log(chalk.yellow('Unable to sync with API.'));
+      console.log(chalk.dim('Make sure you are authenticated and online.'));
+      return;
+    }
+
+    const localBalance = getLocalBalance();
+
+    console.log();
+    console.log(chalk.bold('Local Balance:'));
+    console.log(`  Balance: ${chalk.green(localBalance)} points`);
+    console.log();
+    console.log(chalk.bold('API Balance:'));
+    console.log(`  Balance: ${chalk.green(apiBalance.balance)} points`);
+    console.log(`  Total Commits: ${chalk.cyan(apiBalance.total_commits)}`);
+    console.log(`  Total Winnings: ${chalk.cyan(apiBalance.total_winnings)}`);
+
+    // Show biggest win with pattern and hash
+    if (apiBalance.biggest_win > 0) {
+      const winText = `${chalk.cyan(apiBalance.biggest_win)} points`;
+      const patternText = apiBalance.biggest_win_pattern ? ` (${chalk.yellow(apiBalance.biggest_win_pattern)})` : '';
+      const hashText = apiBalance.biggest_win_hash ? chalk.dim(` - ${apiBalance.biggest_win_hash}`) : '';
+      console.log(`  Biggest Win: ${winText}${patternText}${hashText}`);
+    } else {
+      console.log(`  Biggest Win: ${chalk.cyan(apiBalance.biggest_win)}`);
+    }
+    console.log();
+
+    if (localBalance !== apiBalance.balance) {
+      console.log(chalk.yellow('Warning: Local and API balances differ.'));
+      console.log(chalk.dim('This is normal if you play offline or in multiple repos.'));
+    } else {
+      console.log(chalk.green('Balances are in sync!'));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error: ${(error as Error).message}`));
+    process.exit(1);
+  }
+}

package/src/commands/test.ts

@@ -0,0 +1,19 @@
+import { playCommand } from './play';
+
+interface TestOptions {
+  small?: boolean;
+}
+
+function generateRandomHash(): string {
+  const hexChars = '0123456789abcdef';
+  let hash = '';
+  for (let i = 0; i < 7; i++) {
+    hash += hexChars[Math.floor(Math.random() * hexChars.length)];
+  }
+  return hash;
+}
+
+export async function testCommand(options: TestOptions): Promise<void> {
+  const randomHash = generateRandomHash();
+  await playCommand(randomHash, options);
+}

package/src/config.ts

@@ -0,0 +1,154 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+interface Config {
+  githubUsername?: string;
+  apiUrl?: string;
+  apiToken?: string;
+  syncEnabled?: 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();
+  return config.githubUsername || null;
+}
+
+export function setGitHubUsername(username: string): void {
+  const config = getRepoConfig();
+  config.githubUsername = username;
+  saveRepoConfig(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 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];
+      return {
+        owner,
+        name,
+        url: `https://github.com/${owner}/${name}`,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { playCommand } from './commands/play';
+import { spinCommand } from './commands/spin';
+import { initCommand } from './commands/init';
+import { balanceCommand } from './commands/balance';
+import { testCommand } from './commands/test';
+import { authLoginCommand, authLogoutCommand, authStatusCommand } from './commands/auth';
+import { syncCommand } from './commands/sync';
+import { configGetCommand, configSetCommand } from './commands/config';
+
+const program = new Command();
+
+program
+  .name('git-slot-machine')
+  .description('Git commit hash slot machine')
+  .version('0.1.0');
+
+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
+const auth = program
+  .command('auth')
+  .description('Manage API authentication');
+
+auth
+  .command('login')
+  .description('Login with GitHub username')
+  .argument('<github-username>', 'Your GitHub username')
+  .action(async (githubUsername: string) => {
+    await authLoginCommand(githubUsername);
+  });
+
+auth
+  .command('logout')
+  .description('Logout and clear API token')
+  .action(async () => {
+    await authLogoutCommand();
+  });
+
+auth
+  .command('status')
+  .description('Show authentication status')
+  .action(async () => {
+    await authStatusCommand();
+  });
+
+// Sync command
+program
+  .command('sync')
+  .description('Sync balance with API')
+  .action(async () => {
+    await syncCommand();
+  });
+
+// Config commands
+const config = program
+  .command('config')
+  .description('Manage CLI configuration');
+
+config
+  .command('get')
+  .description('Get configuration value')
+  .argument('<key>', 'Configuration key (api-url, sync-enabled, all)')
+  .action(async (key: string) => {
+    await configGetCommand(key);
+  });
+
+config
+  .command('set')
+  .description('Set configuration value')
+  .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

@@ -0,0 +1,44 @@
+import { detectPattern, PatternType } from './patterns';
+
+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');
+  });
+});