numerology/name-optimizer.ts

#!/usr/bin/env bun
/**
 * Name Optimizer - "Rainbow Tables for Numerology" 🔮
 *
 * Intelligently searches through name variations to find those that
 * produce master numbers or target specific numerology values.
 *
 * Like a hash cracker, but instead of cracking passwords, we're
 * discovering your most powerful name variations!
 *
 * Usage:
 *   bun name-optimizer.ts -b "1/1/1980" -c "John Smith" --find-masters
 *   bun name-optimizer.ts -b "5/13/1982" -c "Jane Smith" --purpose spiritual
 *   bun name-optimizer.ts -b "3/14/1985" -c "John Doe" --target-expression 8
 */

import { calculateCoreNumbers, calculateAdditionalNumbers } from './core-calculator';

// Parse command line arguments
const args = process.argv.slice(2);
let birthdate = '';
let currentName = '';
let findMasters = false;
let purpose = '';
let targetExpression: number | null = null;
let targetSoulUrge: number | null = null;
let maxResults = 20;

for (let i = 0; i < args.length; i++) {
  if ((args[i] === '--birthdate' || args[i] === '-b') && args[i + 1]) {
    birthdate = args[i + 1];
    i++;
  } else if ((args[i] === '--current' || args[i] === '-c') && args[i + 1]) {
    currentName = args[i + 1];
    i++;
  } else if (args[i] === '--find-masters' || args[i] === '-m') {
    findMasters = true;
  } else if ((args[i] === '--purpose' || args[i] === '-p') && args[i + 1]) {
    purpose = args[i + 1].toLowerCase();
    i++;
  } else if (args[i] === '--target-expression' && args[i + 1]) {
    targetExpression = parseInt(args[i + 1]);
    i++;
  } else if (args[i] === '--target-soul-urge' && args[i + 1]) {
    targetSoulUrge = parseInt(args[i + 1]);
    i++;
  } else if ((args[i] === '--max' || args[i] === '-n') && args[i + 1]) {
    maxResults = parseInt(args[i + 1]);
    i++;
  } else if (args[i] === '--help' || args[i] === '-h') {
    console.log(`
Name Optimizer - Rainbow Tables for Numerology 🔮

Intelligently search through name variations to find ones that unlock
master numbers or target specific numerology values.

USAGE:
  bun name-optimizer.ts --birthdate "mm/dd/yyyy" --current "Your Name" [OPTIONS]

OPTIONS:
  -b, --birthdate DATE       Your birthdate (mm/dd/yyyy) [required]
  -c, --current NAME         Your current/base name [required]
  -m, --find-masters         Find ANY master numbers (11, 22, 33)
  -p, --purpose TYPE         Optimize for purpose: spiritual, business, creative
  --target-expression NUM    Find names with specific Expression number
  --target-soul-urge NUM     Find names with specific Soul Urge number
  -n, --max NUMBER           Max results to show [default: 20]
  -h, --help                 Show this help message

PURPOSES:
  spiritual  → Targets master 11, 7, 9 (intuition, wisdom, compassion)
  business   → Targets 8, 1, 22 (power, leadership, master building)
  creative   → Targets 3, 5, 11 (expression, freedom, inspiration)
  teaching   → Targets 6, 33 (service, master teaching)
  analytical → Targets 7, 4 (wisdom, structure)

EXAMPLES:
  # Find any master numbers
  bun name-optimizer.ts -b "1/1/1980" -c "John Smith" --find-masters

  # Optimize for spiritual writing pseudonym
  bun name-optimizer.ts -b "5/13/1982" -c "Jane Smith" --purpose spiritual

  # Find names with Expression 8 (business power)
  bun name-optimizer.ts -b "3/14/1985" -c "John Doe" --target-expression 8

  # Find names with Soul Urge 11 (intuitive desires)
  bun name-optimizer.ts -b "7/7/1990" -c "Sarah Jones" --target-soul-urge 11

WHAT IT DOES:
  1. Generates intelligent variations of your name
  2. Tests each variation's numerology
  3. Scores and ranks results
  4. Shows you the most powerful variations

NOTE: This is like a "hash cracker" but for unlocking your name's
      hidden numerological potential! 🔮
    `);
    process.exit(0);
  }
}

if (!birthdate || !currentName) {
  console.error('Error: --birthdate and --current are required');
  console.error('Try: bun name-optimizer.ts --help');
  process.exit(1);
}

if (!findMasters && !purpose && targetExpression === null && targetSoulUrge === null) {
  console.error('Error: Specify search criteria: --find-masters, --purpose, --target-expression, or --target-soul-urge');
  console.error('Try: bun name-optimizer.ts --help');
  process.exit(1);
}

// Common nickname mappings
const nicknameMap: Record<string, string[]> = {
  'robert': ['rob', 'bob', 'bobby', 'robbie', 'bert', 'robby'],
  'william': ['will', 'bill', 'billy', 'liam', 'willy'],
  'richard': ['rick', 'dick', 'rich', 'ricky', 'richie'],
  'michael': ['mike', 'mick', 'mikey', 'mickey'],
  'james': ['jim', 'jimmy', 'jamie', 'jay'],
  'john': ['jack', 'johnny', 'jon'],
  'joseph': ['joe', 'joey', 'jo'],
  'david': ['dave', 'davey', 'davy'],
  'christopher': ['chris', 'topher', 'kit'],
  'daniel': ['dan', 'danny'],
  'matthew': ['matt', 'matty'],
  'anthony': ['tony', 'ant'],
  'thomas': ['tom', 'tommy', 'thom'],
  'charles': ['charlie', 'chuck', 'chas'],
  'jennifer': ['jen', 'jenny', 'jenn'],
  'elizabeth': ['liz', 'beth', 'betty', 'libby', 'eliza'],
  'jessica': ['jess', 'jessie'],
  'sarah': ['sara'],
  'rebecca': ['becky', 'becca', 'bex'],
  'katherine': ['kate', 'katie', 'kathy', 'kat', 'kath'],
  'margaret': ['maggie', 'meg', 'peggy', 'marge'],
  'patricia': ['pat', 'patty', 'trish'],
  'christine': ['chris', 'chrissy', 'christie'],
  'amanda': ['mandy', 'manda'],
  'stephanie': ['steph', 'steffi', 'stephie']
};

interface NameVariation {
  name: string;
  expression: number;
  soulUrge: number;
  personality: number;
  maturity: number;
  hiddenPassion: number | null;
  masterCount: number;
  score: number;
}

function generateVariations(fullName: string): string[] {
  const variations = new Set<string>();
  variations.add(fullName); // Original

  const parts = fullName.trim().split(/\s+/);
  if (parts.length < 2) {
    console.error('Error: Please provide at least first and last name');
    process.exit(1);
  }

  const firstName = parts[0].toLowerCase();
  const lastName = parts[parts.length - 1];
  const middleNames = parts.slice(1, -1);

  // 1. Nickname variations
  const nicknames = nicknameMap[firstName] || [];
  nicknames.forEach(nick => {
    variations.add(`${nick.charAt(0).toUpperCase() + nick.slice(1)} ${lastName}`);

    // With middle initials
    middleNames.forEach(middle => {
      variations.add(`${nick.charAt(0).toUpperCase() + nick.slice(1)} ${middle.charAt(0)}. ${lastName}`);
    });
  });

  // 2. Initial variations
  variations.add(`${firstName.charAt(0).toUpperCase()}. ${lastName}`);
  variations.add(`${firstName.charAt(0).toUpperCase()} ${lastName}`);

  // 3. Full name with middle initial
  middleNames.forEach(middle => {
    variations.add(`${parts[0]} ${middle.charAt(0)}. ${lastName}`);
    variations.add(`${parts[0]} ${middle.charAt(0)} ${lastName}`);
  });

  // 4. Double initials
  if (middleNames.length > 0) {
    const middleInitial = middleNames[0].charAt(0).toUpperCase();
    variations.add(`${firstName.charAt(0).toUpperCase()}. ${middleInitial}. ${lastName}`);
    variations.add(`${firstName.charAt(0).toUpperCase()}${middleInitial} ${lastName}`);
  }

  // 5. Common middle initials to try
  const commonMiddle = ['J', 'A', 'M', 'L', 'R', 'K', 'E', 'T', 'S', 'C'];
  commonMiddle.forEach(initial => {
    variations.add(`${parts[0]} ${initial}. ${lastName}`);
    variations.add(`${parts[0]} ${initial} ${lastName}`);

    // With nicknames
    nicknames.forEach(nick => {
      variations.add(`${nick.charAt(0).toUpperCase() + nick.slice(1)} ${initial}. ${lastName}`);
    });
  });

  // 6. Professional titles
  variations.add(`Dr. ${fullName}`);
  variations.add(`Dr ${parts[0]} ${lastName}`);

  // 7. Abbreviated first name
  const shortFirst = parts[0].slice(0, Math.min(4, parts[0].length));
  if (shortFirst !== parts[0]) {
    variations.add(`${shortFirst} ${lastName}`);
  }

  return Array.from(variations);
}

function analyzeVariation(name: string, birthdate: string): NameVariation {
  const coreNumbers = calculateCoreNumbers(name, birthdate);
  const additionalNumbers = calculateAdditionalNumbers(name, coreNumbers);

  // Count master numbers
  let masterCount = 0;
  if ([11, 22, 33].includes(coreNumbers.expression)) masterCount++;
  if ([11, 22, 33].includes(coreNumbers.soulUrge)) masterCount++;
  if ([11, 22, 33].includes(additionalNumbers.personality)) masterCount++;
  if ([11, 22, 33].includes(additionalNumbers.maturity)) masterCount++;

  return {
    name,
    expression: coreNumbers.expression,
    soulUrge: coreNumbers.soulUrge,
    personality: additionalNumbers.personality,
    maturity: additionalNumbers.maturity,
    hiddenPassion: additionalNumbers.hiddenPassion,
    masterCount,
    score: 0 // Will calculate later
  };
}

function calculateScore(variation: NameVariation, criteria: any): number {
  let score = 50; // Base score

  // Master number bonus
  score += variation.masterCount * 20;

  // Target matching
  if (criteria.targetExpression !== null) {
    if (variation.expression === criteria.targetExpression) score += 30;
  }
  if (criteria.targetSoulUrge !== null) {
    if (variation.soulUrge === criteria.targetSoulUrge) score += 30;
  }

  // Purpose alignment
  if (criteria.purpose === 'spiritual') {
    if ([11, 7, 9].includes(variation.expression)) score += 15;
    if ([11, 7, 9].includes(variation.soulUrge)) score += 10;
  } else if (criteria.purpose === 'business') {
    if ([8, 1, 22].includes(variation.expression)) score += 15;
    if ([8, 1].includes(variation.soulUrge)) score += 10;
  } else if (criteria.purpose === 'creative') {
    if ([3, 5, 11].includes(variation.expression)) score += 15;
    if ([3, 5].includes(variation.soulUrge)) score += 10;
  } else if (criteria.purpose === 'teaching') {
    if ([6, 33].includes(variation.expression)) score += 15;
    if ([6, 33].includes(variation.soulUrge)) score += 10;
  } else if (criteria.purpose === 'analytical') {
    if ([7, 4].includes(variation.expression)) score += 15;
    if ([7, 4].includes(variation.soulUrge)) score += 10;
  }

  // Hidden passion bonus
  if (variation.hiddenPassion && [11, 22, 33].includes(variation.hiddenPassion)) {
    score += 5;
  }

  return Math.min(100, score);
}

// Main execution
console.log(`\n🔮 NAME OPTIMIZER - Rainbow Tables for Numerology`);
console.log(`═══════════════════════════════════════════════════════════════\n`);

console.log(`Base Name: ${currentName}`);
console.log(`Birthdate: ${birthdate}`);

if (findMasters) {
  console.log(`Goal: Find ANY master numbers (11, 22, 33)\n`);
} else if (purpose) {
  console.log(`Goal: Optimize for ${purpose} purpose\n`);
} else if (targetExpression) {
  console.log(`Goal: Find Expression ${targetExpression}\n`);
} else if (targetSoulUrge) {
  console.log(`Goal: Find Soul Urge ${targetSoulUrge}\n`);
}

// Show baseline/input name values
console.log(`═══════════════════════════════════════════════════════════════`);
console.log(`📍 BASELINE (Input Name)`);
console.log(`═══════════════════════════════════════════════════════════════\n`);

const baselineAnalysis = analyzeVariation(currentName, birthdate);
console.log(`Name: ${currentName}`);
console.log(`Expression:   ${baselineAnalysis.expression}${[11, 22, 33].includes(baselineAnalysis.expression) ? ' ⭐ MASTER' : ''}`);
console.log(`Soul Urge:    ${baselineAnalysis.soulUrge}${[11, 22, 33].includes(baselineAnalysis.soulUrge) ? ' ⭐ MASTER' : ''}`);
console.log(`Personality:  ${baselineAnalysis.personality}${[11, 22, 33].includes(baselineAnalysis.personality) ? ' ⭐ MASTER' : ''}`);
console.log(`Maturity:     ${baselineAnalysis.maturity}${[11, 22, 33].includes(baselineAnalysis.maturity) ? ' ⭐ MASTER' : ''}`);
if (baselineAnalysis.hiddenPassion) {
  console.log(`Hidden Passion: ${baselineAnalysis.hiddenPassion}${[11, 22, 33].includes(baselineAnalysis.hiddenPassion) ? ' ⭐ MASTER' : ''}`);
}
console.log(`\n(Searching for variations with different values...)\n`);

console.log(`Generating variations...`);
const variations = generateVariations(currentName);
console.log(`Testing ${variations.length} name variations...\n`);

// Analyze all variations
const results: NameVariation[] = [];
const criteria = { findMasters, purpose, targetExpression, targetSoulUrge };

// Track unique combinations to avoid duplicates
const seenCombinations = new Set<string>();

for (const variant of variations) {
  const analysis = analyzeVariation(variant, birthdate);
  analysis.score = calculateScore(analysis, criteria);

  // Create a unique key based on numerology values
  const uniqueKey = `${analysis.expression}-${analysis.soulUrge}-${analysis.personality}-${analysis.maturity}-${analysis.hiddenPassion}`;

  // Skip if we've seen this exact combination
  if (seenCombinations.has(uniqueKey)) {
    continue;
  }
  seenCombinations.add(uniqueKey);

  // Filter based on criteria
  if (findMasters && analysis.masterCount > 0) {
    results.push(analysis);
  } else if (purpose && analysis.score >= 60) {
    results.push(analysis);
  } else if (targetExpression !== null && analysis.expression === targetExpression) {
    results.push(analysis);
  } else if (targetSoulUrge !== null && analysis.soulUrge === targetSoulUrge) {
    results.push(analysis);
  }
}

// Sort by score
results.sort((a, b) => b.score - a.score);

// Display results
if (results.length === 0) {
  console.log(`😞 No matches found. Try:`);
  console.log(`   • Different search criteria`);
  console.log(`   • Adding middle initials manually`);
  console.log(`   • Using --find-masters for broader search\n`);
  process.exit(0);
}

console.log(`✨ FOUND ${results.length} MATCHING NAME${results.length > 1 ? 'S' : ''}:\n`);
console.log(`═══════════════════════════════════════════════════════════════\n`);

const displayResults = results.slice(0, maxResults);

displayResults.forEach((result, index) => {
  const masterSymbols = '⭐'.repeat(result.masterCount);

  console.log(`${index + 1}. ${result.name} ${masterSymbols}`);
  console.log(`   Score: ${result.score}/100`);

  if ([11, 22, 33].includes(result.expression)) {
    console.log(`   Expression: ${result.expression} ⭐ MASTER`);
  } else {
    console.log(`   Expression: ${result.expression}`);
  }

  if ([11, 22, 33].includes(result.soulUrge)) {
    console.log(`   Soul Urge: ${result.soulUrge} ⭐ MASTER`);
  } else {
    console.log(`   Soul Urge: ${result.soulUrge}`);
  }

  if ([11, 22, 33].includes(result.personality)) {
    console.log(`   Personality: ${result.personality} ⭐ MASTER`);
  }

  if ([11, 22, 33].includes(result.maturity)) {
    console.log(`   Maturity: ${result.maturity} ⭐ MASTER`);
  }

  if (result.hiddenPassion && [11, 22, 33].includes(result.hiddenPassion)) {
    console.log(`   Hidden Passion: ${result.hiddenPassion} ⭐ MASTER`);
  }

  console.log('');
});

if (results.length > maxResults) {
  console.log(`... and ${results.length - maxResults} more results (use --max ${results.length} to see all)\n`);
}

console.log(`═══════════════════════════════════════════════════════════════`);
console.log(`💡 USAGE TIPS`);
console.log(`═══════════════════════════════════════════════════════════════\n`);

if (displayResults.length > 0 && displayResults[0].masterCount > 0) {
  console.log(`✨ Top result "${displayResults[0].name}" activates ${displayResults[0].masterCount} master number(s)!`);
  console.log(`   Use for: High-impact work, spiritual pursuits, or leadership\n`);
}

console.log(`📝 Next steps:`);
console.log(`   1. Test your top results with: bun name-change.ts`);
console.log(`   2. Use different variations for different contexts`);
console.log(`   3. Consider which variation "feels" right to you\n`);

console.log(`🔮 Remember: The most powerful name is one that resonates with your soul!\n`);