kundali-chart-mcp 0.2.1

package/azure-function/kundali_bridge.py

@@ -0,0 +1,952 @@
+"""Python bridge used by the Node MCP server to call the bundled Kundali library.
+
+This is not an MCP server. It only receives one JSON payload on stdin, calls the
+standalone chart/geocoder services bundled in this package, and prints JSON on stdout.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import certifi
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+PYTHON_DIR = PACKAGE_DIR / "python"
+if str(PYTHON_DIR) not in sys.path:
+    sys.path.insert(0, str(PYTHON_DIR))
+
+os.environ.setdefault("SSL_CERT_FILE", certifi.where())
+os.environ.setdefault("REQUESTS_CA_BUNDLE", certifi.where())
+
+from kundali_lib.ephemeris import EphemerisService  # noqa: E402
+from kundali_lib.geocoder import GeocoderService  # noqa: E402
+from kundali_lib.vedic.arishta import get_arishta_yogas  # noqa: E402
+from kundali_lib.vedic.ashtakavarga import get_ashtakavarga  # noqa: E402
+from kundali_lib.vedic.avasthas import get_avasthas  # noqa: E402
+from kundali_lib.vedic.ayanamsa import (  # noqa: E402
+    list_ayanamsa_modes,
+    list_house_systems,
+)
+from kundali_lib.vedic.bhava_chalit import get_bhava_chalit  # noqa: E402
+from kundali_lib.vedic.char_dasha import (  # noqa: E402
+    get_char_dasha,
+    get_narayana_dasha,
+)
+from kundali_lib.vedic.chart import (
+    get_transit_positions as calculate_transit_positions,  # noqa: E402
+)
+from kundali_lib.vedic.chart_types import (  # noqa: E402
+    available_chart_types,
+    derive_chart,
+)
+from kundali_lib.vedic.compatibility import get_ashtakoot_milan  # noqa: E402
+from kundali_lib.vedic.dasha_extended import (  # noqa: E402
+    get_pratyantar_dasha,
+    get_yogini_dasha,
+)
+from kundali_lib.vedic.dasha_systems import (  # noqa: E402
+    get_ashtottari_dasha,
+    get_prana_dasha,
+    get_sookshma_dasha,
+)
+from kundali_lib.vedic.doshas import (  # noqa: E402
+    check_combustion,
+    check_graha_yuddha,
+    check_kaal_sarp_dosha,
+    check_mangal_dosha,
+    check_sade_sati,
+)
+from kundali_lib.vedic.gandanta import check_gandanta, get_gandanta_info  # noqa: E402
+from kundali_lib.vedic.gochara import get_gochara  # noqa: E402
+from kundali_lib.vedic.hora import get_hora_chart, get_planetary_hour  # noqa: E402
+from kundali_lib.vedic.jaimini import (  # noqa: E402
+    get_jaimini_aspects,
+    get_jaimini_karakas,
+    get_karakamsha,
+)
+from kundali_lib.vedic.kalachakra import get_kalachakra_dasha  # noqa: E402
+from kundali_lib.vedic.kartari import check_kartari_yoga  # noqa: E402
+from kundali_lib.vedic.kurmachakra import (  # noqa: E402
+    get_full_kurmachakra_chart,
+    get_kurmachakra,
+    get_travel_direction_score,
+)
+from kundali_lib.vedic.lunar_return import (  # noqa: E402
+    get_lunar_return,
+    get_prasna_chart,
+)
+from kundali_lib.vedic.muhurta import (  # noqa: E402
+    get_best_muhurta_in_range,
+    get_muhurta_score,
+)
+from kundali_lib.vedic.nabhasha import get_nabhasha_yogas  # noqa: E402
+from kundali_lib.vedic.nakshatra_details import (  # noqa: E402
+    get_nakshatra_compatibility,
+    get_nakshatra_details,
+    get_planet_nakshatra_analysis,
+)
+from kundali_lib.vedic.panchanga import get_panchanga  # noqa: E402
+from kundali_lib.vedic.shadbala import get_shadbala  # noqa: E402
+from kundali_lib.vedic.special_conditions import (  # noqa: E402
+    check_pushkara_navamsha,
+    check_vargottama,
+    get_dig_bala,
+)
+from kundali_lib.vedic.special_conditions import (
+    get_jaimini_karakas as sc_jaimini_karakas,
+)
+from kundali_lib.vedic.sudarshana import get_sudarshana_chakra  # noqa: E402
+from kundali_lib.vedic.tajaka import get_tajaka_analysis  # noqa: E402
+from kundali_lib.vedic.upagrahas import get_upagrahas  # noqa: E402
+from kundali_lib.vedic.varshaphal import get_varshaphal  # noqa: E402  # noqa: E402
+from kundali_lib.vedic.yogas import get_yogas  # noqa: E402
+from kundali_lib.vedicastro_bridge import (  # noqa: E402
+    get_full_chart as vc_full_chart,
+)
+from kundali_lib.vedicastro_bridge import (
+    get_planetary_aspects as vc_aspects,
+)
+from kundali_lib.vedicastro_bridge import (
+    get_significators as vc_significators,
+)
+from kundali_lib.vedicastro_bridge import (
+    get_vimshottari_dasha as vc_dasha,
+)
+from kundali_lib.vedicastro_bridge import (
+    list_vedicastro_options as vc_options,
+)
+
+ephemeris_service = EphemerisService()
+geocoder_service = GeocoderService()
+
+
+def parse_birth_datetime(date_of_birth: str, time_of_birth: str) -> datetime:
+    date_text = date_of_birth.strip()
+    time_text = time_of_birth.strip()
+
+    try:
+        if "T" in date_text:
+            date_part = datetime.fromisoformat(date_text).date()
+        else:
+            date_part = datetime.strptime(date_text, "%Y-%m-%d").date()
+    except ValueError as exc:
+        raise ValueError("date_of_birth must be in YYYY-MM-DD format") from exc
+
+    for fmt in ("%H:%M", "%H:%M:%S"):
+        try:
+            time_part = datetime.strptime(time_text, fmt).time()
+            return datetime.combine(date_part, time_part)
+        except ValueError:
+            continue
+
+    raise ValueError("time_of_birth must be in HH:MM or HH:MM:SS format")
+
+
+def resolve_location(
+    city: str,
+    latitude: float | None,
+    longitude: float | None,
+    timezone: str | None,
+) -> tuple[float, float, str]:
+    if (latitude is None) != (longitude is None):
+        raise ValueError("latitude and longitude must be provided together")
+
+    if latitude is not None and longitude is not None:
+        resolved_timezone = (
+            timezone or geocoder_service.get_timezone(latitude, longitude) or "UTC"
+        )
+        return latitude, longitude, resolved_timezone
+
+    city_info = geocoder_service.get_city_info(city)
+    if not city_info:
+        raise ValueError(
+            f"Could not find coordinates for city '{city}'. "
+            "Provide latitude, longitude, and optionally timezone to avoid geocoding."
+        )
+
+    return (
+        float(city_info["latitude"]),
+        float(city_info["longitude"]),
+        str(city_info.get("timezone") or "UTC"),
+    )
+
+
+def generate_kundali(payload: dict[str, Any]) -> dict[str, Any]:
+    birth_datetime = parse_birth_datetime(
+        payload["date_of_birth"], payload["time_of_birth"]
+    )
+    latitude, longitude, timezone = resolve_location(
+        city=payload["city"],
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+
+    base_chart = ephemeris_service.calculate_chart(
+        name=payload["name"],
+        birth_datetime=birth_datetime,
+        latitude=latitude,
+        longitude=longitude,
+        timezone=timezone,
+        ayanamsa_mode=payload.get("ayanamsa_mode"),
+        house_system=payload.get("house_system"),
+    )
+    return derive_chart(base_chart, payload.get("chart_type"))
+
+
+def list_available_chart_types(payload: dict[str, Any]) -> dict[str, Any]:
+    return available_chart_types()
+
+
+def list_ayanamsa_modes_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    return list_ayanamsa_modes()
+
+
+def list_house_systems_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    return list_house_systems()
+
+
+def search_birth_places(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    limit = int(payload.get("limit") or 8)
+    safe_limit = max(1, min(limit, 10))
+    return geocoder_service.search_cities(payload["query"], limit=safe_limit)
+
+
+def get_timezone_for_coordinates(payload: dict[str, Any]) -> dict[str, Any]:
+    latitude = float(payload["latitude"])
+    longitude = float(payload["longitude"])
+    timezone_name = geocoder_service.get_timezone(latitude, longitude) or "UTC"
+    return {
+        "latitude": latitude,
+        "longitude": longitude,
+        "timezone": timezone_name,
+    }
+
+
+def parse_transit_datetime(payload: dict[str, Any]) -> datetime:
+    dt_text = (payload.get("datetime_utc") or "").strip()
+    if not dt_text:
+        return datetime.now(timezone.utc)
+
+    try:
+        normalized = dt_text.replace("Z", "+00:00")
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError as exc:
+        raise ValueError(
+            "datetime_utc must be an ISO datetime, for example 2026-06-20T12:00:00Z"
+        ) from exc
+
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def get_transit_positions(payload: dict[str, Any]) -> dict[str, Any]:
+    dt_utc = parse_transit_datetime(payload)
+    return {
+        "datetime_utc": dt_utc.isoformat(),
+        "planetary_positions": calculate_transit_positions(dt_utc),
+    }
+
+
+def get_extended_chart(payload: dict[str, Any]) -> dict[str, Any]:
+    """Enhanced chart using vedicastro — includes SubLord/KP data."""
+    return vc_full_chart(payload)
+
+
+def get_vimshottari_dasha(payload: dict[str, Any]) -> dict[str, Any]:
+    """Vimshottari Dasha (mahadasha + antardasha) for a birth chart."""
+    return vc_dasha(payload)
+
+
+def get_planetary_aspects_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Planetary aspects (conjunction, sextile, square, trine, opposition, etc.)."""
+    return vc_aspects(payload)
+
+
+def get_significators(payload: dict[str, Any]) -> dict[str, Any]:
+    """Planet-wise and house-wise significators (KP system)."""
+    return vc_significators(payload)
+
+
+def list_extended_options(payload: dict[str, Any]) -> dict[str, Any]:
+    """List supported ayanamsas and house systems for extended (vedicastro) tools."""
+    return vc_options(payload)
+
+
+# ─── New comprehensive tools ───────────────────────────────────────────────
+
+
+def _require_base_chart(payload: dict[str, Any]) -> dict[str, Any]:
+    """Generate a base chart from payload (same flow as generate_kundali, lagna type only)."""
+    birth_datetime = parse_birth_datetime(
+        payload["date_of_birth"], payload["time_of_birth"]
+    )
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    return ephemeris_service.calculate_chart(
+        name=payload.get("name", "Chart"),
+        birth_datetime=birth_datetime,
+        latitude=lat,
+        longitude=lon,
+        timezone=tz,
+        ayanamsa_mode=payload.get("ayanamsa_mode"),
+        house_system=payload.get("house_system"),
+    )
+
+
+def get_panchanga_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Panchanga (Tithi, Vara, Nakshatra, Yoga, Karana) for a given datetime and location."""
+    import pytz
+    import swisseph as swe
+
+    # Parse datetime
+    dt_text = (payload.get("datetime") or "").strip()
+    tz_name = payload.get("timezone") or "UTC"
+    if dt_text:
+        dt = datetime.fromisoformat(dt_text.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = pytz.timezone(tz_name).localize(dt)
+    else:
+        dt = datetime.now(pytz.UTC)
+    # Convert to JD
+    utc_dt = dt.astimezone(pytz.UTC)
+    h = utc_dt.hour + utc_dt.minute / 60.0 + utc_dt.second / 3600.0
+    swe.set_ephe_path(None)
+    swe.set_sid_mode(swe.SIDM_LAHIRI)
+    from kundali_lib.vedic.ayanamsa import _SIDM_MAP
+
+    ayanamsa_key = (payload.get("ayanamsa_mode") or "lahiri").lower()
+    swe.set_sid_mode(_SIDM_MAP.get(ayanamsa_key, swe.SIDM_LAHIRI))
+    jd = swe.julday(utc_dt.year, utc_dt.month, utc_dt.day, h)
+    flags = swe.FLG_SWIEPH | swe.FLG_SPEED | swe.FLG_SIDEREAL
+    sun_xx, _ = swe.calc_ut(jd, swe.SUN, flags)
+    moon_xx, _ = swe.calc_ut(jd, swe.MOON, flags)
+    panchanga = get_panchanga(sun_xx[0], moon_xx[0], jd)
+    panchanga["datetime"] = utc_dt.isoformat()
+    panchanga["ayanamsa_mode"] = ayanamsa_key
+    return panchanga
+
+
+def get_doshas_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Check all major doshas for a birth chart: Mangal, Kaal Sarp, Sade Sati, Graha Yuddha, Combustion."""
+    base = _require_base_chart(payload)
+    planets = base["planetary_positions"]
+    asc = base["ascendant"]
+    moon_rashi = base["moon_sign"]
+    current_saturn_rashi = payload.get("current_saturn_rashi")
+    result = {
+        "mangal_dosha": check_mangal_dosha(planets, asc),
+        "kaal_sarp_dosha": check_kaal_sarp_dosha(planets),
+        "graha_yuddha": check_graha_yuddha(planets),
+        "combustion": check_combustion(planets),
+    }
+    if current_saturn_rashi:
+        result["sade_sati"] = check_sade_sati(moon_rashi, current_saturn_rashi)
+    else:
+        result["sade_sati"] = {
+            "note": "Provide current_saturn_rashi to check Sade Sati"
+        }
+    return result
+
+
+def get_yogas_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Identify all major Vedic Yogas in a birth chart."""
+    base = _require_base_chart(payload)
+    return get_yogas(base)
+
+
+def get_compatibility_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Ashtakoot Milan: 36-point Vedic marriage compatibility between two birth charts."""
+    # Expect payload to have chart1 and chart2 sub-dicts with birth details
+    chart1_payload = payload["chart1"]
+    chart2_payload = payload["chart2"]
+    chart1 = _require_base_chart_from(chart1_payload)
+    chart2 = _require_base_chart_from(chart2_payload)
+    return get_ashtakoot_milan(chart1, chart2)
+
+
+def _require_base_chart_from(p: dict[str, Any]) -> dict[str, Any]:
+    birth_datetime = parse_birth_datetime(p["date_of_birth"], p["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=p.get("city", ""),
+        latitude=p.get("latitude"),
+        longitude=p.get("longitude"),
+        timezone=p.get("timezone"),
+    )
+    return ephemeris_service.calculate_chart(
+        name=p.get("name", "Chart"),
+        birth_datetime=birth_datetime,
+        latitude=lat,
+        longitude=lon,
+        timezone=tz,
+    )
+
+
+def get_special_conditions_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Check Vargottama, Pushkara Navamsha, Dig Bala, and Jaimini Karakas."""
+    from kundali_lib.vedic.chart_types import DIVISIONAL_CHARTS, derive_chart
+
+    base = _require_base_chart(payload)
+    d9 = derive_chart(base, "d9")
+    d9_positions = d9.get("planetary_positions", [])
+    return {
+        "vargottama": check_vargottama(base["planetary_positions"], d9_positions),
+        "pushkara_navamsha": check_pushkara_navamsha(base["planetary_positions"]),
+        "dig_bala": get_dig_bala(base["planetary_positions"]),
+        "jaimini_karakas": sc_jaimini_karakas(base["planetary_positions"]),
+    }
+
+
+def get_pratyantar_dasha_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Pratyantar Dasha (3rd level: Mahadasha → Antardasha → Pratyantar) for a birth chart."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    import pytz
+
+    tz_obj = pytz.timezone(tz)
+    birth_dt_aware = tz_obj.localize(birth_dt)
+    return get_pratyantar_dasha(birth_dt_aware, moon["longitude"], moon["nakshatra"])
+
+
+def get_yogini_dasha_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Yogini Dasha (8-yogini 36-year cycle) for a birth chart."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    import pytz
+
+    tz_obj = pytz.timezone(tz)
+    birth_dt_aware = tz_obj.localize(birth_dt)
+    return get_yogini_dasha(birth_dt_aware, moon["longitude"], moon["nakshatra"])
+
+
+def get_varshaphal_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Varshaphal (Solar Return chart) for a given year of life."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, birth_tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    year_of_life = int(payload["year_of_life"])
+    query_lat = float(payload.get("query_latitude") or lat)
+    query_lon = float(payload.get("query_longitude") or lon)
+    query_tz = payload.get("query_timezone") or birth_tz
+    # get_varshaphal expects naive birth_dt and handles tz internally
+    return get_varshaphal(
+        birth_dt, lat, lon, birth_tz, year_of_life, query_lat, query_lon, query_tz
+    )
+
+
+def get_ashtakavarga_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Ashtakavarga (benefic point system) for a birth chart."""
+    base = _require_base_chart(payload)
+    return get_ashtakavarga(base)
+
+
+def get_shadbala_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Shadbala (six-fold planetary strength) for a birth chart."""
+    base = _require_base_chart(payload)
+    return get_shadbala(base)
+
+
+def get_jaimini_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get full Jaimini astrology analysis: Karakas, aspects, and Karakamsha."""
+    from kundali_lib.vedic.chart_types import derive_chart
+
+    base = _require_base_chart(payload)
+    d9 = derive_chart(base, "d9")
+    d9_positions = d9.get("planetary_positions", [])
+    return {
+        "karakas": get_jaimini_karakas(base["planetary_positions"]),
+        "aspects": get_jaimini_aspects(base),
+        "karakamsha": get_karakamsha(base["planetary_positions"], d9_positions),
+    }
+
+
+def get_muhurta_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Score a datetime for Muhurta (auspicious timing) for a given event type."""
+    panchanga = get_panchanga_tool(payload)
+    # Get planetary positions for the same moment (for aspects context)
+    import pytz
+    import swisseph as swe
+
+    swe.set_ephe_path(None)
+    swe.set_sid_mode(swe.SIDM_LAHIRI)
+    dt_text = (payload.get("datetime") or "").strip()
+    tz_name = payload.get("timezone") or "UTC"
+    if dt_text:
+        dt = datetime.fromisoformat(dt_text.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = pytz.timezone(tz_name).localize(dt)
+    else:
+        dt = datetime.now(pytz.UTC)
+    event_type = payload.get("event_type") or "general"
+    return get_muhurta_score(panchanga, [], event_type)
+
+
+def get_best_muhurta_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Find the best Muhurta windows in a date range for an event type."""
+    from datetime import datetime as _dt
+
+    import pytz
+
+    start_str = payload["start_datetime"]
+    end_str = payload["end_datetime"]
+    tz_name = payload.get("timezone") or "UTC"
+    lat = float(payload.get("latitude") or 28.6)
+    lon = float(payload.get("longitude") or 77.2)
+    event_type = payload.get("event_type") or "general"
+    tz_obj = pytz.timezone(tz_name)
+    start_dt = tz_obj.localize(_dt.fromisoformat(start_str))
+    end_dt = tz_obj.localize(_dt.fromisoformat(end_str))
+    return {
+        "best_windows": get_best_muhurta_in_range(
+            start_dt, end_dt, lat, lon, event_type
+        )
+    }
+
+
+# ─── New comprehensive tools batch 2 ──────────────────────────────────────────
+
+
+def get_avasthas_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get planetary Avasthas (9 states) and Baladi Avasthas for a birth chart."""
+    base = _require_base_chart(payload)
+    return {
+        "avasthas": get_avasthas(base["planetary_positions"], base["ascendant"]),
+        "ayanamsa": base.get("ayanamsa_name"),
+    }
+
+
+def get_upagrahas_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Upagrahas: Gulika, Mandi, Dhuma, Vyatipata, Parivesha, Indra Chapa, Upaketu."""
+    import pytz
+    import swisseph as swe
+
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    swe.set_ephe_path(None)
+    swe.set_sid_mode(swe.SIDM_LAHIRI)
+    tz_obj = pytz.timezone(tz)
+    birth_aware = tz_obj.localize(birth_dt)
+    utc = birth_aware.astimezone(pytz.UTC)
+    h = utc.hour + utc.minute / 60.0 + utc.second / 3600.0
+    jd = swe.julday(utc.year, utc.month, utc.day, h)
+    ayanamsa = swe.get_ayanamsa_ut(jd)
+    return get_upagrahas(jd, lat, lon, ayanamsa)
+
+
+def get_gandanta_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Check which planets (if any) are in Gandanta zones (water-fire sign junctions)."""
+    base = _require_base_chart(payload)
+    return {
+        "gandanta_planets": check_gandanta(base["planetary_positions"]),
+        "gandanta_zones_info": get_gandanta_info(),
+    }
+
+
+def get_kartari_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Check Kartari Yoga: planets or houses hemmed between benefics (Subha) or malefics (Papa)."""
+    base = _require_base_chart(payload)
+    # Convert houses dict from {"House_1": "Capricorn", ...} to {1: ["Sun", ...], ...}
+    houses_map: dict[int, list[str]] = {}
+    for planet in base["planetary_positions"]:
+        h = int(planet["house"])
+        houses_map.setdefault(h, []).append(planet["name"])
+    return {
+        "kartari_yogas": check_kartari_yoga(base["planetary_positions"], houses_map)
+    }
+
+
+def get_nakshatra_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get deep Nakshatra analysis: deity, symbol, gana, element, padas, and keywords for each planet."""
+    base = _require_base_chart(payload)
+    result = {
+        "planet_nakshatra_analysis": get_planet_nakshatra_analysis(
+            base["planetary_positions"]
+        )
+    }
+    if payload.get("nakshatra_name"):
+        result["nakshatra_details"] = get_nakshatra_details(payload["nakshatra_name"])
+    return result
+
+
+def get_gochara_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Gochara (Vedic transit analysis): how current transiting planets affect natal Moon houses."""
+    natal = _require_base_chart(payload)
+    # Build transit chart for current or specified datetime
+    import pytz
+    import swisseph as swe
+
+    dt_text = (payload.get("transit_datetime") or "").strip()
+    swe.set_ephe_path(None)
+    swe.set_sid_mode(swe.SIDM_LAHIRI)
+    if dt_text:
+        dt = datetime.fromisoformat(dt_text.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = pytz.UTC.localize(dt)
+    else:
+        dt = datetime.now(pytz.UTC)
+    utc = dt.astimezone(pytz.UTC)
+    h = utc.hour + utc.minute / 60.0 + utc.second / 3600.0
+    jd = swe.julday(utc.year, utc.month, utc.day, h)
+    flags = swe.FLG_SWIEPH | swe.FLG_SPEED | swe.FLG_SIDEREAL
+    from kundali_lib.vedic.chart import get_transit_positions as _gtp
+
+    transit_planets = _gtp(utc)
+    return get_gochara(natal, transit_planets)
+
+
+def get_bhava_chalit_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Bhava Chalit chart: house positions based on equal divisions from house cusps."""
+    base = _require_base_chart(payload)
+    return get_bhava_chalit(base)
+
+
+def get_hora_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Planetary Hour (Hora) for a given datetime and location."""
+    import pytz
+
+    dt_text = (payload.get("datetime") or "").strip()
+    tz_name = payload.get("timezone") or "UTC"
+    lat = float(payload.get("latitude") or 28.6)
+    lon = float(payload.get("longitude") or 77.2)
+    if dt_text:
+        dt = datetime.fromisoformat(dt_text.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = pytz.timezone(tz_name).localize(dt)
+        dt_utc = dt.astimezone(pytz.UTC)
+    else:
+        dt_utc = datetime.now(pytz.UTC)
+    return get_planetary_hour(dt_utc, lat, lon)
+
+
+def get_sudarshana_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Sudarshana Chakra: triple-layer analysis from Lagna, Moon, and Sun simultaneously."""
+    base = _require_base_chart(payload)
+    return get_sudarshana_chakra(base)
+
+
+def get_ashtottari_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Ashtottari Dasha (108-year cycle alternative to Vimshottari)."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    import pytz
+
+    birth_aware = pytz.timezone(tz).localize(birth_dt)
+    return get_ashtottari_dasha(birth_aware, moon["longitude"], moon["nakshatra"])
+
+
+def get_sookshma_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Sookshma Dasha (4th level: MD→AD→PD→SD) — shows current running period at all 4 levels."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    # get_sookshma_dasha expects naive birth_dt
+    return get_sookshma_dasha(birth_dt, moon["longitude"], moon["nakshatra"])
+
+
+def get_prana_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Prana Dasha (5th level: MD→AD→PD→SD→PRD) — finest level of Vimshottari Dasha."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    # get_prana_dasha expects naive birth_dt
+    return get_prana_dasha(birth_dt, moon["longitude"], moon["nakshatra"])
+
+
+def get_char_dasha_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Char Dasha (Jaimini sign-based dasha system)."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    import pytz
+
+    birth_aware = pytz.timezone(tz).localize(birth_dt)
+    return get_char_dasha(base, birth_aware)
+
+
+def get_narayana_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Narayana Dasha (Jaimini sign-based dasha for worldly events)."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    import pytz
+
+    birth_aware = pytz.timezone(tz).localize(birth_dt)
+    return get_narayana_dasha(base, birth_aware)
+
+
+def get_tajaka_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Tajaka analysis for Varshaphal (annual chart): Muntha, Munthesh, and Tajaka Yogas."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, birth_tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    year_of_life = int(payload["year_of_life"])
+    query_lat = float(payload.get("query_latitude") or lat)
+    query_lon = float(payload.get("query_longitude") or lon)
+    query_tz = payload.get("query_timezone") or birth_tz
+    # get_varshaphal expects naive birth_dt
+    birth_chart = ephemeris_service.calculate_chart(
+        "Chart", birth_dt, lat, lon, birth_tz
+    )
+    varsha = get_varshaphal(
+        birth_dt, lat, lon, birth_tz, year_of_life, query_lat, query_lon, query_tz
+    )
+    varsha_chart = varsha.get("varshaphal_chart", {})
+    return get_tajaka_analysis(birth_chart, varsha_chart, year_of_life)
+
+
+def get_nabhasha_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Nabhasha Yogas: special yogas based on overall planetary distribution pattern."""
+    base = _require_base_chart(payload)
+    return get_nabhasha_yogas(base["planetary_positions"])
+
+
+def get_arishta_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Arishta Yogas: longevity assessment and affliction indicators."""
+    base = _require_base_chart(payload)
+    return get_arishta_yogas(base)
+
+
+def get_lunar_return_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Lunar Return (Chandraphal): monthly chart for when Moon returns to natal position."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, birth_tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, birth_tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    target_year = int(payload["target_year"])
+    target_month = int(payload["target_month"])
+    query_lat = float(payload.get("query_latitude") or lat)
+    query_lon = float(payload.get("query_longitude") or lon)
+    query_tz = payload.get("query_timezone") or birth_tz
+    # get_lunar_return expects naive birth_dt (it localizes internally)
+    return get_lunar_return(
+        {
+            "moon_sign": moon["rashi"],
+            "planetary_positions": base["planetary_positions"],
+        },
+        birth_dt,
+        target_year,
+        target_month,
+        query_lat,
+        query_lon,
+        query_tz,
+    )
+
+
+def get_prasna_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Prasna (Horary) chart for the moment a question is asked."""
+    import pytz
+
+    dt_text = (payload.get("datetime") or "").strip()
+    tz_name = payload.get("timezone") or "UTC"
+    lat = float(payload.get("latitude") or 28.6)
+    lon = float(payload.get("longitude") or 77.2)
+    question = payload.get("question") or ""
+    if dt_text:
+        dt = datetime.fromisoformat(dt_text.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = pytz.timezone(tz_name).localize(dt)
+        dt_utc = dt.astimezone(pytz.UTC)
+    else:
+        dt_utc = datetime.now(pytz.UTC)
+    return get_prasna_chart(dt_utc, lat, lon, question)
+
+
+def _moon_nakshatra_from_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """Helper: build a base chart and return Moon nakshatra + longitude + tz-aware birth_dt."""
+    birth_dt = parse_birth_datetime(payload["date_of_birth"], payload["time_of_birth"])
+    lat, lon, tz = resolve_location(
+        city=payload.get("city", ""),
+        latitude=payload.get("latitude"),
+        longitude=payload.get("longitude"),
+        timezone=payload.get("timezone"),
+    )
+    base = ephemeris_service.calculate_chart("Chart", birth_dt, lat, lon, tz)
+    moon = next(p for p in base["planetary_positions"] if p["name"] == "Moon")
+    import pytz
+
+    return {
+        "moon_nakshatra": moon["nakshatra"],
+        "moon_longitude": moon["longitude"],
+        "birth_aware": pytz.timezone(tz).localize(birth_dt),
+    }
+
+
+def get_kalachakra_dasha_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Kalachakra Dasha: 9-group 112-year sign-based cycle (one of the most complex dasha systems)."""
+    info = _moon_nakshatra_from_payload(payload)
+    return get_kalachakra_dasha(
+        info["birth_aware"], info["moon_longitude"], info["moon_nakshatra"]
+    )
+
+
+def get_kurmachakra_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get Kurmachakra (Tortoise Wheel) directional analysis: best/avoid directions for travel, construction, marriage."""
+    info = _moon_nakshatra_from_payload(payload)
+    return get_kurmachakra(
+        birth_nakshatra=info["moon_nakshatra"],
+        current_moon_nakshatra=payload.get("current_moon_nakshatra"),
+        event_type=payload.get("event_type", "travel"),
+    )
+
+
+def get_travel_direction_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Score a specific intended travel direction for auspiciousness using Kurmachakra rules."""
+    info = _moon_nakshatra_from_payload(payload)
+    return get_travel_direction_score(
+        birth_nakshatra=info["moon_nakshatra"],
+        intended_direction=payload.get("intended_direction", "North"),
+        current_moon_nakshatra=payload.get("current_moon_nakshatra"),
+        weekday=payload.get("weekday"),
+    )
+
+
+def get_full_kurmachakra_chart_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Return the full Kurmachakra chart: all 9 directions + their nakshatras + weekday-avoid rules."""
+    return get_full_kurmachakra_chart()
+
+
+TOOLS = {
+    # Core chart tools
+    "generate_kundali": generate_kundali,
+    "list_available_chart_types": list_available_chart_types,
+    "list_ayanamsa_modes": list_ayanamsa_modes_tool,
+    "list_house_systems": list_house_systems_tool,
+    "search_birth_places": search_birth_places,
+    "get_timezone_for_coordinates": get_timezone_for_coordinates,
+    "get_transit_positions": get_transit_positions,
+    # vedicastro / KP tools
+    "get_extended_chart": get_extended_chart,
+    "get_vimshottari_dasha": get_vimshottari_dasha,
+    "get_planetary_aspects": get_planetary_aspects_tool,
+    "get_significators": get_significators,
+    "list_extended_options": list_extended_options,
+    # New comprehensive tools
+    "get_panchanga": get_panchanga_tool,
+    "get_doshas": get_doshas_tool,
+    "get_yogas": get_yogas_tool,
+    "get_compatibility": get_compatibility_tool,
+    "get_special_conditions": get_special_conditions_tool,
+    "get_pratyantar_dasha": get_pratyantar_dasha_tool,
+    "get_yogini_dasha": get_yogini_dasha_tool,
+    "get_varshaphal": get_varshaphal_tool,
+    "get_ashtakavarga": get_ashtakavarga_tool,
+    "get_shadbala": get_shadbala_tool,
+    "get_jaimini": get_jaimini_tool,
+    "get_muhurta": get_muhurta_tool,
+    "get_best_muhurta": get_best_muhurta_tool,
+    # Batch 2 — new comprehensive tools
+    "get_avasthas": get_avasthas_tool,
+    "get_upagrahas": get_upagrahas_tool,
+    "get_gandanta": get_gandanta_tool,
+    "get_kartari": get_kartari_tool,
+    "get_nakshatra_analysis": get_nakshatra_tool,
+    "get_gochara": get_gochara_tool,
+    "get_bhava_chalit": get_bhava_chalit_tool,
+    "get_hora": get_hora_tool,
+    "get_sudarshana_chakra": get_sudarshana_tool,
+    "get_ashtottari_dasha": get_ashtottari_tool,
+    "get_sookshma_dasha": get_sookshma_tool,
+    "get_prana_dasha": get_prana_tool,
+    "get_char_dasha": get_char_dasha_tool,
+    "get_narayana_dasha": get_narayana_tool,
+    "get_tajaka": get_tajaka_tool,
+    "get_nabhasha_yogas": get_nabhasha_tool,
+    "get_arishta": get_arishta_tool,
+    "get_lunar_return": get_lunar_return_tool,
+    "get_prasna": get_prasna_tool,
+    # Kalachakra + Kurmachakra tools (final additions)
+    "get_kalachakra_dasha": get_kalachakra_dasha_tool,
+    "get_kurmachakra": get_kurmachakra_tool,
+    "get_travel_direction_score": get_travel_direction_tool,
+    "get_full_kurmachakra_chart": get_full_kurmachakra_chart_tool,
+}
+
+
+def main() -> int:
+    if len(sys.argv) != 2 or sys.argv[1] not in TOOLS:
+        print("Usage: kundali_bridge.py <tool-name>", file=sys.stderr)
+        return 2
+
+    try:
+        payload = json.loads(sys.stdin.read() or "{}")
+        result = TOOLS[sys.argv[1]](payload)
+        print(json.dumps(result, ensure_ascii=False))
+        return 0
+    except Exception as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())