ramadan-cal 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# 🌙 ramadan-cal
+
+A beautiful terminal Ramadan calendar with prayer times, daily progress, and Hijri date tracking.
+
+## Install
+
+```bash
+npm install -g ramadan-cal
+```
+
+## Usage
+
+```bash
+ramadan              # Full display: prayer times + calendar
+ramadan times        # Prayer times only
+ramadan calendar     # Calendar only
+ramadan check        # Check prayer times for any city
+ramadan eid 2026-03-19  # Set the Eid date when announced
+ramadan reset        # Clear config and start fresh
+```
+
+## Setup
+
+First run auto-detects your location and asks one question — when the moon was sighted. That's it.
+
+Prayer times are calculated offline using the [adhan](https://github.com/batoulapps/adhan-js) library. No API calls needed after setup.
+
+## Claude Code
+
+During installation you'll be asked if you want to set up Claude Code integration. If enabled, type `ramadan` inside any Claude Code session to see your calendar — zero tokens used.
+
+If you skipped during install, run `npm rebuild ramadan-cal` to set it up later.
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { getConfig, resetConfig, setEidDate } from '../src/config.js';
+import { render } from '../src/display.js';
+import { checkLocation } from '../src/check-location.js';
+
+const args = process.argv.slice(2);
+const command = args[0]?.toLowerCase();
+
+async function main() {
+  // Handle reset
+  if (command === 'reset') {
+    resetConfig();
+    console.log('\n✅ Config cleared. Run `ramadan` to set up again.\n');
+    process.exit(0);
+  }
+
+  // Handle eid date setting
+  if (command === 'eid') {
+    const dateStr = args[1];
+    if (!dateStr || !/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+      console.log('\n❌ Please provide a date: ramadan eid YYYY-MM-DD\n');
+      process.exit(1);
+    }
+    setEidDate(dateStr);
+    console.log(`\n✅ Eid date set to ${dateStr}\n`);
+    process.exit(0);
+  }
+
+  // Handle location check
+  if (command === 'check') {
+    await checkLocation();
+    process.exit(0);
+  }
+
+  // Get or create config (will prompt on first run)
+  const config = await getConfig();
+
+  // Determine which view to show
+  const view = command === 'times' ? 'times' : command === 'calendar' ? 'calendar' : 'full';
+
+  render(config, view);
+}
+
+main().catch((err) => {
+  console.error('\n❌ Something went wrong:', err.message, '\n');
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ramadan-cal",
+  "version": "1.0.0",
+  "description": "🌙 A beautiful terminal Ramadan calendar with prayer times, daily progress, and Hijri date",
+  "type": "module",
+  "bin": {
+    "ramadan": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "link": "npm link",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "ramadan",
+    "islam",
+    "prayer-times",
+    "hijri",
+    "calendar",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "src",
+    "scripts",
+    "README.md"
+  ],
+  "dependencies": {
+    "adhan": "^4.4.3",
+    "chalk": "^5.3.0",
+    "conf": "^12.0.0",
+    "prompts": "^2.4.2"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script — runs automatically after npm install.
+ * Interactively sets up Claude Code integration if the user wants it.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { createInterface } from 'readline';
+
+const home = homedir();
+const claudeDir = join(home, '.claude');
+const claudeMd = join(claudeDir, 'CLAUDE.md');
+
+const MARKER = '<!-- ramadan-cal -->';
+const CLAUDE_ENTRY = `
+${MARKER}
+## Ramadan CLI
+When the user types "ramadan" or any command starting with "ramadan" (like "ramadan times", "ramadan reset", "ramadan test mid", "ramadan eid"), run it as a shell command using bash. Do not answer from general knowledge.
+${MARKER}
+`;
+
+function isClaudeInstalled() {
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isAlreadyConfigured() {
+  if (!existsSync(claudeMd)) return false;
+  const content = readFileSync(claudeMd, 'utf-8');
+  return content.includes(MARKER);
+}
+
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+async function main() {
+  console.log('');
+  console.log('   🌙 Ramadan CLI installed successfully!');
+  console.log('   Run `ramadan` to get started.');
+  console.log('');
+
+  // Check if already configured
+  if (isAlreadyConfigured()) {
+    console.log('   ✓ Claude Code integration already configured');
+    return;
+  }
+
+  // Check if Claude is installed
+  const claudeInstalled = isClaudeInstalled();
+
+  if (!claudeInstalled) {
+    // Not interactive — just check if they might want it later
+    const answer = await ask('   Do you use Claude Code? (y/n) ');
+
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('   ✓ Skipping Claude Code setup. You\'re all set!\n');
+      return;
+    }
+
+    // They use Claude Code but it's not on PATH
+    console.log('   ℹ Claude Code wasn\'t detected on your PATH.');
+
+    const proceed = await ask('   Set up the integration anyway? (y/n) ');
+
+    if (proceed !== 'y' && proceed !== 'yes') {
+      console.log('   ✓ No worries — run `npm rebuild ramadan-cal` anytime to set it up later.\n');
+      return;
+    }
+  } else {
+    console.log('   ✓ Claude Code detected');
+
+    const answer = await ask('   Set up Claude Code integration? Type `ramadan` in Claude Code sessions. (y/n) ');
+
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('   ✓ Skipped. Run `npm rebuild ramadan-cal` anytime to set it up later.\n');
+      return;
+    }
+  }
+
+  // Create .claude directory if needed
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+    console.log('   ✓ Created ~/.claude/');
+  }
+
+  // Write or append to CLAUDE.md
+  if (existsSync(claudeMd)) {
+    appendFileSync(claudeMd, CLAUDE_ENTRY);
+    console.log('   ✓ Added ramadan command to ~/.claude/CLAUDE.md');
+  } else {
+    writeFileSync(claudeMd, CLAUDE_ENTRY.trimStart());
+    console.log('   ✓ Created ~/.claude/CLAUDE.md');
+  }
+
+  console.log('   ✓ Done! Type "ramadan" inside Claude Code and it\'ll just work.\n');
+}
+
+// Handle non-interactive environments (CI, piped input)
+if (!process.stdin.isTTY) {
+  console.log('');
+  console.log('   🌙 Ramadan CLI installed successfully!');
+  console.log('   Run `ramadan` to get started.');
+  console.log('   Run `npm rebuild ramadan-cal` in an interactive terminal to set up Claude Code.\n');
+  process.exit(0);
+}
+
+main().catch(() => {
+  // Non-fatal — never block the install
+  process.exit(0);
+});

package/src/calendar.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+
+export function renderCalendar(startDate, currentDay, totalDays) {
+  const lines = [];
+
+  // Header
+  lines.push(chalk.dim(' Su  Mo  Tu  We  Th  Fr  Sa'));
+
+  // What day of the week does Ramadan start? (0 = Sunday)
+  const startDow = startDate.getDay();
+
+  // Build cells
+  const cells = [];
+
+  // Leading empty cells
+  for (let i = 0; i < startDow; i++) {
+    cells.push('    ');
+  }
+
+  // Day cells
+  for (let day = 1; day <= totalDays; day++) {
+    if (day < currentDay) {
+      // Past days — crossed out
+      cells.push(chalk.dim.strikethrough(pad(day)));
+    } else if (day === currentDay) {
+      // Today — highlighted
+      cells.push(chalk.bold.green(`[${day.toString().padStart(2)}]`));
+    } else {
+      // Future days
+      cells.push(pad(day));
+    }
+  }
+
+  // Render rows of 7
+  for (let i = 0; i < cells.length; i += 7) {
+    const row = cells.slice(i, i + 7);
+    lines.push(row.join(''));
+  }
+
+  return lines.join('\n');
+}
+
+function pad(day) {
+  return ` ${day.toString().padStart(2)} `;
+}

package/src/check-location.js

@@ -0,0 +1,112 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { getPrayerTimes } from './prayer.js';
+
+const TIMEZONE_METHODS = {
+  'america': 'NorthAmerica',
+  'europe': 'MuslimWorldLeague',
+  'africa': 'Egyptian',
+  'asia/dubai': 'UmmAlQura',
+  'asia/riyadh': 'UmmAlQura',
+  'asia/karachi': 'Karachi',
+  'asia/kolkata': 'Karachi',
+  'asia/dhaka': 'Karachi',
+  'asia/singapore': 'Singapore',
+  'asia/kuala': 'Singapore',
+  'asia/jakarta': 'Singapore',
+  'asia/istanbul': 'Turkey',
+};
+
+function guessMethod(lat, lng) {
+  // Rough geographic guess
+  if (lng > -130 && lng < -30) return 'NorthAmerica';
+  if (lng > -15 && lng < 40 && lat > 35) return 'MuslimWorldLeague';
+  if (lng > -20 && lng < 55 && lat < 35 && lat > -35) return 'Egyptian';
+  if (lng > 35 && lng < 60 && lat > 10 && lat < 45) return 'UmmAlQura';
+  if (lng > 60 && lng < 100) return 'Karachi';
+  if (lng > 95 && lng < 145) return 'Singapore';
+  return 'MuslimWorldLeague';
+}
+
+async function geocode(query) {
+  try {
+    const encoded = encodeURIComponent(query);
+    const res = await fetch(
+      `https://nominatim.openstreetmap.org/search?q=${encoded}&format=json&limit=5`,
+      { headers: { 'User-Agent': 'ramadan-cal/1.0' }, signal: AbortSignal.timeout(8000) }
+    );
+    const data = await res.json();
+    return data.map((r) => ({
+      name: r.display_name.split(',').slice(0, 3).join(','),
+      lat: parseFloat(r.lat),
+      lng: parseFloat(r.lon),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function checkLocation() {
+  console.log('');
+  console.log(chalk.bold.cyan('🌍 Check Prayer Times'));
+  console.log(chalk.dim('Type any city or country to check prayer times.\n'));
+
+  while (true) {
+    const { query } = await prompts({
+      type: 'text',
+      name: 'query',
+      message: 'City or country (or "quit" to exit)',
+    });
+
+    if (!query || query.toLowerCase() === 'quit' || query.toLowerCase() === 'q') {
+      console.log(chalk.dim('\n👋 Done.\n'));
+      break;
+    }
+
+    console.log(chalk.dim(`\n   Searching for "${query}"...`));
+    const results = await geocode(query);
+
+    if (results.length === 0) {
+      console.log(chalk.red('   Could not find that location. Try again.\n'));
+      continue;
+    }
+
+    let selected;
+
+    if (results.length === 1) {
+      selected = results[0];
+      console.log(chalk.dim(`   Found: ${selected.name}`));
+    } else {
+      const { pick } = await prompts({
+        type: 'select',
+        name: 'pick',
+        message: 'Which location?',
+        choices: results.map((r, i) => ({ title: r.name, value: i })),
+      });
+
+      if (pick === undefined) continue;
+      selected = results[pick];
+    }
+
+    const method = guessMethod(selected.lat, selected.lng);
+    const config = {
+      latitude: selected.lat,
+      longitude: selected.lng,
+      method,
+    };
+
+    const times = getPrayerTimes(config);
+
+    console.log('');
+    console.log(chalk.bold(`   🕌 Prayer Times — ${selected.name.split(',')[0]}`));
+    console.log(chalk.dim(`   ${selected.lat.toFixed(4)}, ${selected.lng.toFixed(4)} · Method: ${method}`));
+    console.log('');
+    console.log(`   Fajr      ${chalk.white(times.fajr)}     Maghrib   ${chalk.white(times.maghrib)}`);
+    console.log(`   Sunrise   ${chalk.white(times.sunrise)}     Isha      ${chalk.white(times.isha)}`);
+    console.log(`   Dhuhr     ${chalk.white(times.dhuhr)}`);
+    console.log(`   Asr       ${chalk.white(times.asr)}`);
+    console.log('');
+    console.log(`   🍽️  Suhoor ends: ${chalk.bold.yellow(times.suhoorEnds)} · Iftar: ${chalk.bold.green(times.iftar)}`);
+    console.log('');
+  }
+}

package/src/config.js

@@ -0,0 +1,261 @@
+import Conf from 'conf';
+import prompts from 'prompts';
+import chalk from 'chalk';
+
+const store = new Conf({
+  projectName: 'ramadan-cal',
+  schema: {
+    city: { type: 'string' },
+    country: { type: 'string' },
+    ramadanStartDate: { type: 'string' },
+    eidDate: { type: 'string', default: '' },
+    method: { type: 'string', default: 'NorthAmerica' },
+    latitude: { type: 'number' },
+    longitude: { type: 'number' },
+    timezone: { type: 'string', default: '' },
+  },
+});
+
+const CALCULATION_METHODS = {
+  'North America': 'NorthAmerica',
+  'Europe': 'MuslimWorldLeague',
+  'Middle East': 'UmmAlQura',
+  'Egypt / Africa': 'Egyptian',
+  'South Asia': 'Karachi',
+  'Southeast Asia': 'Singapore',
+  'Turkey': 'Turkey',
+};
+
+function guessMethodFromTimezone(tz) {
+  if (!tz) return 'MuslimWorldLeague';
+  const t = tz.toLowerCase();
+  if (t.includes('america')) return 'NorthAmerica';
+  if (t.includes('europe') || t.includes('london')) return 'MuslimWorldLeague';
+  if (t.includes('asia/dubai') || t.includes('asia/riyadh') || t.includes('asia/qatar') || t.includes('asia/kuwait')) return 'UmmAlQura';
+  if (t.includes('africa/cairo') || t.includes('africa')) return 'Egyptian';
+  if (t.includes('asia/karachi') || t.includes('asia/dhaka') || t.includes('asia/kolkata')) return 'Karachi';
+  if (t.includes('asia/singapore') || t.includes('asia/kuala') || t.includes('asia/jakarta')) return 'Singapore';
+  if (t.includes('istanbul') || t.includes('turkey')) return 'Turkey';
+  return 'MuslimWorldLeague';
+}
+
+async function detectLocation() {
+  try {
+    const res = await fetch('https://ipapi.co/json/', {
+      headers: { 'User-Agent': 'ramadan-cal/1.0' },
+      signal: AbortSignal.timeout(5000),
+    });
+    const data = await res.json();
+    if (data.latitude && data.longitude) {
+      return {
+        city: data.city || 'Unknown',
+        country: data.country_name || data.country || 'Unknown',
+        latitude: data.latitude,
+        longitude: data.longitude,
+        timezone: data.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      };
+    }
+  } catch {
+    // Fall through
+  }
+  return null;
+}
+
+function getRamadanStartOptions() {
+  // Ramadan 2026 is expected around Feb 17-18
+  // Provide a few date options based on likely moon sighting dates
+  const year = new Date().getFullYear();
+  const candidates = [];
+
+  // Generate options for a reasonable window
+  // For 2026: ~Feb 17-18, for 2025: ~Feb 28 - Mar 1
+  if (year === 2025) {
+    candidates.push(
+      { title: 'Friday 28th February 2025', value: '2025-02-28' },
+      { title: 'Saturday 1st March 2025', value: '2025-03-01' },
+    );
+  } else if (year === 2026) {
+    candidates.push(
+      { title: 'Tuesday 17th February 2026', value: '2026-02-17' },
+      { title: 'Wednesday 18th February 2026', value: '2026-02-18' },
+    );
+  } else if (year === 2027) {
+    candidates.push(
+      { title: 'Saturday 6th February 2027', value: '2027-02-06' },
+      { title: 'Sunday 7th February 2027', value: '2027-02-07' },
+    );
+  } else {
+    // Fallback: ask for manual input
+    return null;
+  }
+
+  candidates.push({ title: 'Other (enter manually)', value: 'manual' });
+  return candidates;
+}
+
+export async function getConfig() {
+  if (store.get('city') && store.get('ramadanStartDate')) {
+    return store.store;
+  }
+
+  console.log('\n🌙 Welcome to Ramadan CLI\n');
+
+  // Auto-detect location
+  console.log('📍 Detecting your location...');
+  const location = await detectLocation();
+
+  let city, country, latitude, longitude, timezone;
+
+  if (location) {
+    console.log(`   Found: ${location.city}, ${location.country}\n`);
+
+    const confirm = await prompts({
+      type: 'confirm',
+      name: 'correct',
+      message: `Is ${location.city}, ${location.country} correct?`,
+      initial: true,
+    });
+
+    if (confirm.correct) {
+      city = location.city;
+      country = location.country;
+      latitude = location.latitude;
+      longitude = location.longitude;
+      timezone = location.timezone;
+    }
+  } else {
+    console.log('   Could not detect automatically.\n');
+  }
+
+  // Manual location if auto-detect failed or was rejected
+  if (!city) {
+    const manual = await prompts([
+      {
+        type: 'text',
+        name: 'city',
+        message: 'What city are you in?',
+        validate: (v) => (v.length > 0 ? true : 'Please enter a city'),
+      },
+      {
+        type: 'text',
+        name: 'country',
+        message: 'What country?',
+        validate: (v) => (v.length > 0 ? true : 'Please enter a country'),
+      },
+    ]);
+
+    if (!manual.city) {
+      console.log('\n👋 Setup cancelled.\n');
+      process.exit(0);
+    }
+
+    city = manual.city;
+    country = manual.country;
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+    // Geocode
+    console.log('\n📍 Finding coordinates...');
+    const coords = await geocodeCity(city, country);
+    if (coords) {
+      latitude = coords.lat;
+      longitude = coords.lng;
+      console.log(`   Found: (${latitude.toFixed(2)}, ${longitude.toFixed(2)})`);
+    } else {
+      console.log('   Could not find coordinates.');
+      const coordInput = await prompts([
+        { type: 'number', name: 'latitude', message: 'Enter latitude:', float: true },
+        { type: 'number', name: 'longitude', message: 'Enter longitude:', float: true },
+      ]);
+      latitude = coordInput.latitude;
+      longitude = coordInput.longitude;
+    }
+  }
+
+  // Moon sighting date — the only real question
+  console.log('');
+  const startOptions = getRamadanStartOptions();
+  let ramadanStartDate;
+
+  if (startOptions) {
+    const response = await prompts({
+      type: 'select',
+      name: 'startDate',
+      message: 'When was the moon sighted for Ramadan?',
+      choices: startOptions,
+    });
+
+    if (response.startDate === 'manual') {
+      const manual = await prompts({
+        type: 'text',
+        name: 'date',
+        message: 'Enter the date (YYYY-MM-DD):',
+        validate: (v) => (/^\d{4}-\d{2}-\d{2}$/.test(v) ? true : 'Use format YYYY-MM-DD'),
+      });
+      ramadanStartDate = manual.date;
+    } else {
+      ramadanStartDate = response.startDate;
+    }
+  } else {
+    const manual = await prompts({
+      type: 'text',
+      name: 'date',
+      message: 'When did Ramadan start? (YYYY-MM-DD)',
+      validate: (v) => (/^\d{4}-\d{2}-\d{2}$/.test(v) ? true : 'Use format YYYY-MM-DD'),
+    });
+    ramadanStartDate = manual.date;
+  }
+
+  if (!ramadanStartDate) {
+    console.log('\n👋 Setup cancelled.\n');
+    process.exit(0);
+  }
+
+  // Eid = 30 days after start
+  const startD = new Date(ramadanStartDate + 'T00:00:00');
+  const eidD = new Date(startD.getTime() + 30 * 86400000);
+  const eidDate = eidD.toISOString().split('T')[0];
+
+  // Auto-detect calculation method from timezone
+  const method = guessMethodFromTimezone(timezone);
+
+  // Save everything
+  store.set('city', city);
+  store.set('country', country);
+  store.set('latitude', latitude);
+  store.set('longitude', longitude);
+  store.set('timezone', timezone || '');
+  store.set('method', method);
+  store.set('ramadanStartDate', ramadanStartDate);
+  store.set('eidDate', eidDate);
+
+  console.log(`\n✅ All set! Eid estimated: ${eidDate}`);
+  console.log(`   Prayer method: ${Object.keys(CALCULATION_METHODS).find(k => CALCULATION_METHODS[k] === method) || method}`);
+  console.log(`   Run ${chalk.dim('ramadan eid YYYY-MM-DD')} to update Eid when announced.\n`);
+
+  return store.store;
+}
+
+async function geocodeCity(city, country) {
+  try {
+    const query = encodeURIComponent(`${city}, ${country}`);
+    const res = await fetch(`https://nominatim.openstreetmap.org/search?q=${query}&format=json&limit=1`, {
+      headers: { 'User-Agent': 'ramadan-cal/1.0' },
+      signal: AbortSignal.timeout(5000),
+    });
+    const data = await res.json();
+    if (data.length > 0) {
+      return { lat: parseFloat(data[0].lat), lng: parseFloat(data[0].lon) };
+    }
+  } catch {
+    // Fall through
+  }
+  return null;
+}
+
+export function resetConfig() {
+  store.clear();
+}
+
+export function setEidDate(dateStr) {
+  store.set('eidDate', dateStr);
+}

package/src/display.js

@@ -0,0 +1,117 @@
+import chalk from 'chalk';
+import { getPrayerTimes } from './prayer.js';
+import { renderCalendar } from './calendar.js';
+
+const DIVIDER = chalk.dim('━'.repeat(38));
+
+function getHijriYear(startDate) {
+  // Known anchor: Ramadan 2025 starts ~Feb/Mar 2025 = 1446 AH
+  // Ramadan 2026 = 1447, 2027 = 1448, etc.
+  const year = startDate.getFullYear();
+  if (year <= 2025) return 1446;
+  return 1446 + (year - 2025);
+}
+
+function daysBetween(a, b) {
+  const msPerDay = 86400000;
+  const aStart = new Date(a.getFullYear(), a.getMonth(), a.getDate());
+  const bStart = new Date(b.getFullYear(), b.getMonth(), b.getDate());
+  return Math.round((bStart - aStart) / msPerDay);
+}
+
+function formatDate(date) {
+  return date.toLocaleDateString('en-GB', {
+    weekday: 'long',
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+  });
+}
+
+export function render(config, view = 'full') {
+  const start = new Date(config.ramadanStartDate + 'T00:00:00');
+  const today = new Date();
+  const hijriYear = getHijriYear(start);
+
+  const endDate = config.eidDate
+    ? new Date(config.eidDate + 'T00:00:00')
+    : new Date(start.getTime() + 30 * 86400000);
+
+  const totalDays = daysBetween(start, endDate);
+  const currentDay = daysBetween(start, today) + 1;
+  const daysRemaining = totalDays - currentDay;
+
+  const output = [];
+
+  // ── STATE A: Before Ramadan ──
+  if (currentDay < 1) {
+    const daysUntil = Math.abs(currentDay) + 1;
+    output.push('');
+    output.push(chalk.bold.cyan(`🌙 Ramadan ${hijriYear} has not started yet`));
+    output.push('');
+    output.push(`📅 Starts: ${chalk.white(formatDate(start))}`);
+    output.push(`⏳ ${chalk.bold.yellow(daysUntil)} days to go`);
+    output.push('');
+    output.push(chalk.dim('May Allah allow us to reach Ramadan 🤲'));
+    output.push('');
+    console.log(output.join('\n'));
+    return;
+  }
+
+  // ── STATE C: After Ramadan ──
+  if (currentDay > totalDays) {
+    output.push('');
+    output.push(chalk.bold.cyan(`🌙 Ramadan ${hijriYear} has ended`));
+    output.push('');
+    output.push(chalk.bold.yellow('🎉 Eid Mubarak!'));
+    output.push(`📅 Ramadan was ${formatDate(start)} — ${formatDate(endDate)}`);
+    output.push(`✅ ${totalDays} days completed`);
+    output.push('');
+    output.push(chalk.dim('Taqabbal Allahu minna wa minkum 🤲'));
+    output.push('');
+    console.log(output.join('\n'));
+    return;
+  }
+
+  // ── STATE B: During Ramadan ──
+  const times = getPrayerTimes(config, today);
+
+  // Header
+  output.push('');
+  output.push(chalk.bold.cyan(`🌙 Ramadan ${hijriYear}`));
+  output.push(DIVIDER);
+
+  // Progress
+  output.push(`📅 ${chalk.white(`${currentDay} Ramadan ${hijriYear}`)} — Day ${chalk.bold(currentDay)} of ${totalDays}`);
+  output.push(`⏳ ${chalk.bold.yellow(daysRemaining)} days remaining`);
+
+  // Prayer times
+  if (view === 'full' || view === 'times') {
+    output.push('');
+    output.push(`🕌 Prayer Times ${chalk.dim(`(${config.city})`)}`);
+    output.push(`   Fajr     ${chalk.white(times.fajr)}     Maghrib  ${chalk.white(times.maghrib)}`);
+    output.push(`   Sunrise  ${chalk.white(times.sunrise)}     Isha     ${chalk.white(times.isha)}`);
+    output.push(`   Dhuhr    ${chalk.white(times.dhuhr)}`);
+    output.push(`   Asr      ${chalk.white(times.asr)}`);
+    output.push('');
+    output.push(`🍽️  Suhoor ends: ${chalk.bold.yellow(times.suhoorEnds)} · Iftar: ${chalk.bold.green(times.iftar)}`);
+  }
+
+  // Calendar
+  if (view === 'full' || view === 'calendar') {
+    output.push('');
+    output.push(DIVIDER);
+    output.push(renderCalendar(start, currentDay, totalDays));
+    output.push(DIVIDER);
+  }
+
+  // Eid prompt
+  if (!config.eidDate && currentDay >= 28) {
+    output.push('');
+    output.push(chalk.yellow('⚠️  Day 28+ — Has Eid been announced?'));
+    output.push(chalk.dim('   Run: ramadan eid YYYY-MM-DD'));
+  }
+
+  output.push('');
+  console.log(output.join('\n'));
+}

package/src/prayer.js

@@ -0,0 +1,44 @@
+import adhan from 'adhan';
+
+const { PrayerTimes, CalculationMethod, Coordinates } = adhan;
+
+const METHOD_MAP = {
+  NorthAmerica: 'NorthAmerica',
+  MuslimWorldLeague: 'MuslimWorldLeague',
+  Egyptian: 'Egyptian',
+  UmmAlQura: 'UmmAlQura',
+  Karachi: 'Karachi',
+  MoonsightingCommittee: 'MoonsightingCommittee',
+  Singapore: 'Singapore',
+  Turkey: 'Turkey',
+  Tehran: 'Tehran',
+  Dubai: 'Dubai',
+  Kuwait: 'Kuwait',
+  Qatar: 'Qatar',
+};
+
+export function getPrayerTimes(config, date = new Date()) {
+  const coordinates = new Coordinates(config.latitude, config.longitude);
+  const methodName = METHOD_MAP[config.method] || 'NorthAmerica';
+  const params = CalculationMethod[methodName]();
+
+  const times = new PrayerTimes(coordinates, date, params);
+
+  const fmt = (d) =>
+    d.toLocaleTimeString('en-GB', {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    });
+
+  return {
+    fajr: fmt(times.fajr),
+    sunrise: fmt(times.sunrise),
+    dhuhr: fmt(times.dhuhr),
+    asr: fmt(times.asr),
+    maghrib: fmt(times.maghrib),
+    isha: fmt(times.isha),
+    suhoorEnds: fmt(times.fajr),
+    iftar: fmt(times.maghrib),
+  };
+}