kundali-chart-mcp 0.2.8 → 0.3.0

package/azure-function/function_app.py

@@ -49,6 +49,23 @@ except Exception as e:
     # Don't exit - we can still serve the health endpoint
 
 
+@app.route(route="tools")
+def tools_handler(req: func.HttpRequest) -> func.HttpResponse:
+    """Return list of all available tools with descriptions."""
+    tool_list = []
+    for name, func_obj in TOOLS.items():
+        tool_list.append(
+            {
+                "name": name,
+                "description": func_obj.__doc__ or "",
+            }
+        )
+    return func.HttpResponse(
+        json.dumps({"tools": tool_list}, ensure_ascii=False),
+        mimetype="application/json",
+    )
+
+
 @app.route(route="kundali/{toolName}")
 def kundali_handler(req: func.HttpRequest) -> func.HttpResponse:
     tool_name = req.route_params.get("toolName")

package/azure-function/kundali_bridge.py

@@ -26,6 +26,10 @@ 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.arudha import (  # noqa: E402
+    calculate_all_arudhas,
+    calculate_upapada,
+)
 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
@@ -64,6 +68,10 @@ from kundali_lib.vedic.doshas import (  # noqa: E402
 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.inauspicious_times import (  # noqa: E402
+    calculate_inauspicious_times,
+    is_time_auspicious,
+)
 from kundali_lib.vedic.jaimini import (  # noqa: E402
     get_jaimini_aspects,
     get_jaimini_karakas,
@@ -80,6 +88,7 @@ from kundali_lib.vedic.lunar_return import (  # noqa: E402
     get_lunar_return,
     get_prasna_chart,
 )
+from kundali_lib.vedic.medical_astrology import get_medical_astrology  # noqa: E402
 from kundali_lib.vedic.muhurta import (  # noqa: E402
     get_best_muhurta_in_range,
     get_muhurta_score,
@@ -91,6 +100,7 @@ from kundali_lib.vedic.nakshatra_details import (  # noqa: E402
     get_planet_nakshatra_analysis,
 )
 from kundali_lib.vedic.panchanga import get_panchanga  # noqa: E402
+from kundali_lib.vedic.remedial import get_comprehensive_remedial_measures  # noqa: E402
 from kundali_lib.vedic.shadbala import get_shadbala  # noqa: E402
 from kundali_lib.vedic.special_conditions import (  # noqa: E402
     check_pushkara_navamsha,
@@ -876,6 +886,141 @@ def get_full_kurmachakra_chart_tool(payload: dict[str, Any]) -> dict[str, Any]:
     return get_full_kurmachakra_chart()
 
 
+def get_arudha_lagna_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Calculate Arudha Lagna (AL) and all 12 Arudha Padas — how the world perceives you.
+
+    Arudha Lagna reveals your public image, reputation, and social standing.
+    Each Arudha Pada shows the manifested reality of that house.
+    Upapada Lagna indicates marriage nature and spouse characteristics.
+    Used to understand fame, status, and how others see you vs who you really are."""
+    base = _require_base_chart(payload)
+    lagna_rashi = base.get("ascendant", {}).get("rashi", "")
+    positions = base.get("planetary_positions", [])
+    return calculate_all_arudhas(lagna_rashi, positions)
+
+
+def get_upapada_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Calculate Upapada Lagna — the key indicator for marriage and spouse analysis.
+
+    Upapada Lagna is derived from Arudha Lagna and specifically indicates:
+    - Nature of marriage (love/arranged, harmonious/difficult)
+    - Spouse characteristics and personality
+    - Marital happiness and longevity of marriage
+    Essential for relationship and marriage timing analysis."""
+    base = _require_base_chart(payload)
+    lagna_rashi = base.get("ascendant", {}).get("rashi", "")
+    positions = base.get("planetary_positions", [])
+    return calculate_upapada(lagna_rashi, positions)
+
+
+def get_remedial_measures_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get personalized Vedic remedies — gemstones, mantras, charity, fasting, and lifestyle changes.
+
+    Analyzes each planet's condition (debilitated, combust, retrograde, weak in Shadbala, etc.)
+    and provides specific, actionable remedies:
+    - Gemstone recommendations (which stone, which finger, which metal, when to wear)
+    - Mantra recommendations (specific Beej mantras for each planet)
+    - Charity recommendations (what to donate, to whom, on which day)
+    - Fasting recommendations (which day, what type of fast)
+    - Lifestyle changes (colors, directions, activities to embrace or avoid)
+    Remedies are prioritized by urgency (high/medium/low)."""
+    base = _require_base_chart(payload)
+    positions = base.get("planetary_positions", [])
+    # Try to get Shadbala for more accurate assessment
+    shadbala_data = None
+    try:
+        shadbala_data = get_shadbala(positions)
+    except Exception:
+        pass
+    return get_comprehensive_remedial_measures(positions, shadbala_data)
+
+
+def get_inauspicious_times_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get inauspicious time periods for a given date — Rahu Kala, Yamaganda, Gulika, Choghadiya.
+
+    Calculates all major inauspicious (and auspicious) time periods:
+    - Rahu Kala: The most inauspicious period — avoid starting new ventures
+    - Yamaganda: Yama's inauspicious period — avoid travel
+    - Gulika Kala: Inauspicious for important decisions
+    - Choghadiya: 8 time divisions showing auspicious/inauspicious nature
+    - Abhijit Muhurta: Most auspicious midday window
+    - Brahma Muhurta: Pre-dawn spiritual time
+    Essential for muhurta (electional astrology) and daily planning."""
+    from datetime import datetime as dt
+
+    date = dt(
+        payload.get("year", 2000),
+        payload.get("month", 1),
+        payload.get("day", 1),
+    )
+    sunrise = None
+    sunset = None
+    if "sunrise_hour" in payload:
+        sunrise = date.replace(
+            hour=payload.get("sunrise_hour", 6),
+            minute=payload.get("sunrise_minute", 0),
+        )
+    if "sunset_hour" in payload:
+        sunset = date.replace(
+            hour=payload.get("sunset_hour", 18),
+            minute=payload.get("sunset_minute", 0),
+        )
+    return calculate_inauspicious_times(date, sunrise, sunset)
+
+
+def check_time_auspiciousness_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Check if a specific date and time is auspicious or inauspicious.
+
+    Evaluates any given moment against all Vedic time-keeping systems:
+    - Is it in Rahu Kala? (avoid important work)
+    - Is it in Yamaganda? (avoid travel)
+    - Is it in Gulika Kala? (avoid decisions)
+    - Is it Abhijit Muhurta? (excellent for new beginnings)
+    - Is it Brahma Muhurta? (best for spiritual practices)
+    - What is the current Choghadiya? (auspicious/inauspicious)
+    Returns a clear rating: Highly Auspicious / Auspicious / Neutral / Inauspicious
+    with a recommendation on what to do or avoid."""
+    from datetime import datetime as dt
+
+    check_time = dt(
+        payload.get("year", 2000),
+        payload.get("month", 1),
+        payload.get("day", 1),
+        payload.get("hour", 12),
+        payload.get("minute", 0),
+    )
+    sunrise = None
+    sunset = None
+    if "sunrise_hour" in payload:
+        sunrise = check_time.replace(
+            hour=payload.get("sunrise_hour", 6),
+            minute=payload.get("sunrise_minute", 0),
+        )
+    if "sunset_hour" in payload:
+        sunset = check_time.replace(
+            hour=payload.get("sunset_hour", 18),
+            minute=payload.get("sunset_minute", 0),
+        )
+    return is_time_auspicious(check_time, sunrise, sunset)
+
+
+def get_medical_astrology_tool(payload: dict[str, Any]) -> dict[str, Any]:
+    """Get health predictions from Vedic Medical Astrology (Ayurvedic Astrology).
+
+    Maps your birth chart to health vulnerabilities:
+    - Vulnerable body parts based on house placements
+    - Planet-conditioned health risks (debilitated/retrograde planets)
+    - Ayurvedic Dosha balance (Vata/Pitta/Kapha constitution)
+    - Health recommendations based on your chart
+    - Overall vitality, mental health, and longevity indicators
+    Based on traditional Vedic medical astrology connecting houses, signs,
+    and planets to body systems and Ayurvedic principles."""
+    base = _require_base_chart(payload)
+    lagna_rashi = base.get("ascendant", {}).get("rashi", "")
+    positions = base.get("planetary_positions", [])
+    return get_medical_astrology(positions, lagna_rashi)
+
+
 TOOLS = {
     # Core chart tools
     "generate_kundali": generate_kundali,
@@ -930,6 +1075,13 @@ TOOLS = {
     "get_kurmachakra": get_kurmachakra_tool,
     "get_travel_direction_score": get_travel_direction_tool,
     "get_full_kurmachakra_chart": get_full_kurmachakra_chart_tool,
+    # Batch 3 — Arudha, Remedial, Inauspicious Times, Medical Astrology
+    "get_arudha_lagna": get_arudha_lagna_tool,
+    "get_upapada": get_upapada_tool,
+    "get_remedial_measures": get_remedial_measures_tool,
+    "get_inauspicious_times": get_inauspicious_times_tool,
+    "check_time_auspiciousness": check_time_auspiciousness_tool,
+    "get_medical_astrology": get_medical_astrology_tool,
 }
 
 

package/azure-function/python/kundali_lib/vedic/arudha.py

@@ -0,0 +1,189 @@
+"""Arudha Lagna and Arudha Padas calculation.
+
+Arudha Lagna (AL) is the "image" or "maya" house — how the world perceives you.
+Arudha Pada for each house shows the manifested reality of that house.
+
+Calculation:
+- Count from Lagna lord to Lagna sign (excluding Lagna itself)
+- Arudha Lagna = that many signs from Lagna lord's position
+- If result is same as Lagna (1st house), use 10th from there (special rule)
+- Similar for each house: count from house lord to house sign
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from kundali_lib.vedic.constants import PLANET_IDS, RASHI_LORDS, RASHIS
+
+# Build HOUSE_LORDS dict from RASHI_LORDS list
+HOUSE_LORDS = {rashi: lord for rashi, lord in zip(RASHIS, RASHI_LORDS)}
+
+
+def _sign_index(rashi: str) -> int:
+    return RASHIS.index(rashi)
+
+
+def _count_signs(from_rashi: str, to_rashi: str, exclude_self: bool = True) -> int:
+    """Count signs from from_rashi to to_rashi (forward)."""
+    from_i = _sign_index(from_rashi)
+    to_i = _sign_index(to_rashi)
+    count = (to_i - from_i) % 12
+    if exclude_self and count == 0:
+        count = 12
+    return count
+
+
+def _advance_signs(rashi: str, n: int) -> str:
+    return RASHIS[(_sign_index(rashi) + n) % 12]
+
+
+def calculate_arudha_lagna(
+    lagna_rashi: str,
+    lagna_lord_sign: str,
+) -> dict[str, Any]:
+    """Calculate Arudha Lagna (AL).
+
+    Count from Lagna lord's position to Lagna sign.
+    Then advance that many signs from Lagna lord.
+    If result equals Lagna, use 10th from Lagna instead.
+    """
+    count = _count_signs(lagna_lord_sign, lagna_rashi, exclude_self=True)
+    arudha = _advance_signs(lagna_lord_sign, count)
+
+    # Special rule: if Arudha Lagna falls in 1st house, use 10th from there
+    if arudha == lagna_rashi:
+        arudha = _advance_signs(lagna_rashi, 9)
+
+    return {
+        "arudha_lagna_sign": arudha,
+        "count": count,
+        "lagna_rashi": lagna_rashi,
+        "lagna_lord_sign": lagna_lord_sign,
+        "special_rule_applied": arudha != _advance_signs(lagna_lord_sign, count),
+    }
+
+
+def calculate_arudha_pada(
+    house_sign: str,
+    house_lord_sign: str,
+) -> dict[str, Any]:
+    """Calculate Arudha Pada for a specific house.
+
+    Count from house lord's position to house sign.
+    Then advance that many signs from house lord.
+    If result equals the house itself, use 10th from there.
+    """
+    count = _count_signs(house_lord_sign, house_sign, exclude_self=True)
+    arudha = _advance_signs(house_lord_sign, count)
+
+    # Special rule
+    if arudha == house_sign:
+        arudha = _advance_signs(house_sign, 9)
+
+    return {
+        "house_sign": house_sign,
+        "house_lord_sign": house_lord_sign,
+        "arudha_pada_sign": arudha,
+        "count": count,
+        "special_rule_applied": arudha != _advance_signs(house_lord_sign, count),
+    }
+
+
+def calculate_all_arudhas(
+    lagna_rashi: str,
+    planetary_positions: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Calculate Arudha Lagna and all 12 Arudha Padas.
+
+    Args:
+        lagna_rashi: The ascendant sign
+        planetary_positions: List of planet dicts with 'name' and 'rashi' keys
+
+    Returns:
+        Dictionary with AL and all Arudha Padas
+    """
+    # Build planet sign lookup
+    planet_signs = {}
+    for p in planetary_positions:
+        planet_signs[p["name"]] = p["rashi"]
+
+    # Get Lagna lord sign
+    lagna_lord = HOUSE_LORDS.get(lagna_rashi, "Mars")
+    lagna_lord_sign = planet_signs.get(lagna_lord, lagna_rashi)
+
+    # Calculate Arudha Lagna
+    al = calculate_arudha_lagna(lagna_rashi, lagna_lord_sign)
+
+    # Calculate Arudha Padas for each house
+    arudha_padas = {}
+    for i, rashi in enumerate(RASHIS):
+        house_num = i + 1
+        house_lord = HOUSE_LORDS.get(rashi, "Mars")
+        house_lord_sign = planet_signs.get(house_lord, rashi)
+
+        pada = calculate_arudha_pada(rashi, house_lord_sign)
+        arudha_padas[f"house_{house_num}"] = {
+            "house_sign": rashi,
+            "house_lord": house_lord,
+            "arudha_pada_sign": pada["arudha_pada_sign"],
+            "meaning": _arudha_pada_meaning(house_num),
+        }
+
+    return {
+        "arudha_lagna": al,
+        "arudha_padas": arudha_padas,
+        "interpretation": {
+            "al_significance": "Arudha Lagna shows how the world perceives you — your public image and reputation",
+            "pada_significance": "Each Arudha Pada shows the manifested reality of that house",
+        },
+    }
+
+
+def calculate_upapada(
+    lagna_rashi: str,
+    planetary_positions: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Calculate Upapada Lagna — the 12th house from Arudha Lagna.
+
+    Upapada is used for marriage analysis and spouse identification.
+    It shows the nature of marriage and the spouse.
+    """
+    # Build planet sign lookup
+    planet_signs = {}
+    for p in planetary_positions:
+        planet_signs[p["name"]] = p["rashi"]
+
+    lagna_lord = HOUSE_LORDS.get(lagna_rashi, "Mars")
+    lagna_lord_sign = planet_signs.get(lagna_lord, lagna_rashi)
+
+    al = calculate_arudha_lagna(lagna_rashi, lagna_lord_sign)
+    al_sign = al["arudha_lagna_sign"]
+
+    # Upapada = 12th from AL
+    upapada_sign = _advance_signs(al_sign, 11)
+
+    return {
+        "upapada_sign": upapada_sign,
+        "arudha_lagna_sign": al_sign,
+        "significance": "Upapada Lagna indicates marriage nature, spouse characteristics, and marital happiness",
+        "lord": HOUSE_LORDS.get(upapada_sign, "Unknown"),
+    }
+
+
+def _arudha_pada_meaning(house_num: int) -> str:
+    meanings = {
+        1: "Self-image and personality projection",
+        2: "Wealth manifestation and family image",
+        3: "Communication style and courage display",
+        4: "Home life and emotional expression",
+        5: "Creativity and children's image",
+        6: "Health service and conflict handling",
+        7: "Partnerships and relationship image",
+        8: "Transformation and hidden matters",
+        9: "Fortune and spiritual image",
+        10: "Career and public standing",
+        11: "Gains and social network image",
+        12: "Losses and spiritual liberation",
+    }
+    return meanings.get(house_num, "")