Idf Date Converter

{
  "schemaVersion": "1.0",
  "skill": "idf-date-converter",
  "generated_at": "2026-05-20T00:00:00Z",
  "claims": [
    {
      "claim_id": "hebrew-year-5786-not-leap",
      "claim": "The Hebrew year 5786 (2025-2026 Gregorian) is a regular year in the 19-year Metonic cycle, NOT a leap year, so it has only one Adar (no Adar I / Adar II).",
      "source_url": "https://en.wikipedia.org/wiki/Hebrew_calendar",
      "raw_snippet": "19-year cycle",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "hebrew-2026-holiday-dates",
      "claim": "Hebrew calendar 2026 (Gregorian) holiday dates verified against pyluach: Tu B'Shvat (15 Shvat) = Feb 2; Ta'anit Esther (13 Adar) = Mar 2; Purim (14 Adar) = Mar 3; Shushan Purim (15 Adar) = Mar 4; Pesach (15-21 Nisan) = Apr 2-8; Yom HaShoah (27 Nisan) = Apr 14; Yom HaZikaron (4 Iyar) = Apr 21; Yom HaAtzmaut (5 Iyar) = Apr 22; Lag BaOmer (18 Iyar) = May 5; Shavuot (6 Sivan) = May 22; 17 Tammuz = Jul 3; Tisha B'Av (9 Av) = Jul 24; Rosh Hashana (1-2 Tishrei 5787) = Sep 12-13; Yom Kippur (10 Tishrei) = Sep 21; Sukkot (15-21 Tishrei) = Sep 26 - Oct 2; Simchat Torah (22 Tishrei in Israel) = Oct 3; Chanukah (25 Kislev - 2 Tevet 5787) = Dec 5-12, 2026 (first candle evening Dec 4); 10 Tevet = Dec 20, 2026.",
      "source_url": "https://www.hebcal.com/holidays/2026",
      "raw_snippet": "Pesach Shavuot Purim",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "pyluach-library",
      "claim": "pyluach is an open-source Python library for Hebrew calendar / Jewish date conversion, used as the canonical reference implementation for date arithmetic in this skill.",
      "source_url": "https://github.com/simlist/pyluach",
      "raw_snippet": "pyluach",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md", "scripts/convert_date.py"]
    },
    {
      "claim_id": "hebcal-com",
      "claim": "hebcal.com is the canonical web-based Hebrew calendar reference and provides authoritative holiday tables, dual-date conversions, and a developer API at hebcal.com/home/developer-apis.",
      "source_url": "https://www.hebcal.com",
      "raw_snippet": "hebcal https://www.hebcal.com/home/developer-apis",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "yom-haatzmaut-displacement-2026",
      "claim": "5 Iyar 5786 falls on a Wednesday (April 22, 2026), so neither Yom HaZikaron nor Yom HaAtzmaut is displaced in 2026 under the Knesset's displacement rules.",
      "source_url": "https://www.hebcal.com/holidays/yom-haatzmaut",
      "raw_snippet": "Yom HaAtzmaut",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "knesset-displacement-laws",
      "claim": "The Israeli Knesset legislated displacement rules for Yom HaZikaron and Yom HaAtzmaut to avoid Shabbat desecration: if 5 Iyar falls on Friday or Saturday, both are moved earlier; if it falls on Monday, Yom HaAtzmaut moves later to Tuesday; if it falls on Sunday, Tuesday, or Wednesday, no displacement applies.",
      "source_url": "https://en.wikipedia.org/wiki/Yom_Ha%27atzmaut",
      "raw_snippet": "displacement",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "gematria-numerals",
      "claim": "Hebrew gematria uses letter-number mapping (alef=1, bet=2, ..., yod=10, kaf=20, ..., kuf=100, ..., tav=400) with two important exceptions: 15 is written tet-vav (not yod-heh) and 16 is tet-zayin (not yod-vav), to avoid spelling Divine names.",
      "source_url": "https://en.wikipedia.org/wiki/Hebrew_numerals",
      "raw_snippet": "gematria",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "pesach-israel-7-days",
      "claim": "Pesach is celebrated for 7 days in Israel (15-21 Nisan) and 8 days in the diaspora (15-22 Nisan, with an additional last day yom tov sheni).",
      "source_url": "https://en.wikipedia.org/wiki/Passover",
      "raw_snippet": "Passover",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md"]
    },
    {
      "claim_id": "israeli-business-week",
      "claim": "The Israeli business week runs Sunday through Thursday; Friday is a half-day in many sectors and Saturday (Shabbat) is the non-working day.",
      "source_url": "https://en.wikipedia.org/wiki/Workweek_and_weekend",
      "raw_snippet": "Israel",
      "fetched_at": "2026-05-20T00:00:00Z",
      "appears_in": ["SKILL.md", "SKILL_HE.md", "scripts/convert_date.py"]
    }
  ]
}

{
  "author": "skills-il",
  "version": "2.0.0",
  "category": "developer-tools",
  "tags": {
    "he": [
      "לוח-שנה",
      "תאריך-עברי",
      "חגים",
      "שבת",
      "המרה",
      "ישראל"
    ],
    "en": [
      "calendar",
      "hebrew-date",
      "holidays",
      "shabbat",
      "conversion",
      "israel"
    ]
  },
  "display_name": {
    "he": "ממיר תאריכים עברי-לועזי",
    "en": "IDF Date Converter"
  },
  "display_description": {
    "he": "ממירים בין תאריכים עבריים ולועזיים בכל הפורמטים.",
    "en": "Convert between Hebrew (Jewish) calendar and Gregorian dates, look up Israeli holidays, format dual dates for Israeli documents, and calculate Israeli business days. Use when user asks about Hebrew dates, \"luach ivri\", Jewish calendar, Israeli holidays, \"chagim\", Shabbat times, or needs dual-date formatting for Israeli forms. Do NOT use for Islamic Hijri calendar or non-Israeli holiday calendars."
  },
  "supported_agents": [
    "claude-code",
    "cursor",
    "github-copilot",
    "windsurf",
    "opencode",
    "codex",
    "openclaw",
    "antigravity",
    "gemini-cli"
  ]
}

#!/usr/bin/env python3
"""Hebrew-Gregorian Date Converter for Israeli applications.

Converts between Hebrew (Jewish) calendar and Gregorian dates, looks up
Israeli holidays, formats dual dates for Israeli documents, and calculates
Israeli business days.

Requirements:
    pip install pyluach

Usage:
    python convert_date.py today
    python convert_date.py to-hebrew 2026-02-24
    python convert_date.py to-gregorian 5786 6 26
    python convert_date.py holidays 2026
    python convert_date.py business-days 2026-03-01 2026-03-31
"""

import argparse
import sys
from datetime import date, timedelta

try:
    from pyluach import dates, hebrewcal
    HAS_PYLUACH = True
except ImportError:
    HAS_PYLUACH = False


# Hebrew month names for fallback display
HEBREW_MONTHS = {
    1: "Nisan", 2: "Iyar", 3: "Sivan", 4: "Tammuz", 5: "Av", 6: "Elul",
    7: "Tishrei", 8: "Cheshvan", 9: "Kislev", 10: "Tevet", 11: "Shevat",
    12: "Adar", 13: "Adar II"
}

# Israeli holidays (Hebrew month, day) -> holiday name
# Month numbering: 7=Tishrei (start of civil year), 1=Nisan (start of religious year)
ISRAELI_HOLIDAYS = {
    (7, 1): "Rosh Hashana (Day 1)",
    (7, 2): "Rosh Hashana (Day 2)",
    (7, 10): "Yom Kippur",
    (7, 15): "Sukkot (Day 1)",
    (7, 16): "Sukkot (Day 2)",
    (7, 17): "Sukkot (Chol HaMoed)",
    (7, 18): "Sukkot (Chol HaMoed)",
    (7, 19): "Sukkot (Chol HaMoed)",
    (7, 20): "Sukkot (Chol HaMoed)",
    (7, 21): "Hoshana Rabba",
    (7, 22): "Simchat Torah",
    (1, 15): "Pesach (Day 1)",
    (1, 16): "Pesach (Chol HaMoed)",
    (1, 17): "Pesach (Chol HaMoed)",
    (1, 18): "Pesach (Chol HaMoed)",
    (1, 19): "Pesach (Chol HaMoed)",
    (1, 20): "Pesach (Chol HaMoed)",
    (1, 21): "Pesach (Day 7)",
    (3, 6): "Shavuot",
    (1, 27): "Yom HaShoah",
    (2, 4): "Yom HaZikaron",
    (2, 5): "Yom HaAtzmaut",
}


def gregorian_to_hebrew(greg_date: date) -> dict:
    """Convert a Gregorian date to Hebrew date.

    Args:
        greg_date: Python date object

    Returns:
        Dictionary with Hebrew date components
    """
    if HAS_PYLUACH:
        gd = dates.GregorianDate(greg_date.year, greg_date.month, greg_date.day)
        hd = gd.to_heb()
        return {
            "year": hd.year,
            "month": hd.month,
            "day": hd.day,
            "month_name": hd.month_name(),
            "formatted": f"{hd.day} {hd.month_name()} {hd.year}",
        }
    else:
        print("WARNING: pyluach not installed. Install with: pip install pyluach",
              file=sys.stderr)
        return {
            "error": "pyluach not installed",
            "install": "pip install pyluach"
        }


def hebrew_to_gregorian(year: int, month: int, day: int) -> dict:
    """Convert a Hebrew date to Gregorian.

    Args:
        year: Hebrew year (e.g., 5786)
        month: Hebrew month (7=Tishrei, 1=Nisan, etc.)
        day: Day of month

    Returns:
        Dictionary with Gregorian date components
    """
    if HAS_PYLUACH:
        hd = dates.HebrewDate(year, month, day)
        gd = hd.to_greg()
        return {
            "year": gd.year,
            "month": gd.month,
            "day": gd.day,
            "formatted": f"{gd.year}-{gd.month:02d}-{gd.day:02d}",
            "display": f"{gd.day} {date(gd.year, gd.month, gd.day).strftime('%B')} {gd.year}",
        }
    else:
        print("WARNING: pyluach not installed. Install with: pip install pyluach",
              file=sys.stderr)
        return {"error": "pyluach not installed", "install": "pip install pyluach"}


def format_dual_date(greg_date: date) -> str:
    """Format a date as dual Gregorian/Hebrew for Israeli documents.

    Args:
        greg_date: Python date object

    Returns:
        Formatted dual date string
    """
    heb = gregorian_to_hebrew(greg_date)
    if "error" in heb:
        return f"{greg_date.strftime('%d %B %Y')} (Hebrew date unavailable - install pyluach)"

    greg_str = greg_date.strftime("%d %B %Y")
    heb_str = heb["formatted"]
    return f"{greg_str} / {heb_str}"


def is_shabbat(greg_date: date) -> bool:
    """Check if a date falls on Shabbat (Saturday).

    Args:
        greg_date: Python date object

    Returns:
        True if the date is Shabbat
    """
    return greg_date.weekday() == 5  # Saturday


def is_israeli_holiday(greg_date: date) -> tuple:
    """Check if a Gregorian date falls on an Israeli holiday.

    Args:
        greg_date: Python date object

    Returns:
        Tuple of (is_holiday: bool, holiday_name: str or None)
    """
    if not HAS_PYLUACH:
        return (False, None)

    hd = dates.GregorianDate(greg_date.year, greg_date.month, greg_date.day).to_heb()
    key = (hd.month, hd.day)
    if key in ISRAELI_HOLIDAYS:
        return (True, ISRAELI_HOLIDAYS[key])
    return (False, None)


def is_israeli_business_day(greg_date: date) -> bool:
    """Check if a date is an Israeli business day.

    Israeli business week: Sunday-Thursday (Friday half day, Saturday off)
    Also excludes national holidays.

    Args:
        greg_date: Python date object

    Returns:
        True if the date is a business day in Israel
    """
    # Saturday (5) and Friday (4) are not full business days
    if greg_date.weekday() == 5:  # Saturday
        return False

    holiday, _ = is_israeli_holiday(greg_date)
    if holiday:
        return False

    return True


def count_business_days(start_date: date, end_date: date) -> dict:
    """Count Israeli business days between two dates.

    Args:
        start_date: Start date (inclusive)
        end_date: End date (inclusive)

    Returns:
        Dictionary with count and details
    """
    total_days = 0
    business_days = 0
    holidays_in_range = []
    shabbatot = 0

    current = start_date
    while current <= end_date:
        total_days += 1
        if is_shabbat(current):
            shabbatot += 1
        else:
            is_hol, hol_name = is_israeli_holiday(current)
            if is_hol:
                holidays_in_range.append(
                    f"{current.strftime('%Y-%m-%d')} - {hol_name}"
                )
            else:
                business_days += 1
        current += timedelta(days=1)

    return {
        "start": start_date.isoformat(),
        "end": end_date.isoformat(),
        "total_days": total_days,
        "business_days": business_days,
        "shabbatot": shabbatot,
        "holidays": holidays_in_range,
    }


def get_holidays_for_year(greg_year: int) -> list:
    """Get approximate Gregorian dates for Israeli holidays in a given year.

    Args:
        greg_year: Gregorian year

    Returns:
        List of dictionaries with holiday info
    """
    if not HAS_PYLUACH:
        return [{"error": "pyluach not installed", "install": "pip install pyluach"}]

    holidays = []
    # Scan the entire Gregorian year day by day
    current = date(greg_year, 1, 1)
    end = date(greg_year, 12, 31)

    while current <= end:
        is_hol, hol_name = is_israeli_holiday(current)
        if is_hol:
            heb = gregorian_to_hebrew(current)
            holidays.append({
                "holiday": hol_name,
                "gregorian": current.isoformat(),
                "hebrew": heb.get("formatted", "N/A"),
                "day_of_week": current.strftime("%A"),
            })
        current += timedelta(days=1)

    return holidays


def main():
    parser = argparse.ArgumentParser(
        description="Hebrew-Gregorian Date Converter for Israeli Applications"
    )
    subparsers = parser.add_subparsers(dest="command", help="Command to execute")

    # Today command
    subparsers.add_parser("today", help="Show today's date in both calendars")

    # To Hebrew command
    to_heb = subparsers.add_parser("to-hebrew", help="Convert Gregorian to Hebrew")
    to_heb.add_argument("date", help="Gregorian date (YYYY-MM-DD)")

    # To Gregorian command
    to_greg = subparsers.add_parser("to-gregorian", help="Convert Hebrew to Gregorian")
    to_greg.add_argument("year", type=int, help="Hebrew year (e.g., 5786)")
    to_greg.add_argument("month", type=int, help="Hebrew month (7=Tishrei, 1=Nisan)")
    to_greg.add_argument("day", type=int, help="Day of month")

    # Holidays command
    holidays_parser = subparsers.add_parser("holidays",
                                             help="List Israeli holidays for a year")
    holidays_parser.add_argument("year", type=int, help="Gregorian year")

    # Business days command
    bdays = subparsers.add_parser("business-days",
                                   help="Count Israeli business days between dates")
    bdays.add_argument("start", help="Start date (YYYY-MM-DD)")
    bdays.add_argument("end", help="End date (YYYY-MM-DD)")

    # Dual date command
    dual = subparsers.add_parser("dual", help="Format dual date for Israeli documents")
    dual.add_argument("date", help="Gregorian date (YYYY-MM-DD)")

    args = parser.parse_args()

    if args.command == "today":
        today = date.today()
        heb = gregorian_to_hebrew(today)
        print(f"Gregorian: {today.strftime('%A, %d %B %Y')}")
        if "error" not in heb:
            print(f"Hebrew:    {heb['formatted']}")
            print(f"\nDual format: {format_dual_date(today)}")
        else:
            print(f"Hebrew:    Install pyluach: {heb['install']}")

        is_bday = is_israeli_business_day(today)
        print(f"\nIsraeli business day: {'Yes' if is_bday else 'No'}")
        if is_shabbat(today):
            print("  (Shabbat)")
        is_hol, hol_name = is_israeli_holiday(today)
        if is_hol:
            print(f"  (Holiday: {hol_name})")

    elif args.command == "to-hebrew":
        parts = args.date.split('-')
        greg_date = date(int(parts[0]), int(parts[1]), int(parts[2]))
        heb = gregorian_to_hebrew(greg_date)
        if "error" not in heb:
            print(f"Gregorian: {greg_date.strftime('%d %B %Y')}")
            print(f"Hebrew:    {heb['formatted']}")
            print(f"\nDual format: {format_dual_date(greg_date)}")
        else:
            print(f"Error: {heb['error']}")
            print(f"Install: {heb['install']}")

    elif args.command == "to-gregorian":
        greg = hebrew_to_gregorian(args.year, args.month, args.day)
        if "error" not in greg:
            month_name = HEBREW_MONTHS.get(args.month, f"Month {args.month}")
            print(f"Hebrew:    {args.day} {month_name} {args.year}")
            print(f"Gregorian: {greg['display']}")
            print(f"ISO:       {greg['formatted']}")
        else:
            print(f"Error: {greg['error']}")
            print(f"Install: {greg['install']}")

    elif args.command == "holidays":
        holidays = get_holidays_for_year(args.year)
        if holidays and "error" in holidays[0]:
            print(f"Error: {holidays[0]['error']}")
            print(f"Install: {holidays[0]['install']}")
        else:
            print(f"Israeli Holidays in {args.year}:")
            print(f"{'Holiday':<30} {'Gregorian':<14} {'Hebrew':<25} {'Day':<10}")
            print("-" * 80)
            for h in holidays:
                print(f"{h['holiday']:<30} {h['gregorian']:<14} "
                      f"{h['hebrew']:<25} {h['day_of_week']:<10}")

    elif args.command == "business-days":
        start_parts = args.start.split('-')
        end_parts = args.end.split('-')
        start_date = date(int(start_parts[0]), int(start_parts[1]), int(start_parts[2]))
        end_date = date(int(end_parts[0]), int(end_parts[1]), int(end_parts[2]))

        result = count_business_days(start_date, end_date)
        print(f"Period: {result['start']} to {result['end']}")
        print(f"Total days:    {result['total_days']}")
        print(f"Business days: {result['business_days']}")
        print(f"Shabbatot:     {result['shabbatot']}")
        if result['holidays']:
            print(f"Holidays ({len(result['holidays'])}):")
            for h in result['holidays']:
                print(f"  {h}")

    elif args.command == "dual":
        parts = args.date.split('-')
        greg_date = date(int(parts[0]), int(parts[1]), int(parts[2]))
        print(format_dual_date(greg_date))

    else:
        parser.print_help()


if __name__ == "__main__":
    main()