Vedic Numerology Calculator (VNC)

VNC/
├── apps/
│   ├── web/                    # Next.js 16 frontend
│   │   ├── src/
│   │   │   ├── app/           # App Router pages
│   │   │   │   ├── page.tsx   # Home/Calculator
│   │   │   │   ├── calculator/
│   │   │   │   └── results/
│   │   │   ├── components/    # React components
│   │   │   │   ├── features/results/
│   │   │   │   └── ui/
│   │   │   ├── animations/    # Framer Motion animations
│   │   │   └── utils/         # tRPC client
│   │   └── package.json
│   │
│   └── api/                   # Fastify + tRPC backend
│       ├── src/
│       │   ├── index.ts       # Fastify server entry
│       │   ├── router.ts      # tRPC router definition
│       │   ├── context.ts     # Request context
│       │   ├── routes/        # API routes
│       │   │   ├── numerology.router.ts
│       │   │   ├── remedies.router.ts
│       │   │   ├── reports.router.ts
│       │   │   ├── subscriptions.router.ts
│       │   │   ├── portfolio.router.ts
│       │   │   └── compatibility.router.ts
│       │   ├── services/      # Business logic
│       │   │   ├── ai-interpretation.service.ts
│       │   │   ├── remedy.service.ts
│       │   │   ├── report-generation.service.ts
│       │   │   └── portfolio-integration.service.ts
│       │   └── prisma/        # Database client
│       └── prisma/
│           └── schema.prisma  # Database schema
│
├── packages/
│   ├── shared-types/         # TypeScript interfaces
│   ├── validators/          # Zod validation schemas
│   └── utils/               # Core numerology algorithms
│       ├── src/
│       │   ├── numerology.ts # Core calculation functions
│       │   ├── mahadasha.ts  # Mahadasha period calculations
│       │   ├── compatibility.ts # Compatibility scoring
│       │   └── types.ts
│       └── package.json
│
├── docker-compose.yml        # Database container
└── turbo.json               # Turborepo config

// packages/utils/src/numerology.ts
export function reduceToSingleDigit(num: number): number {
    while (num > 9) {
        let sum = 0;
        while (num > 0) {
            sum += num % 10;
            num = Math.floor(num / 10);
        }
        num = sum;
    }
    return num;
}

export function calculateLifeNumber(day: number): number {
    return reduceToSingleDigit(day);
}

export function calculateDestinyNumber(day: number, month: number, year: number): number {
    const dStr = day.toString().padStart(2, '0');
    const mStr = month.toString().padStart(2, '0');
    const yStr = year.toString().padStart(4, '0');
    let totalSum = 0;
    for (const char of (dStr + mStr + yStr)) {
        totalSum += parseInt(char, 10);
    }
    return reduceToSingleDigit(totalSum);
}

// Chaldean/Vedic alphabet values for Name Number
const LETTER_VALUES: Record<string, number> = {
    'A': 1, 'I': 1, 'J': 1, 'Q': 1, 'Y': 1,
    'B': 2, 'K': 2, 'R': 2,
    'C': 3, 'G': 3, 'L': 3, 'S': 3,
    'D': 4, 'M': 4, 'T': 4,
    'E': 5, 'H': 5, 'N': 5, 'X': 5,
    'U': 6, 'V': 6, 'W': 6,
    'O': 7, 'Z': 7,
    'F': 8, 'P': 8
};

export function calculateNameNumber(name: string): number {
    const cleanName = name.toUpperCase().replace(/[^A-Z]/g, '');
    let totalSum = 0;
    for (const char of cleanName) {
        totalSum += LETTER_VALUES[char] || 0;
    }
    return reduceToSingleDigit(totalSum);
}

export function generateCoreGrid(dob: DateOfBirth, ln: number, dn: number): CoreNatalGrid {
    const { day, month, year } = dob;
    
    // Extract individual digits
    const dayStr = day.toString().padStart(2, '0');
    const D1 = parseInt(dayStr[0]);
    const D2 = parseInt(dayStr[1]);
    
    const monthStr = month.toString().padStart(2, '0');
    const M1 = parseInt(monthStr[0]);
    const M2 = parseInt(monthStr[1]);
    
    const yearStr = year.toString().padStart(4, '0');
    const Y3 = parseInt(yearStr[2]);
    const Y4 = parseInt(yearStr[3]);
    
    // Collect extracted values
    const extractedValues: number[] = [D1, D2, M1, M2, Y3, Y4];
    
    // Destiny Number is always included
    extractedValues.push(dn);
    
    // Life Number Logic (Conditional inclusion)
    const isRedundant = (ln === D1) || (ln === D2);
    if (!isRedundant) {
        extractedValues.push(ln);
    }
    
    // ... Grid placement logic follows specific Vedic rules
}

// Core Numerology Model
model NumerologyCalculation {
  id                    String   @id @default(uuid())
  tenantId              String
  userId                String
  
  // Input
  fullName              String
  dateOfBirth           DateTime
  
  // Calculated Values
  lifeNumber            Int
  destinyNumber         Int
  nameNumber            Int
  
  // Natal Grid
  natalGridValues       Int[]
  natalGridJson         Json
  
  // Mahadasha Phase
  currentMahadashaPhase Int?
  mahadashaStartDate    DateTime?
  mahadashaEndDate      DateTime?
  
  // Relations
  tenant                Tenant   @relation(fields: [tenantId], references: [id])
  user                  User     @relation(fields: [userId], references: [id])
  mahadashaPhases       MahadashaPhase[]
  reports               NumerologyReport[]
  
  @@map("numerology_calculations")
}

// Mahadasha Period Tracking
model MahadashaPhase {
  id            String   @id @default(uuid())
  calculationId String
  
  phaseNumber   Int
  planetName    String
  durationYears Int
  startDate     DateTime
  endDate       DateTime
  
  isCurrent     Boolean  @default(false)
  
  calculation   NumerologyCalculation @relation(...)
  
  @@map("mahadasha_phases")
}

// Premium Content Models
model PremiumNumberMeaning {
  id               String   @id @default(uuid())
  number           Int       // 1-9
  interpretationType String  // 'LIFE', 'DESTINY', 'NAME'
  
  detailedMeaning  String
  strengths        String[]
  weaknesses       String[]
  rulingPlanet     String?
  gemstoneRecs     String[]
  mantraRecs       String[]
  
  @@unique([number, interpretationType])
}

model PremiumRemedy {
  id               String   @id @default(uuid())
  numberCombination String
  
  remedyType       String    // 'GEMSTONE', 'MANTRA', 'PRACTICE'
  remedyName       String
  description      String
  
  gemstoneName     String?
  mantraText       String?
  practiceDuration String?
  
  @@map("premium_remedies")
}

// Public endpoints
numerology.calculate(input): CoreNumerologyResult
numerology.getById(id): NumerologyCalculation
compatibility.calculate(user1Id, user2Id): CompatibilityResult

// Protected endpoints
remedies.list(calculationId): PremiumRemedy[]
reports.generate(calculationId, type): NumerologyReport
subscriptions.upgrade(planType): Subscription

// Admin endpoints
meanings.create(content): PremiumNumberMeaning
remedies.create(remedy): PremiumRemedy

# Install dependencies
pnpm install

# Start PostgreSQL
docker compose up -d

# Setup database
pnpm --filter api db:push

# Run application
pnpm dev

# Access:
# Web: http://localhost:3000
# API: http://localhost:4000/trpc

Internet
   ↓
Next.js Frontend (Port 3000)
   ↓
tRPC Router
   ↓
Fastify API Server (Port 4000)
   ↓
PostgreSQL Database