ether-to-astro 1.0.0

package/dist/cli.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { Command, Option } from 'commander';
+import pc from 'picocolors';
+import { loadResolvedProfileFile, ProfileStoreError, resolveProfileSelection, toNatalInput, } from './profile-store.js';
+import { getToolSpec } from './tool-registry.js';
+const E2A_BANNER = `
+███████╗██████╗  █████╗
+██╔════╝╚════██╗██╔══██╗
+█████╗   █████╔╝███████║
+██╔══╝  ██╔═══╝ ██╔══██║
+███████╗███████╗██║  ██║
+╚══════╝╚══════╝╚═╝  ╚═╝
+    ether-to-astro
+`;
+function mustTool(name) {
+    const spec = getToolSpec(name);
+    if (!spec) {
+        throw new Error(`Missing tool specification: ${name}`);
+    }
+    return spec;
+}
+function toolSchemaProperty(toolName, propertyName) {
+    const schema = mustTool(toolName).inputSchema;
+    const prop = schema.properties?.[propertyName];
+    if (!prop) {
+        throw new Error(`Missing schema property: ${toolName}.${propertyName}`);
+    }
+    return prop;
+}
+function toFlag(propertyName) {
+    return propertyName.replaceAll('_', '-');
+}
+function addSchemaOption(command, toolName, propertyName, override) {
+    const prop = toolSchemaProperty(toolName, propertyName);
+    const flag = toFlag(propertyName);
+    const description = prop.description ?? propertyName;
+    const choices = override?.choices ?? prop.enum;
+    if (prop.type === 'boolean') {
+        command.option(`--${flag}`, description);
+        return command;
+    }
+    const valueHint = override?.valueHint ?? 'value';
+    if (choices && choices.length > 0) {
+        command.addOption(new Option(`--${flag} <${valueHint}>`, description).choices(choices));
+        return command;
+    }
+    command.option(`--${flag} <${valueHint}>`, description);
+    return command;
+}
+function toNumber(raw, field) {
+    if (raw == null) {
+        throw new Error(`Missing required argument --${field}`);
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid numeric value for --${field}: ${raw}`);
+    }
+    return parsed;
+}
+async function loadNatalFromFile(path) {
+    const raw = await readFile(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+        name: parsed.name ?? 'CLI User',
+        year: Number(parsed.year),
+        month: Number(parsed.month),
+        day: Number(parsed.day),
+        hour: Number(parsed.hour),
+        minute: Number(parsed.minute),
+        latitude: Number(parsed.latitude),
+        longitude: Number(parsed.longitude),
+        timezone: String(parsed.timezone),
+        house_system: parsed.house_system,
+        birth_time_disambiguation: parsed.birth_time_disambiguation,
+    };
+}
+async function loadPackageMeta() {
+    try {
+        const raw = await readFile(new URL('../package.json', import.meta.url), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function resolveNatalInput(options) {
+    if (options.natalFile) {
+        return loadNatalFromFile(options.natalFile);
+    }
+    return {
+        name: options.name ?? 'CLI User',
+        year: toNumber(options.year, 'year'),
+        month: toNumber(options.month, 'month'),
+        day: toNumber(options.day, 'day'),
+        hour: toNumber(options.hour, 'hour'),
+        minute: toNumber(options.minute, 'minute'),
+        latitude: toNumber(options.latitude, 'latitude'),
+        longitude: toNumber(options.longitude, 'longitude'),
+        timezone: options.timezone ??
+            (() => {
+                throw new Error('Missing required argument --timezone');
+            })(),
+        house_system: options.houseSystem,
+        birth_time_disambiguation: options.birthTimeDisambiguation,
+    };
+}
+function hasInlineNatalInput(options) {
+    return (options.year !== undefined ||
+        options.month !== undefined ||
+        options.day !== undefined ||
+        options.hour !== undefined ||
+        options.minute !== undefined ||
+        options.latitude !== undefined ||
+        options.longitude !== undefined ||
+        options.timezone !== undefined);
+}
+function withProfileOptions(command) {
+    return command
+        .option('--profile <name>', 'Profile name to load from profile file')
+        .option('--profile-file <path>', 'Explicit path to profile file');
+}
+function emit(io, data, text, pretty) {
+    if (pretty) {
+        io.stdout(`${pc.bold(pc.magenta(E2A_BANNER))}\n${text}`);
+        return;
+    }
+    io.stdout(JSON.stringify(data, null, 2));
+}
+function emitExecution(io, result, pretty) {
+    if (result.kind === 'state') {
+        emit(io, result.data, result.text, pretty);
+        return;
+    }
+    const text = result.content
+        .filter((item) => item.type === 'text')
+        .map((item) => item.text)
+        .join('\n');
+    emit(io, { content: result.content }, text, pretty);
+}
+function errorPayload(error) {
+    if (error instanceof ProfileStoreError) {
+        return { code: error.code, message: error.message };
+    }
+    if (typeof error === 'object' && error !== null && 'code' in error && 'message' in error) {
+        const code = error.code;
+        const message = error.message;
+        if (typeof code === 'string' && typeof message === 'string') {
+            return { code, message };
+        }
+    }
+    if (error instanceof Error) {
+        return { code: 'CLI_ERROR', message: error.message };
+    }
+    return { code: 'CLI_ERROR', message: String(error) };
+}
+function commonNatalOptions(command) {
+    withProfileOptions(command);
+    command.option('--natal-file <path>', 'JSON file containing natal inputs');
+    addSchemaOption(command, 'set_natal_chart', 'name', { valueHint: 'name' });
+    addSchemaOption(command, 'set_natal_chart', 'year', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'month', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'day', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'hour', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'minute', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'latitude', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'longitude', { valueHint: 'number' });
+    addSchemaOption(command, 'set_natal_chart', 'timezone', { valueHint: 'tz' });
+    addSchemaOption(command, 'set_natal_chart', 'house_system', { valueHint: 'system' });
+    addSchemaOption(command, 'set_natal_chart', 'birth_time_disambiguation', { valueHint: 'mode' });
+    command.option('--pretty', 'Human-readable output instead of JSON');
+    return command;
+}
+async function withNatalChart(service, options, fn) {
+    let natalInput = null;
+    if (options.natalFile || hasInlineNatalInput(options)) {
+        natalInput = await resolveNatalInput(options);
+    }
+    else {
+        const profileSelection = await resolveProfileSelection({
+            profileName: options.profile,
+            profileFile: options.profileFile,
+        });
+        natalInput = profileSelection ? toNatalInput(profileSelection.profile) : null;
+    }
+    if (!natalInput) {
+        throw new ProfileStoreError('PROFILE_NOT_FOUND', 'No natal context resolved. Provide natal fields, --natal-file, or --profile.');
+    }
+    const setNatal = mustTool('set_natal_chart');
+    const result = await setNatal.execute({ service, natalChart: null }, natalInput);
+    if (result.kind !== 'state' || !result.natalChart) {
+        throw new Error('set_natal_chart did not return a natal chart');
+    }
+    await fn(result.natalChart, options.pretty ?? false);
+}
+async function resolveCommandTimezone(options) {
+    if (options.timezone) {
+        return options.timezone;
+    }
+    const explicitProfileRequested = Boolean(options.profile ||
+        options.profileFile ||
+        process.env.ASTRO_PROFILE ||
+        process.env.ASTRO_PROFILE_FILE);
+    try {
+        const profileSelection = await resolveProfileSelection({
+            profileName: options.profile,
+            profileFile: options.profileFile,
+        });
+        return profileSelection?.profile.timezone ?? 'UTC';
+    }
+    catch (error) {
+        if (error instanceof ProfileStoreError && !explicitProfileRequested) {
+            return 'UTC';
+        }
+        throw error;
+    }
+}
+function emitCliError(io, pretty, err) {
+    const payload = errorPayload(err);
+    if (pretty) {
+        io.stderr(pc.red(payload.message));
+    }
+    else {
+        io.stderr(JSON.stringify(payload, null, 2));
+    }
+    return 1;
+}
+export async function runCli(argv, io = {
+    stdout: (msg) => console.log(msg),
+    stderr: (msg) => console.error(msg),
+}) {
+    globalThis.self ??= globalThis;
+    const { AstroService } = await import('./astro-service.js');
+    const service = new AstroService();
+    await service.init();
+    const pkg = await loadPackageMeta();
+    const program = new Command();
+    const isHelpInvocation = argv.includes('--help') || argv.includes('-h');
+    if (isHelpInvocation) {
+        io.stdout(pc.bold(pc.magenta(E2A_BANNER)));
+    }
+    program
+        .name('e2a')
+        .description(pkg.description ?? 'Single-shot astrology CLI (JSON-first, stateless)')
+        .version(pkg.version ?? '0.0.0', '-v, --version', 'Show package version')
+        .showHelpAfterError('(add --help for more details)')
+        .configureOutput({
+        writeErr: (str) => io.stderr(str.trimEnd()),
+        writeOut: (str) => {
+            const spaced = str.replace(/\n( {2}[\w-]+(?: \[[^\]]+\])?\s{2,})/g, '\n\n$1');
+            io.stdout(spaced.trimEnd());
+        },
+    });
+    commonNatalOptions(program.command('set-natal-chart').description(mustTool('set_natal_chart').description)).action(async (options) => {
+        const setNatal = mustTool('set_natal_chart');
+        const profileSelection = options.natalFile || hasInlineNatalInput(options)
+            ? null
+            : await resolveProfileSelection({
+                profileName: options.profile,
+                profileFile: options.profileFile,
+            });
+        const natalInput = options.natalFile || hasInlineNatalInput(options)
+            ? await resolveNatalInput(options)
+            : profileSelection
+                ? toNatalInput(profileSelection.profile)
+                : (() => {
+                    throw new ProfileStoreError('PROFILE_NOT_FOUND', 'No natal context resolved. Provide natal fields, --natal-file, or --profile.');
+                })();
+        const result = await setNatal.execute({ service, natalChart: null }, natalInput);
+        emitExecution(io, result, options.pretty ?? false);
+    });
+    program
+        .command('get-retrograde-planets')
+        .description(mustTool('get_retrograde_planets').description)
+        .option('--timezone <tz>', 'Timezone label for output')
+        .option('--profile <name>', 'Profile name to load from profile file')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const spec = mustTool('get_retrograde_planets');
+        const timezone = await resolveCommandTimezone(options);
+        const result = await spec.execute({ service, natalChart: null }, { timezone });
+        emitExecution(io, result, options.pretty ?? false);
+    });
+    program
+        .command('get-asteroid-positions')
+        .description(mustTool('get_asteroid_positions').description)
+        .option('--timezone <tz>', 'Timezone label for output')
+        .option('--profile <name>', 'Profile name to load from profile file')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const spec = mustTool('get_asteroid_positions');
+        const timezone = await resolveCommandTimezone(options);
+        const result = await spec.execute({ service, natalChart: null }, { timezone });
+        emitExecution(io, result, options.pretty ?? false);
+    });
+    program
+        .command('get-next-eclipses')
+        .description(mustTool('get_next_eclipses').description)
+        .option('--timezone <tz>', 'Timezone label for output')
+        .option('--profile <name>', 'Profile name to load from profile file')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const spec = mustTool('get_next_eclipses');
+        const timezone = await resolveCommandTimezone(options);
+        const result = await spec.execute({ service, natalChart: null }, { timezone });
+        emitExecution(io, result, options.pretty ?? false);
+    });
+    const profiles = program
+        .command('profiles')
+        .description('Inspect and validate CLI profile files');
+    profiles
+        .command('list')
+        .description('List available profiles')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const { filePath, file } = await loadResolvedProfileFile({
+            profileFile: options.profileFile,
+        });
+        const names = Object.keys(file.profiles).sort();
+        const data = {
+            filePath,
+            defaultProfile: file.defaultProfile ?? null,
+            profiles: names,
+        };
+        const text = names.length === 0
+            ? `No profiles found in ${filePath}`
+            : `Profiles in ${filePath}:\n- ${names.join('\n- ')}`;
+        emit(io, data, text, options.pretty ?? false);
+    });
+    profiles
+        .command('show')
+        .description('Show a profile')
+        .requiredOption('--profile <name>', 'Profile name to show')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const { filePath, file } = await loadResolvedProfileFile({
+            profileFile: options.profileFile,
+        });
+        const profileName = options.profile;
+        const profile = file.profiles[profileName];
+        if (!profile) {
+            throw new ProfileStoreError('PROFILE_NOT_FOUND', `Profile "${profileName}" not found in ${filePath}`);
+        }
+        const data = {
+            filePath,
+            profileName,
+            profile,
+        };
+        const text = `Profile "${profileName}" from ${filePath}`;
+        emit(io, data, text, options.pretty ?? false);
+    });
+    profiles
+        .command('validate')
+        .description('Validate profile file schema')
+        .option('--profile-file <path>', 'Explicit path to profile file')
+        .option('--pretty', 'Human-readable output instead of JSON')
+        .action(async (options) => {
+        const { filePath, file } = await loadResolvedProfileFile({
+            profileFile: options.profileFile,
+        });
+        const data = {
+            valid: true,
+            filePath,
+            profileCount: Object.keys(file.profiles).length,
+            defaultProfile: file.defaultProfile ?? null,
+        };
+        const text = `Profile file is valid: ${filePath}`;
+        emit(io, data, text, options.pretty ?? false);
+    });
+    commonNatalOptions(program.command('get-transits').description(mustTool('get_transits').description))
+        .option('--date <yyyy-mm-dd>', toolSchemaProperty('get_transits', 'date').description ?? 'Date for transits')
+        .option('--categories <list>', toolSchemaProperty('get_transits', 'categories').description ?? 'Categories')
+        .option('--include-mundane', toolSchemaProperty('get_transits', 'include_mundane').description ??
+        'Include mundane positions')
+        .option('--days-ahead <number>', toolSchemaProperty('get_transits', 'days_ahead').description ?? 'Days ahead')
+        .option('--max-orb <number>', toolSchemaProperty('get_transits', 'max_orb').description ?? 'Max orb')
+        .option('--exact-only', toolSchemaProperty('get_transits', 'exact_only').description ?? 'Exact only')
+        .option('--applying-only', toolSchemaProperty('get_transits', 'applying_only').description ?? 'Applying only')
+        .action(async (options) => {
+        await withNatalChart(service, options, async (chart, pretty) => {
+            const categories = options.categories
+                ?.split(',')
+                .map((v) => v.trim())
+                .filter(Boolean);
+            const input = {
+                date: options.date,
+                categories,
+                include_mundane: options.includeMundane,
+                days_ahead: options.daysAhead == null ? undefined : toNumber(options.daysAhead, 'days-ahead'),
+                max_orb: options.maxOrb == null ? undefined : toNumber(options.maxOrb, 'max-orb'),
+                exact_only: options.exactOnly,
+                applying_only: options.applyingOnly,
+            };
+            const spec = mustTool('get_transits');
+            const result = await spec.execute({ service, natalChart: chart }, input);
+            emitExecution(io, result, pretty);
+        });
+    });
+    commonNatalOptions(program.command('get-houses').description(mustTool('get_houses').description))
+        .addOption(new Option('--system <system>', toolSchemaProperty('get_houses', 'system').description ?? 'House system override').choices(['P', 'W', 'K', 'E']))
+        .action(async (options) => {
+        await withNatalChart(service, options, async (chart, pretty) => {
+            const spec = mustTool('get_houses');
+            const result = await spec.execute({ service, natalChart: chart }, { system: options.system ?? options.houseSystem });
+            emitExecution(io, result, pretty);
+        });
+    });
+    commonNatalOptions(program.command('get-rise-set-times').description(mustTool('get_rise_set_times').description)).action(async (options) => {
+        await withNatalChart(service, options, async (chart, pretty) => {
+            const spec = mustTool('get_rise_set_times');
+            const result = await spec.execute({ service, natalChart: chart }, {});
+            emitExecution(io, result, pretty);
+        });
+    });
+    commonNatalOptions(program
+        .command('generate-natal-chart')
+        .description(mustTool('generate_natal_chart').description))
+        .addOption(new Option('--theme <theme>', toolSchemaProperty('generate_natal_chart', 'theme').description ?? 'Chart theme').choices(['light', 'dark']))
+        .addOption(new Option('--format <format>', toolSchemaProperty('generate_natal_chart', 'format').description ?? 'Output format')
+        .choices(['svg', 'png', 'webp'])
+        .default('svg'))
+        .option('--output-path <path>', toolSchemaProperty('generate_natal_chart', 'output_path').description ?? 'Output path')
+        .action(async (options) => {
+        await withNatalChart(service, options, async (chart, pretty) => {
+            const spec = mustTool('generate_natal_chart');
+            const result = await spec.execute({ service, natalChart: chart }, {
+                theme: options.theme,
+                format: options.format,
+                output_path: options.outputPath,
+            });
+            emitExecution(io, result, pretty);
+        });
+    });
+    commonNatalOptions(program
+        .command('generate-transit-chart')
+        .description(mustTool('generate_transit_chart').description))
+        .option('--date <yyyy-mm-dd>', toolSchemaProperty('generate_transit_chart', 'date').description ?? 'Transit date')
+        .addOption(new Option('--theme <theme>', toolSchemaProperty('generate_transit_chart', 'theme').description ?? 'Chart theme').choices(['light', 'dark']))
+        .addOption(new Option('--format <format>', toolSchemaProperty('generate_transit_chart', 'format').description ?? 'Output format')
+        .choices(['svg', 'png', 'webp'])
+        .default('svg'))
+        .option('--output-path <path>', toolSchemaProperty('generate_transit_chart', 'output_path').description ?? 'Output path')
+        .action(async (options) => {
+        await withNatalChart(service, options, async (chart, pretty) => {
+            const spec = mustTool('generate_transit_chart');
+            const result = await spec.execute({ service, natalChart: chart }, {
+                date: options.date,
+                theme: options.theme,
+                format: options.format,
+                output_path: options.outputPath,
+            });
+            emitExecution(io, result, pretty);
+        });
+    });
+    try {
+        await program.parseAsync(argv, { from: 'user' });
+        return 0;
+    }
+    catch (err) {
+        return emitCliError(io, argv.includes('--pretty'), err);
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runCli(process.argv.slice(2)).then((code) => {
+        process.exit(code);
+    });
+}

package/dist/constants.d.ts

@@ -0,0 +1,81 @@
+export declare const LogLevel: {
+    readonly DEBUG: "DEBUG";
+    readonly INFO: "INFO";
+    readonly WARN: "WARN";
+    readonly ERROR: "ERROR";
+};
+export type LogLevelType = (typeof LogLevel)[keyof typeof LogLevel];
+export declare const ErrorCategory: {
+    readonly EPHEMERIS: "EPHEMERIS";
+    readonly CALCULATION: "CALCULATION";
+    readonly STORAGE: "STORAGE";
+    readonly VALIDATION: "VALIDATION";
+    readonly CHART_RENDERING: "CHART_RENDERING";
+    readonly SERVER: "SERVER";
+};
+export type ErrorCategoryType = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+export declare const LIGHT_THEME_COLORS: string[];
+export declare const DARK_THEME_COLORS: string[];
+export declare const LIGHT_ASPECT_COLORS: {
+    conjunction: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    square: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    trine: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    opposition: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    sextile: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+};
+export declare const DARK_ASPECT_COLORS: {
+    conjunction: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    square: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    trine: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    opposition: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+    sextile: {
+        degree: number;
+        orbit: number;
+        color: string;
+    };
+};
+/**
+ * Determine chart theme based on time of day
+ * Dark theme: 6 PM - 6 AM (18:00 - 06:00)
+ * Light theme: 6 AM - 6 PM (06:00 - 18:00)
+ *
+ * @param timezone - Optional IANA timezone to use (e.g., 'America/New_York'). Defaults to server local time.
+ * @returns 'dark' or 'light' theme
+ */
+export declare function getDefaultTheme(timezone?: string): 'light' | 'dark';

package/dist/constants.js

@@ -0,0 +1,76 @@
+// Log levels
+export const LogLevel = {
+    DEBUG: 'DEBUG',
+    INFO: 'INFO',
+    WARN: 'WARN',
+    ERROR: 'ERROR',
+};
+// Error categories
+export const ErrorCategory = {
+    EPHEMERIS: 'EPHEMERIS',
+    CALCULATION: 'CALCULATION',
+    STORAGE: 'STORAGE',
+    VALIDATION: 'VALIDATION',
+    CHART_RENDERING: 'CHART_RENDERING',
+    SERVER: 'SERVER',
+};
+// Chart theme colors
+export const LIGHT_THEME_COLORS = [
+    '#ffffff', // Aries - White (fire)
+    '#c1e6d1', // Taurus - Mint (earth)
+    '#ffffff', // Gemini - White (air)
+    '#c1e6d1', // Cancer - Mint (water)
+    '#ffffff', // Leo - White (fire)
+    '#c1e6d1', // Virgo - Mint (earth)
+    '#ffffff', // Libra - White (air)
+    '#c1e6d1', // Scorpio - Mint (water)
+    '#ffffff', // Sagittarius - White (fire)
+    '#c1e6d1', // Capricorn - Mint (earth)
+    '#ffffff', // Aquarius - White (air)
+    '#c1e6d1', // Pisces - Mint (water)
+];
+export const DARK_THEME_COLORS = [
+    '#282c34', // Aries - Dark (fire)
+    '#8545b0', // Taurus - Purple (earth)
+    '#282c34', // Gemini - Dark (air)
+    '#8545b0', // Cancer - Purple (water)
+    '#282c34', // Leo - Dark (fire)
+    '#8545b0', // Virgo - Purple (earth)
+    '#282c34', // Libra - Dark (air)
+    '#8545b0', // Scorpio - Purple (water)
+    '#282c34', // Sagittarius - Dark (fire)
+    '#8545b0', // Capricorn - Purple (earth)
+    '#282c34', // Aquarius - Dark (air)
+    '#8545b0', // Pisces - Purple (water)
+];
+// Aspect colors for light theme
+export const LIGHT_ASPECT_COLORS = {
+    conjunction: { degree: 0, orbit: 10, color: 'transparent' },
+    square: { degree: 90, orbit: 8, color: '#fb923c' }, // Orange
+    trine: { degree: 120, orbit: 8, color: '#34d399' }, // Emerald
+    opposition: { degree: 180, orbit: 10, color: '#a78bfa' }, // Purple
+    sextile: { degree: 60, orbit: 6, color: '#22d3ee' }, // Cyan
+};
+// Aspect colors for dark theme
+export const DARK_ASPECT_COLORS = {
+    conjunction: { degree: 0, orbit: 10, color: 'transparent' },
+    square: { degree: 90, orbit: 8, color: '#f97316' }, // Orange
+    trine: { degree: 120, orbit: 8, color: '#10b981' }, // Emerald
+    opposition: { degree: 180, orbit: 10, color: '#8b5cf6' }, // Purple
+    sextile: { degree: 60, orbit: 6, color: '#06b6d4' }, // Cyan
+};
+/**
+ * Determine chart theme based on time of day
+ * Dark theme: 6 PM - 6 AM (18:00 - 06:00)
+ * Light theme: 6 AM - 6 PM (06:00 - 18:00)
+ *
+ * @param timezone - Optional IANA timezone to use (e.g., 'America/New_York'). Defaults to server local time.
+ * @returns 'dark' or 'light' theme
+ */
+export function getDefaultTheme(timezone) {
+    const now = new Date();
+    const hour = timezone
+        ? Number.parseInt(now.toLocaleString('en-US', { timeZone: timezone, hour: '2-digit', hour12: false }), 10)
+        : now.getHours();
+    return hour >= 18 || hour < 6 ? 'dark' : 'light';
+}