@openephemeris/mcp-server 3.0.0

package/dist/schema-packs/llm.js

@@ -0,0 +1,429 @@
+import { z } from "zod";
+export const LLM_V2_POINTS_SCHEMA = [
+    "id",
+    "kind",
+    "src",
+    "lon",
+    "lat",
+    "spd",
+    "rx",
+    "sg",
+    "deg",
+    "hs",
+    "dec",
+    "oob",
+    "ed",
+    "ed_sc",
+    "ad_sc",
+    "on_cusp",
+];
+export const LLM_V2_ASPECTS_SCHEMA = ["a_i", "b_i", "t", "orb", "orb_pct", "app", "str"];
+export const LLM_V2_DICT = {
+    sign_id: ["ari", "tau", "gem", "can", "leo", "vir", "lib", "sco", "sag", "cap", "aqu", "pis"],
+    aspect_id: ["con", "opp", "tri", "sqr", "sex"],
+    aspect_angle: [0, 180, 120, 90, 60],
+    kind_id: ["planet", "angle", "node", "lilith", "asteroid", "uranian", "other"],
+};
+const PointsSchemaZ = z.tuple(LLM_V2_POINTS_SCHEMA.map((v) => z.literal(v)));
+const AspectsSchemaZ = z.tuple(LLM_V2_ASPECTS_SCHEMA.map((v) => z.literal(v)));
+const PointKindZ = z.enum(LLM_V2_DICT.kind_id);
+const EdZ = z.enum(["none", "dom", "ex", "det", "fall"]);
+const PointRowZ = z.tuple([
+    z.string(), // id
+    PointKindZ, // kind
+    z.number().int(), // src (single-frame currently 0)
+    z.number(), // lon
+    z.number().nullable(), // lat
+    z.number().nullable(), // spd
+    z.number().int(), // rx
+    z.number().int(), // sg
+    z.number(), // deg
+    z.number().nullable(), // hs
+    z.number().nullable(), // dec
+    z.number().int(), // oob
+    EdZ, // ed
+    z.number().nullable(), // ed_sc
+    z.number().nullable(), // ad_sc
+    z.number().int(), // on_cusp
+]);
+const AspectRowZ = z.tuple([
+    z.number().int(), // a_i
+    z.number().int(), // b_i
+    z.number().int(), // t
+    z.number(), // orb
+    z.number(), // orb_pct
+    z.number().int(), // app
+    z.number(), // str
+]);
+const ChartSubjectZ = z
+    .object({
+    datetime: z.string().nullable().optional(),
+    jd: z.number().nullable().optional(),
+    lat: z.number().nullable().optional(),
+    lon: z.number().nullable().optional(),
+})
+    .strict();
+const ChartZ = z
+    .object({
+    chart_type: z.enum(["natal", "synastry"]),
+    // Natal-style payloads include subject; synastry-style table payloads omit it.
+    subject: ChartSubjectZ.optional(),
+})
+    .strict();
+const RulesZ = z
+    .object({
+    zodiac_type: z.string().nullable().optional(),
+    house_system: z.string().nullable().optional(),
+    coordinate_system: z.string().nullable().optional(),
+    node_source: z.string().nullable().optional(),
+    lon_range: z.literal("0_360"),
+    aspect_set: z.literal("major_default"),
+    orb_profile: z.string().nullable().optional(),
+    strength_basis: z.literal("engine"),
+    point_order_id: z.literal("astro_point_order_v1"),
+    core_set_id: z.literal("core_interp_set_v1"),
+})
+    .strict();
+const ProvenanceZ = z
+    .object({
+    engine: z.string(),
+    ephemeris_source: z.string(),
+    ephemeris_version: z.string(),
+    validation_profile: z.string().nullable().optional(),
+    precision_level: z.string().nullable().optional(),
+    checksum: z.string().nullable().optional(),
+})
+    .strict();
+const DictZ = z
+    .object({
+    sign_id: z.tuple(LLM_V2_DICT.sign_id.map((v) => z.literal(v))),
+    aspect_id: z.tuple(LLM_V2_DICT.aspect_id.map((v) => z.literal(v))),
+    aspect_angle: z.tuple(LLM_V2_DICT.aspect_angle.map((v) => z.literal(v))),
+    kind_id: z.tuple(LLM_V2_DICT.kind_id.map((v) => z.literal(v))),
+})
+    .strict();
+const PresentZ = z
+    .object({
+    point_count: z.number().int(),
+    kinds: z.record(z.string(), z.number().int()),
+})
+    .strict();
+const AnglesZ = z
+    .object({
+    asc: z.number().nullable().optional(),
+    mc: z.number().nullable().optional(),
+    dsc: z.number().nullable().optional(),
+    ic: z.number().nullable().optional(),
+})
+    .strict();
+const HousesZ = z
+    .object({
+    system: z.string().nullable().optional(),
+    cusps: z.array(z.number()),
+})
+    .strict();
+const PatternsZ = z
+    .object({
+    stellium: z.array(z.unknown()),
+    t_square: z.array(z.unknown()),
+    grand_trine: z.array(z.unknown()),
+    kite: z.array(z.unknown()),
+    yod: z.array(z.unknown()),
+    grand_cross: z.array(z.unknown()),
+})
+    .strict();
+const ExtrasZ = z
+    .object({
+    fixed_star_conjunctions: z.array(z.unknown()),
+    lots: z.array(z.unknown()),
+})
+    .strict();
+const CountsZ = z
+    .object({
+    point_count: z.number().int(),
+    aspect_count: z.number().int(),
+    // Natal-style payloads include these; synastry-style may omit.
+    aspect_count_unfiltered: z.number().int().optional(),
+    midpoint_count: z.number().int().optional(),
+    declination_aspect_count: z.number().int().optional(),
+    stellium_count: z.number().int().optional(),
+})
+    .strict();
+const HumanDesignZ = z
+    .object({
+    gates_schema: z.array(z.string()),
+    gates: z.array(z.array(z.any())),
+})
+    .strict();
+export const LlmV2PayloadSchema = z
+    .object({
+    // Some fixtures include this (envelope-like), but backend projector may omit it.
+    output_mode: z.literal("llm").optional(),
+    // Backend keeps schema versioning internal; allow older fixtures to include it.
+    schema_version: z.literal("llm").optional(),
+    chart: ChartZ,
+    // Natal-style payloads include these blocks; synastry-style may omit.
+    rules: RulesZ.optional(),
+    reliability: z.record(z.string(), z.unknown()).optional(),
+    provenance: ProvenanceZ.optional(),
+    dict: DictZ,
+    present: PresentZ,
+    points_schema: PointsSchemaZ,
+    points: z.array(PointRowZ),
+    angles: AnglesZ.optional(),
+    houses: HousesZ.optional(),
+    aspects_schema: AspectsSchemaZ,
+    aspects: z.array(AspectRowZ),
+    patterns: PatternsZ.optional(),
+    extras: ExtrasZ.optional(),
+    counts: CountsZ,
+    // Optional enrichment blocks added by some endpoints.
+    analysis: z.record(z.string(), z.unknown()).optional(),
+    human_design: HumanDesignZ.optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const expectedPointsLen = LLM_V2_POINTS_SCHEMA.length;
+    for (let i = 0; i < Math.min(value.points.length, 200); i++) {
+        const row = value.points[i];
+        if (row.length !== expectedPointsLen) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["points", i],
+                message: `points[${i}] row length ${row.length} != ${expectedPointsLen}`,
+            });
+        }
+    }
+    const expectedAspectsLen = LLM_V2_ASPECTS_SCHEMA.length;
+    for (let i = 0; i < Math.min(value.aspects.length, 2000); i++) {
+        const row = value.aspects[i];
+        if (row.length !== expectedAspectsLen) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["aspects", i],
+                message: `aspects[${i}] row length ${row.length} != ${expectedAspectsLen}`,
+            });
+        }
+    }
+});
+// A JSON Schema companion for downstream consumers.
+// (We intentionally keep this small and explicit rather than depending on a zod->jsonschema lib.)
+export const llmV2JsonSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "Open Ephemeris LLM Projection (format=llm)",
+    type: "object",
+    additionalProperties: false,
+    required: ["chart", "dict", "present", "points_schema", "points", "aspects_schema", "aspects", "counts"],
+    properties: {
+        output_mode: { type: "string", enum: ["llm"] },
+        schema_version: { type: "string", enum: ["llm"] },
+        chart: {
+            type: "object",
+            additionalProperties: false,
+            required: ["chart_type"],
+            properties: {
+                chart_type: { type: "string", enum: ["natal", "synastry"] },
+                subject: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        datetime: { anyOf: [{ type: "string" }, { type: "null" }] },
+                        jd: { anyOf: [{ type: "number" }, { type: "null" }] },
+                        lat: { anyOf: [{ type: "number" }, { type: "null" }] },
+                        lon: { anyOf: [{ type: "number" }, { type: "null" }] },
+                    },
+                },
+            },
+        },
+        rules: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "lon_range",
+                "aspect_set",
+                "strength_basis",
+                "point_order_id",
+                "core_set_id",
+            ],
+            properties: {
+                zodiac_type: { anyOf: [{ type: "string" }, { type: "null" }] },
+                house_system: { anyOf: [{ type: "string" }, { type: "null" }] },
+                coordinate_system: { anyOf: [{ type: "string" }, { type: "null" }] },
+                node_source: { anyOf: [{ type: "string" }, { type: "null" }] },
+                lon_range: { type: "string", enum: ["0_360"] },
+                aspect_set: { type: "string", enum: ["major_default"] },
+                orb_profile: { anyOf: [{ type: "string" }, { type: "null" }] },
+                strength_basis: { type: "string", enum: ["engine"] },
+                point_order_id: { type: "string", enum: ["astro_point_order_v1"] },
+                core_set_id: { type: "string", enum: ["core_interp_set_v1"] },
+            },
+        },
+        reliability: { type: "object" },
+        provenance: {
+            type: "object",
+            additionalProperties: false,
+            required: ["engine", "ephemeris_source", "ephemeris_version"],
+            properties: {
+                engine: { type: "string" },
+                ephemeris_source: { type: "string" },
+                ephemeris_version: { type: "string" },
+                validation_profile: { anyOf: [{ type: "string" }, { type: "null" }] },
+                precision_level: { anyOf: [{ type: "string" }, { type: "null" }] },
+                checksum: { anyOf: [{ type: "string" }, { type: "null" }] },
+            },
+        },
+        dict: {
+            type: "object",
+            additionalProperties: false,
+            required: ["sign_id", "aspect_id", "aspect_angle", "kind_id"],
+            properties: {
+                sign_id: {
+                    type: "array",
+                    items: { type: "string" },
+                    const: LLM_V2_DICT.sign_id,
+                },
+                aspect_id: {
+                    type: "array",
+                    items: { type: "string" },
+                    const: LLM_V2_DICT.aspect_id,
+                },
+                aspect_angle: {
+                    type: "array",
+                    items: { type: "number" },
+                    const: LLM_V2_DICT.aspect_angle,
+                },
+                kind_id: {
+                    type: "array",
+                    items: { type: "string" },
+                    const: LLM_V2_DICT.kind_id,
+                },
+            },
+        },
+        present: {
+            type: "object",
+            additionalProperties: false,
+            required: ["point_count", "kinds"],
+            properties: {
+                point_count: { type: "integer" },
+                kinds: { type: "object", additionalProperties: { type: "integer" } },
+            },
+        },
+        points_schema: {
+            type: "array",
+            items: { type: "string" },
+            const: LLM_V2_POINTS_SCHEMA,
+        },
+        points: {
+            type: "array",
+            items: {
+                type: "array",
+                minItems: LLM_V2_POINTS_SCHEMA.length,
+                maxItems: LLM_V2_POINTS_SCHEMA.length,
+                prefixItems: [
+                    { type: "string" },
+                    { type: "string" },
+                    { type: "integer" },
+                    { type: "number" },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { type: "integer" },
+                    { type: "integer" },
+                    { type: "number" },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { type: "integer" },
+                    { type: "string" },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { anyOf: [{ type: "number" }, { type: "null" }] },
+                    { type: "integer" },
+                ],
+            },
+        },
+        angles: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                asc: { anyOf: [{ type: "number" }, { type: "null" }] },
+                mc: { anyOf: [{ type: "number" }, { type: "null" }] },
+                dsc: { anyOf: [{ type: "number" }, { type: "null" }] },
+                ic: { anyOf: [{ type: "number" }, { type: "null" }] },
+            },
+        },
+        houses: {
+            type: "object",
+            additionalProperties: false,
+            required: ["cusps"],
+            properties: {
+                system: { anyOf: [{ type: "string" }, { type: "null" }] },
+                cusps: { type: "array", items: { type: "number" } },
+            },
+        },
+        aspects_schema: {
+            type: "array",
+            items: { type: "string" },
+            const: LLM_V2_ASPECTS_SCHEMA,
+        },
+        aspects: {
+            type: "array",
+            items: {
+                type: "array",
+                minItems: LLM_V2_ASPECTS_SCHEMA.length,
+                maxItems: LLM_V2_ASPECTS_SCHEMA.length,
+                prefixItems: [
+                    { type: "integer" },
+                    { type: "integer" },
+                    { type: "integer" },
+                    { type: "number" },
+                    { type: "number" },
+                    { type: "integer" },
+                    { type: "number" },
+                ],
+            },
+        },
+        patterns: {
+            type: "object",
+            additionalProperties: false,
+            required: ["stellium", "t_square", "grand_trine", "kite", "yod", "grand_cross"],
+            properties: {
+                stellium: { type: "array" },
+                t_square: { type: "array" },
+                grand_trine: { type: "array" },
+                kite: { type: "array" },
+                yod: { type: "array" },
+                grand_cross: { type: "array" },
+            },
+        },
+        extras: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fixed_star_conjunctions", "lots"],
+            properties: {
+                fixed_star_conjunctions: { type: "array" },
+                lots: { type: "array" },
+            },
+        },
+        counts: {
+            type: "object",
+            additionalProperties: false,
+            required: ["point_count", "aspect_count"],
+            properties: {
+                point_count: { type: "integer" },
+                aspect_count: { type: "integer" },
+                aspect_count_unfiltered: { type: "integer" },
+                midpoint_count: { type: "integer" },
+                declination_aspect_count: { type: "integer" },
+                stellium_count: { type: "integer" },
+            },
+        },
+        analysis: { type: "object" },
+        human_design: {
+            type: "object",
+            additionalProperties: false,
+            required: ["gates_schema", "gates"],
+            properties: {
+                gates_schema: { type: "array", items: { type: "string" } },
+                gates: { type: "array", items: { type: "array" } },
+            },
+        },
+    },
+};

package/dist/tools/dev.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/dev.js

@@ -0,0 +1,183 @@
+import { registerTool } from "./index.js";
+import { backendClient } from "../backend/client.js";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function getAllowlistPath() {
+    const envPath = process.env.ASTROMCP_DEV_ALLOWLIST_PATH;
+    if (envPath && envPath.trim())
+        return envPath;
+    // dist lives at mcp-server/dist; src lives at mcp-server/src.
+    // We resolve relative to current file location for both dev+prod.
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // here: .../dist/tools OR .../src/tools
+    const mcpServerRoot = path.resolve(here, "..", "..");
+    return path.join(mcpServerRoot, "config", "dev-allowlist.json");
+}
+function loadAllowlist() {
+    const allowlistPath = getAllowlistPath();
+    const raw = fs.readFileSync(allowlistPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schema !== "astromcp-dev-allowlist-v1" || !Array.isArray(parsed.allow)) {
+        throw new Error(`Invalid allowlist file at ${allowlistPath}. Expected schema astromcp-dev-allowlist-v1.`);
+    }
+    return parsed;
+}
+function isDeniedByPrefix(pathname, prefixes) {
+    return prefixes.some((p) => pathname.startsWith(p));
+}
+function isAllowedOperation(method, pathname, allow) {
+    return allow.some((e) => e.method === method && e.path === pathname);
+}
+registerTool({
+    name: "dev.call",
+    description: "Call any allowlisted Open Ephemeris API endpoint directly. This is the power-user escape hatch " +
+        "— use the typed tools (ephemeris.natal_chart, ephemeris.transits, etc.) first for common operations. " +
+        "Call dev.list_allowed to see all currently available endpoint paths.\n\n" +
+        "AUTH: Set ASTROMCP_API_KEY in your environment. See openephemeris.com/dashboard for active plan limits.\n\n" +
+        "CREDIT COSTS:\n" +
+        "  • Standard chart (natal, synastry, composite, progressed): 1 credit\n" +
+        "  • Predictive ops (transits, returns, transit-chart): 5 credits\n" +
+        "  • ACG / astrocartography: 5 credits\n" +
+        "  • Human Design chart: 1 credit\n" +
+        "  • Catalog / metadata / health endpoints: 0 credits\n" +
+        "  • format=llm (token-optimized output): requires Pro tier ($49+/mo)\n\n" +
+        "COMMON CALLS:\n" +
+        "  POST /ephemeris/natal-chart            — Full natal chart (body: {datetime, latitude, longitude})\n" +
+        "  POST /ephemeris/natal/batch            — Up to 50 natal charts in one request\n" +
+        "  POST /ephemeris/relocation             — Relocated chart (same natal, new location)\n" +
+        "  POST /predictive/transits/search       — Transit event search over a date range\n" +
+        "  POST /predictive/returns/solar         — Solar return chart\n" +
+        "  POST /predictive/returns/lunar         — Lunar return chart\n" +
+        "  POST /comparative/synastry             — Two-person synastry chart\n" +
+        "  POST /comparative/composite            — Composite (midpoint) chart\n" +
+        "  POST /human-design/chart               — Full HD bodygraph\n" +
+        "  GET  /ephemeris/moon/phase             — Current/queried moon phase\n" +
+        "  GET  /ephemeris/moon/void-of-course    — Next void-of-course period\n" +
+        "  GET  /ephemeris/agro/daily             — Biodynamic farming day quality\n" +
+        "  GET  /ephemeris/agro/calendar          — Multi-day biodynamic calendar\n" +
+        "  GET  /ephemeris/agro/void-of-course    — Biodynamic VoC periods\n" +
+        "  GET  /eclipse/solar/global             — Next global solar eclipse (query: date=YYYY-MM-DD)\n" +
+        "  GET  /eclipse/solar/local              — Local solar eclipse (query: latitude, longitude)\n" +
+        "  GET  /eclipse/next-visible             — Next eclipse visible from a location\n" +
+        "  GET  /tidal/forcing                    — Gravitational tidal forcing index\n" +
+        "  GET  /tidal/forcing/deep-time          — Extended tidal deep-time analysis\n" +
+        "  POST /acg/natal-lines                  — Astrocartography natal lines (lat/lon GeoJSON)\n" +
+        "  POST /acg/hits                         — ACG power at a specific location\n" +
+        "  GET  /calendar/astrology/moon-phases   — Moon phase calendar for a date range\n" +
+        "  GET  /location/autocomplete            — Geocode a place name (query: q=City Name)\n" +
+        "  POST /timezone/lookup                  — Resolve timezone + UTC offset for a location\n" +
+        "  POST /chinese/bazi                     — Chinese Ba Zi (Four Pillars) chart\n" +
+        "  GET  /chinese/zodiac                   — Chinese zodiac year element/animal\n" +
+        "  POST /vedic/chart                      — Vedic (Jyotish) natal chart\n" +
+        "  GET  /catalogs/bodies                  — List all supported celestial bodies\n\n" +
+        "ECLIPSE NOTE: Eclipse endpoints accept format=llm via the query param like other endpoints.\n\n" +
+        "format=llm NOTE: Add query: {format: 'llm'} to natal/synastry/composite/HD endpoints for " +
+        "compact columnar output optimized for LLM token budgets (availability depends on your current plan).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+                enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+                description: "HTTP method",
+            },
+            path: {
+                type: "string",
+                description: "Absolute API path (e.g., /ephemeris/natal-chart)",
+            },
+            query: {
+                type: "object",
+                additionalProperties: true,
+                description: "Query params for GET requests (optional)",
+            },
+            body: {
+                description: "JSON body for POST/PUT/PATCH (optional)",
+            },
+            preset: {
+                type: "string",
+                enum: ["full", "simple"],
+                description: "Convenience: if provided, set query.preset (optional).",
+            },
+            format: {
+                type: "string",
+                enum: ["json", "llm", "llm_v2"],
+                description: "Convenience: if provided, set query.format (optional). 'llm' is canonical; 'llm_v2' is accepted as a legacy alias.",
+            },
+            output_mode: {
+                type: "string",
+                enum: ["full", "simple", "llm", "llm_v2"],
+                description: "Legacy convenience (deprecated): if provided, set query.output_mode and also map to query.preset/query.format when possible.",
+            },
+        },
+        required: ["method", "path"],
+        additionalProperties: false,
+    },
+    handler: async (args) => {
+        const method = String(args.method || "").toUpperCase();
+        const pathname = String(args.path || "");
+        if (!pathname.startsWith("/")) {
+            throw new Error("path must start with '/'");
+        }
+        const allowlist = loadAllowlist();
+        const denyPrefixes = allowlist.deny?.path_prefixes ?? [];
+        if (denyPrefixes.length > 0 && isDeniedByPrefix(pathname, denyPrefixes)) {
+            throw new Error(`Endpoint denied by policy: ${pathname}`);
+        }
+        if (!isAllowedOperation(method, pathname, allowlist.allow)) {
+            throw new Error(`Endpoint not allowlisted: ${method} ${pathname}`);
+        }
+        const queryBase = args.query && typeof args.query === "object" ? args.query : {};
+        const query = { ...queryBase };
+        const body = args.body;
+        if (args.preset) {
+            query.preset = args.preset;
+        }
+        if (args.format) {
+            const rawFormat = String(args.format).trim().toLowerCase();
+            // Canonical: "llm". Normalize legacy alias "llm_v2" → "llm".
+            query.format = rawFormat === "llm_v2" ? "llm" : rawFormat;
+        }
+        // Legacy: output_mode used to overload both compute preset and output projection.
+        // Keep forwarding it for older endpoints, but also map it to preset/format for new endpoints.
+        if (args.output_mode) {
+            const rawMode = String(args.output_mode).trim().toLowerCase();
+            query.output_mode = rawMode;
+            if ((rawMode === "full" || rawMode === "simple") && query.preset == null) {
+                query.preset = rawMode;
+            }
+            if ((rawMode === "llm" || rawMode === "llm_v2") && query.format == null) {
+                query.format = "llm";
+            }
+        }
+        return await backendClient.request(method, pathname, {
+            params: query,
+            data: body,
+        });
+    },
+});
+registerTool({
+    name: "dev.list_allowed",
+    description: "List all API operations (method + path) that this MCP instance is authorized to call. " +
+        "Returns endpoint entries grouped by method, plus the active deny rules. " +
+        "Use this to discover what's available before calling dev.call, or to verify an endpoint path. " +
+        "Typed shortcut tools (ephemeris.natal_chart, ephemeris.transits, etc.) cover the most common operations — " +
+        "check those first before reaching for dev.call.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    },
+    handler: async () => {
+        const allowlist = loadAllowlist();
+        return {
+            schema: allowlist.schema,
+            generated_from: allowlist.generated_from,
+            deny: allowlist.deny ?? null,
+            allow: allowlist.allow,
+            counts: {
+                allow: allowlist.allow.length,
+            },
+        };
+    },
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<any> | Record<string, unknown>;
+    handler: (args: any) => Promise<any>;
+}
+export declare const toolRegistry: Record<string, ToolDefinition>;
+export declare function registerTool(tool: ToolDefinition): void;
+export type ToolProfile = "dev" | "legacy";
+/**
+ * Initializes tool modules.
+ *
+ * - `dev`: registers the allowlist-gated generic call tools AND all specialized
+ *   domain tools (natal chart, transits, moon phase, eclipse, synastry, HD).
+ * - `legacy`: registers only the generic tools (back-compat).
+ */
+export declare function initTools(profile?: ToolProfile): Promise<void>;

package/dist/tools/index.js

@@ -0,0 +1,31 @@
+export const toolRegistry = {};
+export function registerTool(tool) {
+    toolRegistry[tool.name] = tool;
+}
+let toolsInitialized = false;
+/**
+ * Initializes tool modules.
+ *
+ * - `dev`: registers the allowlist-gated generic call tools AND all specialized
+ *   domain tools (natal chart, transits, moon phase, eclipse, synastry, HD).
+ * - `legacy`: registers only the generic tools (back-compat).
+ */
+export async function initTools(profile) {
+    if (toolsInitialized)
+        return;
+    toolsInitialized = true;
+    const resolvedProfile = (profile || process.env.ASTROMCP_PROFILE || "dev").toLowerCase();
+    // Always register the generic proxy tools (dev.call + dev.list_allowed).
+    await import("./dev.js");
+    if (resolvedProfile === "dev") {
+        // Register all specialized domain tools.
+        await import("./specialized/natal.js");
+        await import("./specialized/transits.js");
+        await import("./specialized/moon.js");
+        await import("./specialized/eclipse.js");
+        await import("./specialized/human_design.js");
+        await import("./specialized/synastry.js");
+        await import("./specialized/relocation.js");
+        await import("./specialized/electional.js");
+    }
+}

package/dist/tools/specialized/eclipse.d.ts

@@ -0,0 +1 @@
+export {};