ether-to-astro 1.0.2 → 1.2.0

package/tests/unit/cli-commands.test.ts

@@ -25,6 +25,19 @@ describe.sequential('When exercising CLI command handlers end-to-end', () => {
       ['get-retrograde-planets'],
       ['get-asteroid-positions'],
       ['get-next-eclipses'],
+      [
+        'get-electional-context',
+        '--date',
+        '2026-03-28',
+        '--time',
+        '09:30',
+        '--timezone',
+        'America/Los_Angeles',
+        '--latitude',
+        '37.7749',
+        '--longitude',
+        '-122.4194',
+      ],
       ['get-transits', ...natalArgs, '--categories', 'all', '--days-ahead', '1', '--max-orb', '5'],
       ['get-houses', ...natalArgs, '--system', 'W'],
       ['get-rise-set-times', ...natalArgs],

package/tests/unit/entrypoint.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { resolveEntrypoint } from '../../src/entrypoint.js';
+
+describe('When resolving unified binary entrypoint mode', () => {
+  it('Given the e2a binary with no startup flags, then CLI mode receives the original argv', () => {
+    const resolved = resolveEntrypoint(['get-next-eclipses'], '/usr/local/bin/e2a');
+    expect(resolved.mode).toBe('cli');
+    expect(resolved.cliArgv).toEqual(['get-next-eclipses']);
+    expect(resolved.mcpHelpRequested).toBe(false);
+    expect(resolved.mcpStartupDefaults).toEqual({});
+  });
+
+  it('Given e2a --mcp with startup defaults, then MCP mode is selected and defaults are parsed', () => {
+    const resolved = resolveEntrypoint(
+      [
+        '--mcp',
+        '--preferred-tz',
+        'America/Los_Angeles',
+        '--preferred-house-style=W',
+        '--weekday-labels',
+      ],
+      '/usr/local/bin/e2a'
+    );
+    expect(resolved.mode).toBe('mcp');
+    expect(resolved.cliArgv).toEqual([]);
+    expect(resolved.mcpHelpRequested).toBe(false);
+    expect(resolved.mcpStartupDefaults).toEqual({
+      preferredTimezone: 'America/Los_Angeles',
+      preferredHouseStyle: 'W',
+      weekdayLabels: true,
+    });
+  });
+
+  it('Given the compatibility alias, then MCP mode is selected without --mcp', () => {
+    const resolved = resolveEntrypoint(['--preferred-tz', 'UTC'], '/usr/local/bin/e2a-mcp');
+    expect(resolved.mode).toBe('mcp');
+    expect(resolved.mcpHelpRequested).toBe(false);
+    expect(resolved.mcpStartupDefaults).toEqual({
+      preferredTimezone: 'UTC',
+    });
+  });
+
+  it('Given MCP mode help flags, then help is allowed without treating them as CLI args', () => {
+    const resolved = resolveEntrypoint(['--mcp', '--help'], '/usr/local/bin/e2a');
+    expect(resolved.mode).toBe('mcp');
+    expect(resolved.mcpHelpRequested).toBe(true);
+    expect(resolved.cliArgv).toEqual(['--help']);
+  });
+
+  it('Given MCP-only flags outside MCP mode, then resolution fails clearly', () => {
+    expect(() =>
+      resolveEntrypoint(['get-next-eclipses', '--preferred-tz', 'UTC'], '/usr/local/bin/e2a')
+    ).toThrow(/MCP startup defaults require MCP mode/);
+  });
+
+  it('Given invalid startup defaults or CLI args in MCP mode, then resolution fails clearly', () => {
+    expect(() =>
+      resolveEntrypoint(['--mcp', '--preferred-house-style', 'Q'], '/usr/local/bin/e2a')
+    ).toThrow(/Invalid preferred house style/);
+    expect(() =>
+      resolveEntrypoint(['--mcp', '--preferred-tz', 'Nope/Bad'], '/usr/local/bin/e2a')
+    ).toThrow(/Invalid timezone/);
+    expect(() =>
+      resolveEntrypoint(['--mcp', 'get-next-eclipses'], '/usr/local/bin/e2a')
+    ).toThrow(/Unexpected CLI arguments in MCP mode/);
+  });
+});

package/tests/unit/error-mapping.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { mapToolErrorMessageToCode } from '../../src/tool-result.js';
+
+describe('mapToolErrorMessageToCode', () => {
+  it('maps rising-sign mode and coordinates validation failures to INVALID_INPUT', () => {
+    expect(mapToolErrorMessageToCode('Invalid mode: fast')).toBe('INVALID_INPUT');
+    expect(mapToolErrorMessageToCode('Invalid latitude: 95 (must be between -90 and 90)')).toBe(
+      'INVALID_INPUT'
+    );
+    expect(
+      mapToolErrorMessageToCode('Invalid longitude: -190 (must be between -180 and 180)')
+    ).toBe('INVALID_INPUT');
+  });
+
+  it('preserves existing timezone classification', () => {
+    expect(mapToolErrorMessageToCode('Invalid timezone: Nope/Not-A-Timezone')).toBe(
+      'INVALID_TIMEZONE'
+    );
+  });
+});

package/tests/unit/formatter.test.ts

@@ -26,4 +26,10 @@ describe('When formatting timestamps for users', () => {
     expect(ny).toMatch(/AM|PM/);
     expect(la).toMatch(/AM|PM/);
   });
+
+  it('Given weekday formatting is requested, then output includes a weekday label', () => {
+    const date = new Date('2024-03-20T12:00:00Z');
+    const formatted = formatInTimezone(date, 'America/New_York', { weekday: true });
+    expect(formatted).toMatch(/\b(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\b/);
+  });
 });

package/tests/unit/tool-registry.test.ts

@@ -4,8 +4,13 @@ import { createToolSpecIndex, getToolSpec, MCP_TOOL_SPECS } from '../../src/tool
 function makeService() {
   return {
     setNatalChart: vi.fn(() => ({ data: { ok: true }, text: 'set', chart: { name: 'x' } })),
+    getRisingSignWindows: vi.fn(() => ({ data: { windows: [] }, text: 'rising windows' })),
+    getElectionalContext: vi.fn(() => ({ data: { ascendant: {} }, text: 'electional' })),
     getTransits: vi.fn(() => ({ data: { transits: [] }, text: 'transits' })),
     getHouses: vi.fn(() => ({ data: { system: 'P' }, text: 'houses' })),
+    resolveReportingTimezone: vi.fn((explicit?: string, natal?: string) => {
+      return explicit ?? 'America/New_York' ?? natal ?? 'UTC';
+    }),
     getRetrogradePlanets: vi.fn(() => ({ data: { planets: [] }, text: 'retro' })),
     getRiseSetTimes: vi.fn(async () => ({ data: { times: [] }, text: 'rise' })),
     getAsteroidPositions: vi.fn(() => ({ data: { positions: [] }, text: 'asteroids' })),
@@ -47,6 +52,35 @@ describe('When resolving tool specs from the registry', () => {
     }
   });
 
+
+  it('Given get_transits args, then execute forwards mundane and filter options to service', async () => {
+    const service = makeService();
+    const ctx = { service: service as any, natalChart: { name: 'chart' } as any };
+
+    const spec = getToolSpec('get_transits');
+    expect(spec).toBeDefined();
+
+    await spec!.execute(ctx, {
+      include_mundane: true,
+      days_ahead: 3,
+      max_orb: 5,
+      exact_only: true,
+      applying_only: true,
+      categories: ['outer'],
+      date: '2026-01-02',
+    });
+
+    expect(service.getTransits).toHaveBeenCalledWith(ctx.natalChart, {
+      include_mundane: true,
+      days_ahead: 3,
+      max_orb: 5,
+      exact_only: true,
+      applying_only: true,
+      categories: ['outer'],
+      date: '2026-01-02',
+    });
+  });
+
   it('Given simple state tools, then calls route to matching service methods', async () => {
     const service = makeService();
     const ctx = { service: service as any, natalChart: { name: 'chart' } as any };
@@ -58,6 +92,60 @@ describe('When resolving tool specs from the registry', () => {
     expect(service.getServerStatus).toHaveBeenCalled();
   });
 
+  it('Given rising-sign window arguments, then tool routes to the shared service with deterministic shape', async () => {
+    const service = makeService();
+    const result = await getToolSpec('get_rising_sign_windows')!.execute(
+      { service: service as any, natalChart: null },
+      {
+        date: '2026-03-28',
+        latitude: 40.7128,
+        longitude: -74.006,
+        timezone: 'America/New_York',
+        mode: 'exact',
+      }
+    );
+
+    expect(result.kind).toBe('state');
+    expect(service.getRisingSignWindows).toHaveBeenCalledWith({
+      date: '2026-03-28',
+      latitude: 40.7128,
+      longitude: -74.006,
+      timezone: 'America/New_York',
+      mode: 'exact',
+    });
+  });
+
+  it('Given get_electional_context args, then the stateless tool forwards them without natal state', async () => {
+    const service = makeService();
+    const result = await getToolSpec('get_electional_context')!.execute(
+      { service: service as any, natalChart: null },
+      {
+        date: '2026-03-28',
+        time: '09:30',
+        timezone: 'America/Los_Angeles',
+        latitude: 37.7749,
+        longitude: -122.4194,
+        house_system: 'R',
+        include_ruler_basics: true,
+        include_planetary_applications: false,
+        orb_degrees: 2.5,
+      }
+    );
+
+    expect(result.kind).toBe('state');
+    expect(service.getElectionalContext).toHaveBeenCalledWith({
+      date: '2026-03-28',
+      time: '09:30',
+      timezone: 'America/Los_Angeles',
+      latitude: 37.7749,
+      longitude: -122.4194,
+      house_system: 'R',
+      include_ruler_basics: true,
+      include_planetary_applications: false,
+      orb_degrees: 2.5,
+    });
+  });
+
   it('Given async state tool handlers, then they resolve to state payloads', async () => {
     const service = makeService();
     const ctx = { service: service as any, natalChart: { name: 'chart' } as any };
@@ -176,6 +264,27 @@ describe('When resolving tool specs from the registry', () => {
     expect(required.has('get_rise_set_times')).toBe(true);
     expect(required.has('generate_natal_chart')).toBe(true);
     expect(required.has('generate_transit_chart')).toBe(true);
+    expect(required.has('get_rising_sign_windows')).toBe(false);
+    expect(required.has('get_electional_context')).toBe(false);
+  });
+
+  it('Given get_transits schema and execution, then mode semantics are exposed and forwarded', async () => {
+    const spec = getToolSpec('get_transits');
+    expect(spec).toBeDefined();
+    const modeProp = spec?.inputSchema.properties?.mode as any;
+    expect(modeProp?.enum).toEqual(['snapshot', 'best_hit', 'forecast']);
+    expect(modeProp?.default).toBeUndefined();
+    expect(modeProp?.description).toContain('If omitted, legacy behavior is preserved');
+
+    const service = makeService();
+    await spec!.execute(
+      { service: service as any, natalChart: { name: 'chart' } as any },
+      { mode: 'forecast' }
+    );
+    expect(service.getTransits).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ mode: 'forecast' })
+    );
   });
 
   it('Given chart tools return no payload, then execution throws explicit errors', async () => {
@@ -215,8 +324,11 @@ describe('When resolving tool specs from the registry', () => {
       { timezone: 'UTC' }
     );
 
-    expect(service.getRetrogradePlanets).toHaveBeenCalledWith('Asia/Tokyo');
-    expect(service.getAsteroidPositions).toHaveBeenCalledWith('UTC');
+    expect(service.resolveReportingTimezone).toHaveBeenCalledWith(undefined, 'Asia/Tokyo');
+    expect(service.resolveReportingTimezone).toHaveBeenCalledWith(undefined, undefined);
+    expect(service.resolveReportingTimezone).toHaveBeenCalledWith('UTC', 'America/New_York');
+    expect(service.getRetrogradePlanets).toHaveBeenCalledWith('America/New_York');
+    expect(service.getAsteroidPositions).toHaveBeenCalledWith('America/New_York');
     expect(service.getNextEclipses).toHaveBeenCalledWith('UTC');
   });
 });

package/setup.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-
-echo "Setting up Astro MCP Server..."
-
-echo "Installing npm dependencies..."
-npm install
-
-echo "Building TypeScript..."
-npm run build
-
-echo ""
-echo "✅ Setup complete!"
-echo ""
-echo "The server uses WebAssembly Swiss Ephemeris - no data files needed!"
-echo ""
-echo "Next steps:"
-echo "1. Add this server to your MCP settings"
-echo "2. Use set_natal_chart to store birth data"
-echo "3. Query transits with your AI agent"
-echo ""
-echo "See README.md for detailed usage instructions."