chart2txt 0.7.0 → 0.8.0

package/dist/core/orbResolver.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrbResolver = void 0;
+const types_1 = require("../types");
+/**
+ * Default planet categorization mapping
+ */
+const DEFAULT_PLANET_MAPPING = {
+    Sun: types_1.PlanetCategory.Luminaries,
+    Moon: types_1.PlanetCategory.Luminaries,
+    Mercury: types_1.PlanetCategory.Personal,
+    Venus: types_1.PlanetCategory.Personal,
+    Mars: types_1.PlanetCategory.Personal,
+    Jupiter: types_1.PlanetCategory.Social,
+    Saturn: types_1.PlanetCategory.Social,
+    Uranus: types_1.PlanetCategory.Outer,
+    Neptune: types_1.PlanetCategory.Outer,
+    Pluto: types_1.PlanetCategory.Outer,
+    Ascendant: types_1.PlanetCategory.Angles,
+    Midheaven: types_1.PlanetCategory.Angles,
+    MC: types_1.PlanetCategory.Angles,
+    ASC: types_1.PlanetCategory.Angles,
+};
+/**
+ * Resolves orbs using hierarchical rules with caching for performance
+ */
+class OrbResolver {
+    constructor(orbConfiguration = {}) {
+        this.orbCache = new Map();
+        this.orbConfiguration = orbConfiguration;
+        this.planetMapping = {
+            ...DEFAULT_PLANET_MAPPING,
+            ...orbConfiguration.planetMapping,
+        };
+    }
+    /**
+     * Resolves the appropriate orb for a given context
+     */
+    resolveOrb(context) {
+        const cacheKey = this.generateCacheKey(context);
+        // Check cache first
+        if (this.orbCache.has(cacheKey)) {
+            return this.orbCache.get(cacheKey);
+        }
+        const orb = this.calculateOrb(context);
+        this.orbCache.set(cacheKey, orb);
+        return orb;
+    }
+    /**
+     * Clears the orb cache (useful when configuration changes)
+     */
+    clearCache() {
+        this.orbCache.clear();
+    }
+    /**
+     * Gets the planet category for a given planet name
+     */
+    getPlanetCategory(planetName) {
+        return this.planetMapping[planetName];
+    }
+    calculateOrb(context) {
+        let baseOrb = this.getBaseOrb(context);
+        // Apply aspect classification multipliers
+        baseOrb = this.applyClassificationMultipliers(baseOrb, context.aspect);
+        // Apply contextual multipliers (synastry, transit, etc.)
+        baseOrb = this.applyContextualMultipliers(baseOrb, context);
+        // Ensure minimum constraints
+        baseOrb = this.applyConstraints(baseOrb, context.aspect);
+        // Round to reasonable precision
+        return Math.round(baseOrb * 10) / 10;
+    }
+    getBaseOrb(context) {
+        const planetAName = typeof context.planetA === 'string'
+            ? context.planetA
+            : context.planetA.name;
+        const planetBName = typeof context.planetB === 'string'
+            ? context.planetB
+            : context.planetB.name;
+        // Try to get planet-specific orbs
+        const orbA = this.getPlanetSpecificOrb(planetAName, context.aspect);
+        const orbB = this.getPlanetSpecificOrb(planetBName, context.aspect);
+        // Use the larger of the two planet-specific orbs, or aspect default
+        if (orbA !== null && orbB !== null) {
+            return Math.max(orbA, orbB);
+        }
+        else if (orbA !== null) {
+            return orbA;
+        }
+        else if (orbB !== null) {
+            return orbB;
+        }
+        // Fall back to aspect's default orb
+        return context.aspect.orb;
+    }
+    getPlanetSpecificOrb(planetName, aspect) {
+        const planetCategory = this.getPlanetCategory(planetName);
+        if (!planetCategory)
+            return null;
+        const categoryRules = this.orbConfiguration.planetCategories?.[planetCategory];
+        if (!categoryRules)
+            return null;
+        // Try aspect-specific orb first
+        const aspectOrb = categoryRules.aspectOrbs?.[aspect.name];
+        if (aspectOrb !== undefined)
+            return aspectOrb;
+        // Fall back to category default orb
+        return categoryRules.defaultOrb ?? null;
+    }
+    applyClassificationMultipliers(orb, aspect) {
+        if (!aspect.classification)
+            return orb;
+        const classificationRules = this.orbConfiguration.aspectClassification?.[aspect.classification];
+        if (!classificationRules?.orbMultiplier)
+            return orb;
+        return orb * classificationRules.orbMultiplier;
+    }
+    applyContextualMultipliers(orb, context) {
+        if (!context.chartType || context.chartType === 'natal')
+            return orb;
+        // Map 'transit' to 'transits' for the configuration key
+        const configKey = context.chartType === 'transit' ? 'transits' : context.chartType;
+        const contextRules = this.orbConfiguration.contextualOrbs?.[configKey];
+        if (!contextRules)
+            return orb;
+        // Apply aspect-specific multiplier if available
+        const aspectMultiplier = contextRules.aspectMultipliers?.[context.aspect.name];
+        if (aspectMultiplier) {
+            return orb * aspectMultiplier;
+        }
+        // Fall back to general multiplier
+        if (contextRules.orbMultiplier) {
+            return orb * contextRules.orbMultiplier;
+        }
+        return orb;
+    }
+    applyConstraints(orb, aspect) {
+        const classificationRules = aspect.classification
+            ? this.orbConfiguration.aspectClassification?.[aspect.classification]
+            : undefined;
+        let constrainedOrb = orb;
+        // Apply minimum constraint
+        const minOrb = classificationRules?.minOrb;
+        if (minOrb !== undefined && constrainedOrb < minOrb) {
+            constrainedOrb = minOrb;
+        }
+        // Apply maximum constraint
+        const maxOrb = classificationRules?.maxOrb;
+        if (maxOrb !== undefined && constrainedOrb > maxOrb) {
+            constrainedOrb = maxOrb;
+        }
+        // Global fallback if somehow orb is still invalid
+        if (constrainedOrb <= 0) {
+            constrainedOrb = this.orbConfiguration.globalFallbackOrb ?? 3;
+        }
+        return constrainedOrb;
+    }
+    generateCacheKey(context) {
+        const planetAName = typeof context.planetA === 'string'
+            ? context.planetA
+            : context.planetA.name;
+        const planetBName = typeof context.planetB === 'string'
+            ? context.planetB
+            : context.planetB.name;
+        return `${planetAName}-${planetBName}-${context.aspect.name}-${context.chartType || 'natal'}`;
+    }
+}
+exports.OrbResolver = OrbResolver;

package/dist/core/signDistributions.js

@@ -35,16 +35,19 @@ function calculateSignDistributions(planets, ascendant) {
     return { elements, modalities, polarities };
 }
 function formatElementDistribution(elements) {
-    return Object.entries(elements).map(([element, planets]) => {
+    const parts = Object.entries(elements).map(([element, planets]) => {
         if (planets.length === 0) {
             return `${element}: 0`;
         }
         return `${element}: ${planets.length} (${planets.join(', ')})`;
     });
+    return [parts.join(' | ')];
 }
 function formatModalityDistribution(modalities) {
-    return Object.entries(modalities).map(([modality, count]) => `${modality}: ${count}`);
+    const parts = Object.entries(modalities).map(([modality, count]) => `${modality}: ${count}`);
+    return [parts.join(' | ')];
 }
 function formatPolarityDistribution(polarities) {
-    return Object.entries(polarities).map(([polarity, count]) => `${polarity}: ${count}`);
+    const parts = Object.entries(polarities).map(([polarity, count]) => `${polarity}: ${count}`);
+    return [parts.join(' | ')];
 }

package/dist/formatters/text/sections/dispositors.d.ts

@@ -1,6 +1,6 @@
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param dispositors A map of planet names to their full dispositor chain string.
+ * @param dispositors A map of planet names to their full dispositor chain string, or summary data.
  * @returns An array of strings for the output.
  */
 export declare function generateDispositorsOutput(dispositors: {

package/dist/formatters/text/sections/dispositors.js

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDispositorsOutput = generateDispositorsOutput;
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param dispositors A map of planet names to their full dispositor chain string.
+ * @param dispositors A map of planet names to their full dispositor chain string, or summary data.
  * @returns An array of strings for the output.
  */
 function generateDispositorsOutput(dispositors) {
+    // Check if this is summary format (finals mode)
+    if (dispositors['summary']) {
+        return [`[DISPOSITORS] ${dispositors['summary']}`];
+    }
+    // Traditional format
     const output = ['[DISPOSITOR TREE]'];
     if (Object.keys(dispositors).length === 0) {
         output.push('No dispositor data available.');

package/dist/formatters/text/textFormatter.js

@@ -21,7 +21,9 @@ const processSingleChartOutput = (analysis, settings, chartTitlePrefix) => {
     outputLines.push(...(0, angles_1.generateAnglesOutput)(chart.ascendant, chart.midheaven));
     outputLines.push(...(0, houses_1.generateHousesOutput)(chart.houseCusps));
     outputLines.push(...(0, planets_1.generatePlanetsOutput)(placements.planets));
-    outputLines.push(...(0, dispositors_1.generateDispositorsOutput)(dispositors));
+    if (settings.includeDispositors) {
+        outputLines.push(...(0, dispositors_1.generateDispositorsOutput)(dispositors));
+    }
     if (settings.includeSignDistributions) {
         outputLines.push(...(0, signDistributions_1.generateElementDistributionOutput)(signDistributions.elements));
         outputLines.push(...(0, signDistributions_1.generateModalityDistributionOutput)(signDistributions.modalities));
@@ -56,8 +58,10 @@ const processChartPairOutput = (analysis, settings) => {
         outputLines.push(...(0, aspectPatterns_1.generateAspectPatternsOutput)(compositePatterns, `${chart1.name}-${chart2.name} Composite`, true));
     }
     outputLines.push('');
-    outputLines.push(...(0, houseOverlays_1.generateHouseOverlaysOutput)(houseOverlays, chart1.name, chart2.name));
-    outputLines.push('');
+    if (settings.includeHouseOverlays) {
+        outputLines.push(...(0, houseOverlays_1.generateHouseOverlaysOutput)(houseOverlays, chart1.name, chart2.name));
+        outputLines.push('');
+    }
     return outputLines;
 };
 const processGlobalPatternsOutput = (analysis, isTransit = false) => {

package/dist/humandesign2txt.d.ts

@@ -0,0 +1,239 @@
+/**
+ * humandesign2txt
+ * Converts Human Design chart data to human-readable text for LLM consumption.
+ */
+export interface PlanetPosition {
+    name: string;
+    longitude: number;
+    speed: number;
+}
+export interface CalculationResult {
+    planets: PlanetPosition[];
+    ascendant: number;
+    midheaven: number;
+    houseCusps: number[];
+    date: string;
+    time: string;
+    location: {
+        latitude: number;
+        longitude: number;
+    };
+    timezone?: string;
+}
+export interface HumanDesignApiResponse {
+    personality: CalculationResult;
+    design: CalculationResult;
+    metadata: {
+        designUtcDateTime: string;
+        solarArcDegrees: number;
+        personalitySunLongitude: number;
+        designSunLongitude: number;
+    };
+}
+export interface Activation {
+    planet: string;
+    gate: number;
+    line: number;
+}
+export interface Channel {
+    gates: [number, number];
+    name: string;
+    centers: [string, string];
+}
+export interface HumanDesignChart {
+    name: string;
+    location: string;
+    date: string;
+    time: string;
+    type: string;
+    strategy: string;
+    authority: string;
+    definition: string;
+    definitionIslands: string[][];
+    profile: string;
+    profileName: string;
+    incarnationCross: string;
+    definedCenters: string[];
+    undefinedCenters: string[];
+    openCenters: string[];
+    activeChannels: Channel[];
+    hangingGates: Array<{
+        gate: number;
+        center: string;
+    }>;
+    allGates: Map<number, {
+        center: string;
+        sources: string[];
+    }>;
+    personalityActivations: Activation[];
+    designActivations: Activation[];
+}
+/**
+ * The 64 gates in I Ching wheel order (starting from 0° Aries after 58° adjustment)
+ */
+export declare const GATES: number[];
+/**
+ * Gate names (I Ching / Human Design names)
+ */
+export declare const GATE_NAMES: Record<number, string>;
+/**
+ * Which center each gate belongs to
+ */
+export declare const GATE_CENTERS: Record<number, string>;
+/**
+ * All 36 channels with their gate pairs, names, and connected centers
+ */
+export declare const CHANNELS: Channel[];
+/**
+ * Profile names by line combination
+ */
+export declare const PROFILE_NAMES: Record<string, string>;
+/**
+ * Incarnation Cross names by Sun gate (simplified - Right Angle crosses)
+ * Format: { gateNumber: "Cross Name" }
+ */
+export declare const INCARNATION_CROSSES: Record<number, string>;
+/**
+ * Strategy by Type
+ */
+export declare const STRATEGY_BY_TYPE: Record<string, string>;
+/**
+ * All 9 centers
+ */
+export declare const ALL_CENTERS: string[];
+/**
+ * Convert a planetary longitude to gate and line
+ */
+export declare function longitudeToGateLine(longitude: number): {
+    gate: number;
+    line: number;
+};
+/**
+ * Get the opposite gate (180° across the wheel)
+ */
+export declare function oppositeGate(gate: number): number;
+/**
+ * Calculate all activations from planetary positions
+ */
+export declare function calculateActivations(planets: PlanetPosition[]): Activation[];
+/**
+ * Get all unique gates from activations, tracking their sources
+ */
+export declare function getAllGates(personalityActivations: Activation[], designActivations: Activation[]): Map<number, {
+    center: string;
+    sources: string[];
+}>;
+/**
+ * Determine which channels are active (both gates present)
+ */
+export declare function getActiveChannels(allGates: Map<number, {
+    center: string;
+    sources: string[];
+}>): Channel[];
+/**
+ * Determine center status: Defined, Undefined, or Open
+ */
+export declare function getCenterStatus(activeChannels: Channel[], allGates: Map<number, {
+    center: string;
+    sources: string[];
+}>): {
+    defined: string[];
+    undefined: string[];
+    open: string[];
+};
+/**
+ * Calculate Human Design Type
+ */
+export declare function calculateType(definedCenters: string[], activeChannels: Channel[]): string;
+/**
+ * Calculate Inner Authority
+ */
+export declare function calculateAuthority(definedCenters: string[], activeChannels: Channel[]): string;
+/**
+ * Calculate Definition type (how centers are connected)
+ */
+export declare function calculateDefinition(activeChannels: Channel[], definedCenters: string[]): string;
+/**
+ * Get definition islands - groups of connected defined centers
+ */
+export declare function getDefinitionIslands(activeChannels: Channel[], definedCenters: string[]): string[][];
+/**
+ * Get hanging gates - gates that are not part of a complete channel
+ */
+export declare function getHangingGates(allGates: Map<number, {
+    center: string;
+    sources: string[];
+}>, activeChannels: Channel[]): Array<{
+    gate: number;
+    center: string;
+}>;
+/**
+ * Calculate Profile from personality and design sun lines
+ */
+export declare function calculateProfile(personalitySunLine: number, designSunLine: number): string;
+/**
+ * Get Incarnation Cross
+ */
+export declare function getIncarnationCross(personalitySunGate: number, personalityEarthGate: number, designSunGate: number, designEarthGate: number, personalitySunLine: number, designSunLine: number): string;
+export interface HumanDesign2TxtOptions {
+    name?: string;
+    location?: string;
+}
+/**
+ * Main entry point: Convert Human Design API response to formatted text
+ */
+export declare function humandesign2txt(apiResponse: HumanDesignApiResponse, options?: HumanDesign2TxtOptions): string;
+export interface ChannelConnection {
+    channel: Channel;
+    type: 'electromagnetic' | 'companionship' | 'dominance' | 'compromise';
+    person1Gates: number[];
+    person2Gates: number[];
+    description: string;
+}
+export interface GateConnection {
+    gate: number;
+    gateName: string;
+    center: string;
+    type: 'shared' | 'unique_person1' | 'unique_person2';
+}
+export interface HumanDesignPartnership {
+    person1: HumanDesignChart;
+    person2: HumanDesignChart;
+    electromagneticChannels: ChannelConnection[];
+    companionshipChannels: ChannelConnection[];
+    dominanceChannels: ChannelConnection[];
+    compromiseChannels: ChannelConnection[];
+    compositeDefinedCenters: string[];
+    compositeUndefinedCenters: string[];
+    compositeOpenCenters: string[];
+    compositeChannels: Channel[];
+    compositeType: string;
+    compositeStrategy: string;
+    compositeDefinition: string;
+    compositeDefinitionIslands: string[][];
+    channelsPerson1Only: Channel[];
+    channelsPerson2Only: Channel[];
+    channelsOnlyTogether: Channel[];
+    sharedGates: GateConnection[];
+    uniqueGatesPerson1: GateConnection[];
+    uniqueGatesPerson2: GateConnection[];
+}
+/**
+ * Analyze the relationship between two Human Design charts
+ */
+export declare function analyzePartnership(chart1: HumanDesignChart, chart2: HumanDesignChart): HumanDesignPartnership;
+/**
+ * Build a HumanDesignChart object from API response
+ */
+export declare function buildChart(apiResponse: HumanDesignApiResponse, options?: HumanDesign2TxtOptions): HumanDesignChart;
+export interface HumanDesignPartnership2TxtOptions {
+    person1Name?: string;
+    person1Location?: string;
+    person2Name?: string;
+    person2Location?: string;
+}
+/**
+ * Main entry point for partnership analysis: Convert two Human Design API responses to formatted text
+ */
+export declare function humandesignPartnership2txt(apiResponse1: HumanDesignApiResponse, apiResponse2: HumanDesignApiResponse, options?: HumanDesignPartnership2TxtOptions): string;
+export default humandesign2txt;