chart2txt 0.6.0 → 0.7.0

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

@@ -6,164 +6,188 @@ const formatting_1 = require("../../../utils/formatting");
 /**
  * Format a planet position for display
  */
-function formatPlanetPosition(planet) {
+function formatPlanetPosition(planet, includeHouse = false, showChartNames = true) {
     const degInSign = Math.floor((0, astrology_1.getDegreeInSign)(planet.degree));
-    const houseStr = planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
-    return `${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
+    const houseStr = includeHouse && planet.house ? ` (${(0, formatting_1.getOrdinal)(planet.house)} house)` : '';
+    const chartPrefix = showChartNames && planet.chartName ? `${planet.chartName}'s ` : '';
+    return `${chartPrefix}${planet.name} ${degInSign}° ${planet.sign}${houseStr}`;
 }
 /**
- * Format a T-Square pattern
+ * Format a T-Square pattern in compact format
  */
-function formatTSquare(pattern) {
+function formatTSquare(pattern, showChartNames = true) {
     if (pattern.type !== 'T-Square')
         return [];
-    const output = ['T-Square:'];
-    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
-    output.push(`  - Opposition: ${formatPlanetPosition(pattern.opposition[0])} - ${formatPlanetPosition(pattern.opposition[1])}`);
-    output.push(`  - Mode: ${pattern.mode}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const opp1 = formatPlanetPosition(pattern.opposition[0], false, showChartNames);
+    const opp2 = formatPlanetPosition(pattern.opposition[1], false, showChartNames);
+    return [
+        `T-Square (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${opp1} ↔ ${opp2}`,
+    ];
 }
 /**
- * Format a Grand Trine pattern
+ * Format a Grand Trine pattern in compact format
  */
-function formatGrandTrine(pattern) {
+function formatGrandTrine(pattern, showChartNames = true) {
     if (pattern.type !== 'Grand Trine')
         return [];
-    const output = ['Grand Trine:'];
-    pattern.planets.forEach((planet, index) => {
-        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
-    });
-    output.push(`  - Element: ${pattern.element}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
-}
-/**
- * Format a Stellium pattern
- */
-function formatStellium(pattern) {
-    if (pattern.type !== 'Stellium')
-        return [];
-    const output = ['Stellium:'];
-    const planetNames = pattern.planets.map((p) => p.name).join(', ');
-    output.push(`  - Planets: ${planetNames}`);
-    if (pattern.sign) {
-        output.push(`  - Sign: ${pattern.sign}`);
-    }
-    if (pattern.houses.length > 0) {
-        const houseStr = pattern.houses.length === 1
-            ? `${(0, formatting_1.getOrdinal)(pattern.houses[0])}`
-            : pattern.houses.map((h) => (0, formatting_1.getOrdinal)(h)).join('-');
-        output.push(`  - Houses: ${houseStr}`);
-    }
-    output.push(`  - Span: ${pattern.span.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    return [
+        `Grand Trine (${pattern.element}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
 }
 /**
- * Format a Grand Cross pattern
+ * Format a Grand Cross pattern in compact format
  */
-function formatGrandCross(pattern) {
+function formatGrandCross(pattern, showChartNames = true) {
     if (pattern.type !== 'Grand Cross')
         return [];
-    const output = ['Grand Cross:'];
-    pattern.planets.forEach((planet, index) => {
-        output.push(`  - Planet ${index + 1}: ${formatPlanetPosition(planet)}`);
-    });
-    output.push(`  - Mode: ${pattern.mode}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const planets = pattern.planets
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' ⨯ ');
+    return [
+        `Grand Cross (${pattern.mode}, ${pattern.averageOrb.toFixed(1)}°): ${planets}`,
+    ];
 }
 /**
- * Format a Yod pattern
+ * Format a Yod pattern in compact format
  */
-function formatYod(pattern) {
+function formatYod(pattern, showChartNames = true) {
     if (pattern.type !== 'Yod')
         return [];
-    const output = ['Yod:'];
-    output.push(`  - Apex: ${formatPlanetPosition(pattern.apex)}`);
-    output.push(`  - Base planet 1: ${formatPlanetPosition(pattern.base[0])}`);
-    output.push(`  - Base planet 2: ${formatPlanetPosition(pattern.base[1])}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const apex = formatPlanetPosition(pattern.apex, false, showChartNames);
+    const base1 = formatPlanetPosition(pattern.base[0], false, showChartNames);
+    const base2 = formatPlanetPosition(pattern.base[1], false, showChartNames);
+    return [
+        `Yod (${pattern.averageOrb.toFixed(1)}°): ${apex} ← ${base1} • ${base2}`,
+    ];
 }
 /**
- * Format a Mystic Rectangle pattern
+ * Format a Mystic Rectangle pattern in compact format
  */
-function formatMysticRectangle(pattern) {
+function formatMysticRectangle(pattern, showChartNames = true) {
     if (pattern.type !== 'Mystic Rectangle')
         return [];
-    const output = ['Mystic Rectangle:'];
-    output.push(`  - Opposition 1: ${formatPlanetPosition(pattern.oppositions[0][0])} - ${formatPlanetPosition(pattern.oppositions[0][1])}`);
-    output.push(`  - Opposition 2: ${formatPlanetPosition(pattern.oppositions[1][0])} - ${formatPlanetPosition(pattern.oppositions[1][1])}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const opp1_1 = formatPlanetPosition(pattern.oppositions[0][0], false, showChartNames);
+    const opp1_2 = formatPlanetPosition(pattern.oppositions[0][1], false, showChartNames);
+    const opp2_1 = formatPlanetPosition(pattern.oppositions[1][0], false, showChartNames);
+    const opp2_2 = formatPlanetPosition(pattern.oppositions[1][1], false, showChartNames);
+    return [
+        `Mystic Rectangle (${pattern.averageOrb.toFixed(1)}°): ${opp1_1} ↔ ${opp1_2} | ${opp2_1} ↔ ${opp2_2}`,
+    ];
 }
 /**
- * Format a Kite pattern
+ * Format a Kite pattern in compact format
  */
-function formatKite(pattern) {
+function formatKite(pattern, showChartNames = true) {
     if (pattern.type !== 'Kite')
         return [];
-    const output = ['Kite:'];
-    const grandTrineStr = pattern.grandTrine.map((p) => p.name).join(', ');
-    output.push(`  - Grand Trine planets: ${grandTrineStr}`);
-    output.push(`  - Opposition planet: ${formatPlanetPosition(pattern.opposition)}`);
-    output.push(`  - Average orb: ${pattern.averageOrb.toFixed(1)}°`);
-    output.push('');
-    return output;
+    const grandTrineStr = pattern.grandTrine
+        .map((p) => formatPlanetPosition(p, false, showChartNames))
+        .join(' △ ');
+    const oppositionPlanet = formatPlanetPosition(pattern.opposition, false, showChartNames);
+    // Get the element from the first planet's sign for context
+    const element = pattern.grandTrine[0].sign
+        ? getElementFromSign(pattern.grandTrine[0].sign)
+        : '';
+    const elementStr = element ? `${element}, ` : '';
+    return [
+        `Kite (${elementStr}${pattern.averageOrb.toFixed(1)}°): [${grandTrineStr}] ← ${oppositionPlanet}`,
+    ];
+}
+/**
+ * Helper function to get element from sign
+ */
+function getElementFromSign(sign) {
+    const fireSigns = ['Aries', 'Leo', 'Sagittarius'];
+    const earthSigns = ['Taurus', 'Virgo', 'Capricorn'];
+    const airSigns = ['Gemini', 'Libra', 'Aquarius'];
+    const waterSigns = ['Cancer', 'Scorpio', 'Pisces'];
+    if (fireSigns.includes(sign))
+        return 'Fire';
+    if (earthSigns.includes(sign))
+        return 'Earth';
+    if (airSigns.includes(sign))
+        return 'Air';
+    if (waterSigns.includes(sign))
+        return 'Water';
+    return '';
+}
+/**
+ * Check if a Grand Trine is part of any Kite pattern within the same analysis context
+ * Uses exact planet identity matching (chart name + planet name + degree)
+ */
+function isGrandTrinePartOfKite(grandTrine, patterns) {
+    if (grandTrine.type !== 'Grand Trine')
+        return false;
+    return patterns.some((pattern) => {
+        if (pattern.type !== 'Kite')
+            return false;
+        // Create unique identifiers for exact planet identity matching
+        const createPlanetId = (p) => `${p.chartName || ''}-${p.name}-${p.degree}`;
+        const kiteGrandTrinePlanets = pattern.grandTrine.map(createPlanetId);
+        const grandTrinePlanets = grandTrine.planets.map(createPlanetId);
+        // Check if the sets of planets are identical (same planets, same count)
+        return (kiteGrandTrinePlanets.length === grandTrinePlanets.length &&
+            kiteGrandTrinePlanets.every((kp) => grandTrinePlanets.includes(kp)));
+    });
 }
 /**
  * Generates the [ASPECT PATTERNS] section of the chart output.
  * @param patterns Array of detected aspect patterns
+ * @param customTitle Optional custom title for the section
+ * @param showChartNames Whether to show chart names for planets (false for single charts, true for multi-chart)
  * @returns An array of strings for the output.
  */
-function generateAspectPatternsOutput(patterns) {
-    const output = ['[ASPECT PATTERNS]'];
+function generateAspectPatternsOutput(patterns, customTitle, showChartNames = true) {
+    const output = [
+        customTitle ? `[ASPECT PATTERNS: ${customTitle}]` : '[ASPECT PATTERNS]',
+    ];
     if (patterns.length === 0) {
-        output.push('No aspect patterns detected.');
+        output.push('No T-Squares detected.');
+        output.push('No Grand Trines detected.');
         return output;
     }
+    // Filter out Grand Trines that are part of Kites to avoid duplication
+    const filteredPatterns = patterns.filter((pattern) => {
+        if (pattern.type === 'Grand Trine') {
+            return !isGrandTrinePartOfKite(pattern, patterns);
+        }
+        return true;
+    });
     // Sort patterns by type for consistent output
     const sortOrder = [
         'T-Square',
         'Grand Trine',
         'Grand Cross',
-        'Stellium',
         'Yod',
         'Mystic Rectangle',
         'Kite',
     ];
-    const sortedPatterns = patterns.sort((a, b) => {
+    const sortedPatterns = filteredPatterns.sort((a, b) => {
         return sortOrder.indexOf(a.type) - sortOrder.indexOf(b.type);
     });
     sortedPatterns.forEach((pattern) => {
         switch (pattern.type) {
             case 'T-Square':
-                output.push(...formatTSquare(pattern));
+                output.push(...formatTSquare(pattern, showChartNames));
                 break;
             case 'Grand Trine':
-                output.push(...formatGrandTrine(pattern));
-                break;
-            case 'Stellium':
-                output.push(...formatStellium(pattern));
+                output.push(...formatGrandTrine(pattern, showChartNames));
                 break;
             case 'Grand Cross':
-                output.push(...formatGrandCross(pattern));
+                output.push(...formatGrandCross(pattern, showChartNames));
                 break;
             case 'Yod':
-                output.push(...formatYod(pattern));
+                output.push(...formatYod(pattern, showChartNames));
                 break;
             case 'Mystic Rectangle':
-                output.push(...formatMysticRectangle(pattern));
+                output.push(...formatMysticRectangle(pattern, showChartNames));
                 break;
             case 'Kite':
-                output.push(...formatKite(pattern));
+                output.push(...formatKite(pattern, showChartNames));
                 break;
         }
     });

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

@@ -1,14 +1,11 @@
 import { AspectData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-export declare function generateAspectsOutput(title: string, aspects: AspectData[], settings: ChartSettings, p1ChartName?: string, p2ChartName?: string, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit?: boolean): string[];
+export declare function generateAspectsOutput(title: string, groupedAspects?: Map<string, AspectData[]>, p1ChartName?: string, p2ChartName?: string, p2IsTransit?: boolean): string[];

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

@@ -2,66 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAspectsOutput = generateAspectsOutput;
 /**
- * Generates aspect sections (e.g., [ASPECTS], [PLANET-PLANET ASPECTS], [TRANSIT ASPECTS: Name]).
+ * Generates the output for a single aspect line.
+ * @param asp The aspect data.
+ * @param p1ChartName Optional name of the first chart.
+ * @param p2ChartName Optional name of the second chart.
+ * @param p2IsTransit Optional flag if the second chart is for transits.
+ * @returns A formatted string for the aspect.
+ */
+function formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit = false) {
+    const p1NameStr = p1ChartName
+        ? `${p1ChartName}'s ${asp.planetA}`
+        : asp.planetA;
+    let p2NameStr = asp.planetB;
+    if (p2IsTransit) {
+        p2NameStr = `transiting ${asp.planetB}`;
+    }
+    else if (p2ChartName) {
+        p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
+    }
+    const applicationStr = asp.application && asp.application !== 'exact'
+        ? ` (${asp.application})`
+        : '';
+    return `${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`;
+}
+/**
+ * Generates aspect sections from a pre-grouped map of aspects.
  * @param title The main title for this aspect block (e.g., "[ASPECTS]").
- * @param aspects Array of calculated aspect data.
- * @param settings The chart settings, containing aspect categories.
+ * @param groupedAspects A map of category names to aspect data arrays.
  * @param p1ChartName Optional: Name of the first chart/entity for synastry/transit aspects.
  * @param p2ChartName Optional: Name of the second chart/entity for synastry aspects.
  * @param p2IsTransit Optional: Boolean indicating if p2 represents transiting points.
  * @returns An array of strings for the output.
  */
-function generateAspectsOutput(title, aspects, settings, p1ChartName, p2ChartName, // For synastry, this is the second person's name. For transits, it could be "Current" or the transit chart name.
-p2IsTransit = false) {
+function generateAspectsOutput(title, groupedAspects, p1ChartName, p2ChartName, p2IsTransit = false) {
     const output = [title];
-    let aspectsFoundInAnyCategory = false;
-    settings.aspectCategories.forEach((category) => {
-        const categoryAspects = aspects.filter((asp) => {
-            const orb = asp.orb;
-            const minOrbCheck = category.minOrb === undefined ? true : orb > category.minOrb;
-            const maxOrbCheck = orb <= category.maxOrb;
-            return minOrbCheck && maxOrbCheck;
-        });
-        if (categoryAspects.length > 0) {
-            aspectsFoundInAnyCategory = true;
-            let orbRangeStr = `orb under ${category.maxOrb.toFixed(1)}°`;
-            if (category.minOrb !== undefined) {
-                // Ensure minOrb is less than maxOrb for sensible range string
-                orbRangeStr =
-                    category.minOrb < category.maxOrb
-                        ? `orb ${category.minOrb.toFixed(1)}-${category.maxOrb.toFixed(1)}°`
-                        : `orb over ${category.minOrb.toFixed(1)}° & under ${category.maxOrb.toFixed(1)}°`; // Fallback for unusual category def
-            }
-            output.push(`[${category.name}: ${orbRangeStr}]`);
-            categoryAspects.sort((a, b) => a.orb - b.orb); // Sort by orb tightness
-            categoryAspects.forEach((asp) => {
-                const p1NameStr = p1ChartName
-                    ? `${p1ChartName}'s ${asp.planetA}`
-                    : asp.planetA;
-                let p2NameStr = asp.planetB;
-                if (p2IsTransit) {
-                    // For "Transit Aspects: Alice", p1 is Alice, p2 is the transiting planet.
-                    // Example: "Alice's Mercury opposition transiting Neptune: 0.3°" - here p2ChartName is not used for the planet itself.
-                    p2NameStr = `transiting ${asp.planetB}`;
-                }
-                else if (p2ChartName) {
-                    // For "Synastry: Alice-Bob", "Planet-Planet Aspects"
-                    // Example: "Alice's Mercury opposition Bob's Neptune: 0.3°"
-                    p2NameStr = `${p2ChartName}'s ${asp.planetB}`;
-                }
-                // If neither p2IsTransit nor p2ChartName, it's a natal chart aspect, e.g. "Venus opposition Pluto: 1.2°"
-                const applicationStr = asp.application && asp.application !== 'exact'
-                    ? ` (${asp.application})`
-                    : '';
-                output.push(`${p1NameStr} ${asp.aspectType} ${p2NameStr}: ${asp.orb.toFixed(1)}°${applicationStr}`);
-            });
-        }
-    });
-    if (!aspectsFoundInAnyCategory && aspects.length > 0) {
-        output.push('No aspects within defined categories.');
-    }
-    else if (aspects.length === 0) {
+    if (!groupedAspects || groupedAspects.size === 0) {
         output.push('None');
+        return output;
     }
+    groupedAspects.forEach((categoryAspects, categoryName) => {
+        output.push(categoryName); // The category name is the pre-formatted key from the map
+        categoryAspects.forEach((asp) => {
+            output.push(formatAspectLine(asp, p1ChartName, p2ChartName, p2IsTransit));
+        });
+    });
     return output;
 }

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

@@ -1,7 +1,8 @@
-import { Point } from '../../../types';
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param planets Array of planet points.
+ * @param dispositors A map of planet names to their full dispositor chain string.
  * @returns An array of strings for the output.
  */
-export declare function generateDispositorsOutput(planets: Point[]): string[];
+export declare function generateDispositorsOutput(dispositors: {
+    [key: string]: string;
+}): string[];

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

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDispositorsOutput = generateDispositorsOutput;
-const dispositors_1 = require("../../../core/dispositors");
 /**
  * Generates the [DISPOSITOR TREE] section of the chart output.
- * @param planets Array of planet points.
+ * @param dispositors A map of planet names to their full dispositor chain string.
  * @returns An array of strings for the output.
  */
-function generateDispositorsOutput(planets) {
+function generateDispositorsOutput(dispositors) {
     const output = ['[DISPOSITOR TREE]'];
-    if (planets.length === 0) {
-        output.push('No planets available for dispositor analysis.');
+    if (Object.keys(dispositors).length === 0) {
+        output.push('No dispositor data available.');
         return output;
     }
-    const analysis = (0, dispositors_1.analyzeDispositors)(planets);
-    const formattedAnalysis = (0, dispositors_1.formatDispositorAnalysis)(analysis);
-    output.push(...formattedAnalysis);
+    for (const planet in dispositors) {
+        output.push(dispositors[planet]);
+    }
     return output;
 }

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

@@ -1,10 +1,15 @@
-import { ChartData } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
- * @param chart1 The first chart data.
- * @param chart2 The second chart data.
- * @param settings The chart settings, containing the house system calculator.
+ * @param overlays The pre-calculated house overlay data.
+ * @param chart1Name The name of the first chart.
+ * @param chart2Name The name of the second chart.
  * @returns An array of strings for the output.
  */
-export declare function generateHouseOverlaysOutput(chart1: ChartData, chart2: ChartData, settings: ChartSettings): string[];
+export declare function generateHouseOverlaysOutput(overlays: {
+    chart1InChart2Houses: {
+        [key: string]: number;
+    };
+    chart2InChart1Houses: {
+        [key: string]: number;
+    };
+}, chart1Name: string, chart2Name: string): string[];

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

@@ -2,60 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHouseOverlaysOutput = generateHouseOverlaysOutput;
 const formatting_1 = require("../../../utils/formatting");
-const houseCalculations_1 = require("../../../utils/houseCalculations");
 /**
  * Generates the [HOUSE OVERLAYS] section for synastry.
- * @param chart1 The first chart data.
- * @param chart2 The second chart data.
- * @param settings The chart settings, containing the house system calculator.
+ * @param overlays The pre-calculated house overlay data.
+ * @param chart1Name The name of the first chart.
+ * @param chart2Name The name of the second chart.
  * @returns An array of strings for the output.
  */
-function generateHouseOverlaysOutput(chart1, chart2, settings) {
+function generateHouseOverlaysOutput(overlays, chart1Name, chart2Name) {
     const output = ['[HOUSE OVERLAYS]'];
-    const c1Name = chart1.name;
-    const c2Name = chart2.name;
-    // Chart 1's planets in Chart 2's houses
-    if (chart2.houseCusps && chart2.houseCusps.length === 12) {
-        output.push(`${c1Name}'s planets in ${c2Name}'s houses:`);
-        if (chart1.planets && chart1.planets.length > 0) {
-            chart1.planets.forEach((planet) => {
-                const houseNumber = (0, houseCalculations_1.getHouseForPoint)(planet.degree, chart2.houseCusps);
-                if (houseNumber) {
-                    output.push(`- ${planet.name}: ${(0, formatting_1.getOrdinal)(houseNumber)}`);
-                }
-                else {
-                    output.push(`- ${planet.name}: (Could not determine house in ${c2Name})`);
-                }
-            });
-        }
-        else {
-            output.push('(No planets listed for overlay)');
-        }
+    output.push(`${chart1Name}'s planets in ${chart2Name}'s houses:`);
+    if (Object.keys(overlays.chart1InChart2Houses).length > 0) {
+        output.push(formatHouseOverlayCompact(overlays.chart1InChart2Houses));
     }
     else {
-        output.push(`${c1Name}'s planets in ${c2Name}'s houses: (${c2Name} house cusps not available)`);
+        output.push(`(${chart2Name} house cusps not available)`);
     }
-    output.push(''); // Blank line between the two overlay sections
-    // Chart 2's planets in Chart 1's houses
-    if (chart1.houseCusps && chart1.houseCusps.length === 12) {
-        output.push(`${c2Name}'s planets in ${c1Name}'s houses:`);
-        if (chart2.planets && chart2.planets.length > 0) {
-            chart2.planets.forEach((planet) => {
-                const houseNumber = (0, houseCalculations_1.getHouseForPoint)(planet.degree, chart1.houseCusps);
-                if (houseNumber) {
-                    output.push(`- ${planet.name}: ${(0, formatting_1.getOrdinal)(houseNumber)}`);
-                }
-                else {
-                    output.push(`- ${planet.name}: (Could not determine house in ${c1Name})`);
-                }
-            });
-        }
-        else {
-            output.push('(No planets listed for overlay)');
-        }
+    output.push(`${chart2Name}'s planets in ${chart1Name}'s houses:`);
+    if (Object.keys(overlays.chart2InChart1Houses).length > 0) {
+        output.push(formatHouseOverlayCompact(overlays.chart2InChart1Houses));
     }
     else {
-        output.push(`${c2Name}'s planets in ${c1Name}'s houses: (${c1Name} house cusps not available)`);
+        output.push(`(${chart1Name} house cusps not available)`);
     }
     return output;
 }
+/**
+ * Formats house overlays in a compact format, grouping by house.
+ * @param overlays Object mapping planet names to house numbers.
+ * @returns A compact string representation.
+ */
+function formatHouseOverlayCompact(overlays) {
+    // Group planets by house
+    const houseGroups = {};
+    for (const planet in overlays) {
+        const house = overlays[planet];
+        if (!houseGroups[house]) {
+            houseGroups[house] = [];
+        }
+        houseGroups[house].push(planet);
+    }
+    // Sort houses numerically and format
+    const sortedHouses = Object.keys(houseGroups)
+        .map(Number)
+        .sort((a, b) => a - b);
+    const houseStrings = sortedHouses.map((house) => {
+        const planets = houseGroups[house].join(', ');
+        return `${(0, formatting_1.getOrdinal)(house)}: ${planets}`;
+    });
+    return houseStrings.join(' | ');
+}

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

@@ -1,4 +1,6 @@
 import { ChartSettings } from '../../../config/ChartSettings';
+import { MultiChartData } from '../../../types';
+export declare function determineChartType(data: MultiChartData): string;
 /**
  * Generates the [METADATA] section of the chart output.
  * @param settings The chart settings.

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

@@ -1,6 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineChartType = determineChartType;
 exports.generateMetadataOutput = generateMetadataOutput;
+function determineChartType(data) {
+    let baseChartString = 'natal';
+    let suffixString = '';
+    const natalCharts = data.filter(({ chartType }) => chartType !== 'transit' && chartType !== 'event');
+    const eventCharts = data.filter(({ chartType }) => chartType === 'event');
+    const transitCharts = data.filter(({ chartType }) => chartType === 'transit');
+    if (transitCharts.length > 1) {
+        throw new Error('Must provide at most one transit chart');
+    }
+    const hasTransit = transitCharts.length > 0;
+    // first determine suffix
+    if (natalCharts.length > 0) {
+        if (eventCharts.length === 0) {
+            if (hasTransit) {
+                suffixString = '_with_transit';
+            }
+        }
+        else if (eventCharts.length === 1) {
+            suffixString = hasTransit ? '_with_event_and_transit' : '_with_event';
+        }
+        else {
+            suffixString = hasTransit ? '_with_events_and_transit' : '_with_events';
+        }
+    }
+    else {
+        // base event charts can have transits
+        if (hasTransit) {
+            suffixString = '_with_transit';
+        }
+    }
+    // then determine base string
+    if (natalCharts.length === 0) {
+        if (eventCharts.length === 0) {
+            throw new Error('Must provide at least one non-transit chart');
+        }
+        else if (eventCharts.length === 1) {
+            baseChartString = 'event';
+        }
+        else {
+            baseChartString = 'multi_event';
+        }
+    }
+    else if (natalCharts.length === 1) {
+        baseChartString = 'natal';
+    }
+    else if (natalCharts.length === 2) {
+        baseChartString = 'synastry';
+    }
+    else {
+        baseChartString = 'group_synastry';
+    }
+    return baseChartString + suffixString;
+}
 /**
  * Generates the [METADATA] section of the chart output.
  * @param settings The chart settings.

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

@@ -1,10 +1,8 @@
-import { Point } from '../../../types';
-import { ChartSettings } from '../../../config/ChartSettings';
+import { PlanetPosition } from '../../../types';
 /**
  * Generates the [PLANETS] section of the chart output.
- * @param planets Array of planet points.
- * @param houseCusps Array of 12 house cusp degrees, or undefined if not available.
+ * @param placements Array of planet positions.
  * @param settings The chart settings.
  * @returns An array of strings for the output.
  */
-export declare function generatePlanetsOutput(planets: Point[], houseCusps: number[] | undefined, settings: ChartSettings): string[];
+export declare function generatePlanetsOutput(placements: PlanetPosition[]): string[];