klio 1.1.7

package/src/astrology/astrologyService.js

@@ -0,0 +1,990 @@
+const swisseph = require('swisseph');
+const fs = require('fs');
+const moment = require('moment-timezone');
+const { planets, signs, elements, decans, dignities } = require('./astrologyConstants');
+const { loadConfig } = require('../config/configService');
+const path = require('path');
+
+// Standardort (Berlin, Deutschland) - kann später konfiguriert werden
+const defaultLatitude = 52.5200; // Berlin Breitengrad
+const defaultLongitude = 13.4050; // Berlin Längengrad
+
+// Swisseph initialisieren
+swisseph.swe_set_ephe_path(__dirname + '/../../ephe');
+
+// Funktion zur Berechnung der aktuellen Zeit in der konfigurierten Zeitzone
+function getCurrentTimeInTimezone() {
+  try {
+    const configPath = path.join(__dirname, '../../astrocli-config.json');
+    if (fs.existsSync(configPath)) {
+      const configData = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configData);
+      
+      if (config && config.currentLocation && config.currentLocation.timezone) {
+        // Verwende die konfigurierte Zeitzone
+        const now = moment().tz(config.currentLocation.timezone);
+        return {
+          year: now.year(),
+          month: now.month() + 1, // moment Monate sind 0-basiert
+          day: now.date(),
+          hour: now.hours(),
+          minute: now.minutes()
+        };
+      }
+    }
+  } catch (error) {
+    console.log('Keine Zeitzonenkonfiguration gefunden, verwende lokale Zeit');
+  }
+  
+  // Fallback: Verwende lokale Systemzeit
+  const now = new Date();
+  return {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    day: now.getDate(),
+    hour: now.getHours(),
+    minute: now.getMinutes()
+  };
+}
+
+// Funktion zum Laden der Geburtsdaten aus der Konfiguration
+function getBirthDataFromConfig() {
+  try {
+    const configPath = path.join(__dirname, '../../astrocli-config.json');
+    if (fs.existsSync(configPath)) {
+      const configData = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configData);
+      
+      if (config && config.birthData) {
+        // Parse Geburtsdatum (Format: TT.MM.JJJJ)
+        const dateParts = config.birthData.date.split('.');
+        const day = parseInt(dateParts[0]);
+        const month = parseInt(dateParts[1]);
+        const year = parseInt(dateParts[2]);
+        
+        // Parse Geburtszeit (Format: HH:MM)
+        const timeParts = config.birthData.time.split(':');
+        const hour = parseInt(timeParts[0]);
+        const minute = parseInt(timeParts[1]);
+        
+        return {
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          location: config.birthData.location
+        };
+      }
+    }
+  } catch (error) {
+    console.log('Fehler beim Laden der Geburtsdaten:', error.message);
+  }
+  
+  return null;
+}
+
+// Funktion zur Berechnung des Julian Days in UTC
+function calculateJulianDayUTC(dateComponents, timezoneOffsetMinutes = 0) {
+  // Berechne den Julian Day in lokaler Zeit
+  const localJulianDay = swisseph.swe_julday(
+    dateComponents.year, 
+    dateComponents.month, 
+    dateComponents.day, 
+    dateComponents.hour + dateComponents.minute / 60, 
+    swisseph.SE_GREG_CAL
+  );
+  
+  // Konvertiere zu UTC, indem wir die Zeitzonenverschiebung berücksichtigen
+  // Die Swiss Ephemeris erwartet UTC, also müssen wir die Zeitzone anpassen
+  // timezoneOffsetMinutes ist (Lokalzeit - UTC) in Minuten.
+  // In JS gibt getTimezoneOffset() (UTC - Lokalzeit) in Minuten zurück.
+  // Wir müssen also vorsichtig sein, welches Format wir verwenden.
+  // Wenn timezoneOffsetMinutes (Lokalzeit - UTC) ist, dann:
+  // utcJulianDay = localJulianDay - (offset / 1440)
+  const utcJulianDay = localJulianDay - (timezoneOffsetMinutes / 1440); // 1440 Minuten pro Tag
+  
+  return utcJulianDay;
+}
+
+/**
+ * Hilfsfunktion zur Ermittlung des Zeitzonen-Offsets für ein bestimmtes Datum und einen Ort.
+ * @param {Object} dateComponents - {year, month, day, hour, minute}
+ * @param {string} timezone - Zeitzone (z.B. "Europe/Zurich")
+ * @returns {number} Offset in Minuten (Lokalzeit - UTC)
+ */
+function getTimezoneOffset(dateComponents, timezone) {
+  if (!timezone) return -new Date().getTimezoneOffset();
+  
+  try {
+    const dateStr = `${dateComponents.year}-${String(dateComponents.month).padStart(2, '0')}-${String(dateComponents.day).padStart(2, '0')} ${String(dateComponents.hour).padStart(2, '0')}:${String(dateComponents.minute).padStart(2, '0')}`;
+    const m = moment.tz(dateStr, "YYYY-MM-DD HH:mm", timezone);
+    return m.utcOffset(); // Gibt Offset in Minuten zurück (z.B. 120 für UTC+2)
+  } catch (error) {
+    console.error('Fehler bei der Offset-Berechnung:', error);
+    return -new Date().getTimezoneOffset();
+  }
+}
+
+// Funktion zur Berechnung der Häuser
+function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false) {
+  return new Promise((resolve, reject) => {
+    // Lade die konfigurierten Standortdaten
+    const configPath = path.join(__dirname, '../../astrocli-config.json');
+    let config;
+    try {
+      if (fs.existsSync(configPath)) {
+        const configData = fs.readFileSync(configPath, 'utf8');
+        config = JSON.parse(configData);
+      }
+    } catch (error) {
+      console.log('Keine Konfiguration gefunden, verwende Standardort (Berlin)');
+    }
+    
+    let latitude, longitude, locationName;
+    
+    if (useBirthLocation && config && config.birthData && config.birthData.location) {
+      // Verwende Geburtsort für Geburtscharts
+      latitude = config.birthData.location.latitude;
+      longitude = config.birthData.location.longitude;
+      locationName = `${config.birthData.location.name}, ${config.birthData.location.country}`;
+      console.log(`Verwende Geburtsort: ${locationName} (${latitude}° Breitengrad, ${longitude}° Längengrad)`);
+    } else if (useBirthLocation) {
+      // Geburtsort ist konfiguriert, aber kein Standort - verwende Standardort
+      latitude = defaultLatitude;
+      longitude = defaultLongitude;
+      locationName = 'Berlin, Deutschland';
+      console.log(`Verwende Standard-Geburtsort: ${locationName} (${latitude}° Breitengrad, ${longitude}° Längengrad)`);
+      console.log('⚠️  Kein Geburtsort in der Konfiguration gefunden.');
+    } else {
+      // Verwende aktuellen Standort für aktuelle Berechnungen
+      latitude = config && config.currentLocation ? config.currentLocation.latitude : defaultLatitude;
+      longitude = config && config.currentLocation ? config.currentLocation.longitude : defaultLongitude;
+      locationName = config && config.currentLocation ? `${config.currentLocation.name}, ${config.currentLocation.country}` : 'Berlin, Deutschland';
+    }
+
+    swisseph.swe_houses(julianDay, latitude, longitude, houseSystem, function(result) {
+      if (result.error) {
+        console.error('Fehler bei der Hausberechnung:', result.error);
+        reject(result.error);
+      } else {
+        // Die Swiss Ephemeris gibt im result.house Objekt oft Indices als Strings zurück ("1", "2", ...)
+        // Wir konvertieren dies in ein sauberes 0-basiertes Array (0-11) für eine konsistente Verarbeitung.
+        const houseCusps = [];
+        
+        // Wir versuchen zuerst die Indizes 1 bis 12 direkt abzurufen
+        for (let i = 1; i <= 12; i++) {
+          const cusp = result.house[i];
+          if (cusp !== undefined) {
+            houseCusps.push(cusp);
+          }
+        }
+        
+        // Falls wir nicht 12 Häuser haben (z.B. wenn das Objekt andere Keys hat), 
+        // versuchen wir alle numerischen Keys zu sammeln
+        if (houseCusps.length < 12) {
+            const keys = Object.keys(result.house).filter(k => !isNaN(k)).sort((a,b) => parseInt(a) - parseInt(b));
+            
+            if (keys.length >= 13) {
+                // Wahrscheinlich Index 0 = AC, 1-12 = Häuser
+                houseCusps.length = 0;
+                for (let i = 1; i <= 12; i++) {
+                    const key = keys.find(k => parseInt(k) === i);
+                    if (key !== undefined) {
+                        houseCusps.push(result.house[key]);
+                    }
+                }
+            } else if (keys.length === 12) {
+                // Wahrscheinlich direkt 0-11 = Häuser
+                houseCusps.length = 0;
+                for (let i = 0; i < 12; i++) {
+                    houseCusps.push(result.house[keys[i]]);
+                }
+            }
+        }
+
+        // Falls wir immer noch keine 12 Häuser haben (sollte nicht passieren), 
+        // füllen wir mit den verfügbaren Daten auf oder 0
+        while (houseCusps.length < 12) {
+            houseCusps.push(0);
+        }
+
+        const formattedResult = {
+          ...result,
+          house: houseCusps
+        };
+        
+        resolve(formattedResult);
+      }
+    });
+  });
+}
+
+// Funktion zur Bestimmung des Hauses für einen Planeten
+function getPlanetHouse(planetLongitude, houseCusps) {
+  // Normalisiere die Planetenlänge auf 0-360 Bereich
+  planetLongitude = planetLongitude % 360;
+  if (planetLongitude < 0) planetLongitude += 360;
+
+  // Hausgrenzen sind in houseCusps[0] bis houseCusps[11]
+  // Wir müssen finden, zwischen welchen zwei Hausspitzen der Planet liegt
+  for (let i = 0; i < 12; i++) {
+    const currentCusp = houseCusps[i];
+    const nextCusp = houseCusps[(i + 1) % 12];
+    
+    // Normalisiere die Hausspitzen auf 0-360 Bereich
+    const normalizedCurrentCusp = currentCusp % 360;
+    const normalizedNextCusp = nextCusp % 360;
+
+    // Berücksichtige den Übergang über 360°
+    if (normalizedNextCusp < normalizedCurrentCusp) {
+      // Fall: Hausgrenze überquert 0°/360°
+      // Ein Planet ist in diesem Haus, wenn er >= der aktuellen Hausspitze ODER < der nächsten Hausspitze ist
+      if (planetLongitude >= normalizedCurrentCusp || planetLongitude < normalizedNextCusp) {
+        return i + 1; // Häuser sind 1-basiert
+      }
+    } else {
+      // Normalfall
+      if (planetLongitude >= normalizedCurrentCusp && planetLongitude < normalizedNextCusp) {
+        return i + 1; // Häuser sind 1-basiert
+      }
+    }
+  }
+  
+  // Debug: Zeige die Hausspitzen an, wenn kein Haus gefunden wurde
+  console.log('Kein Haus gefunden für Planet:', planetLongitude);
+  console.log('Hausspitzen:', houseCusps);
+  
+  // Fallback: Sollte nicht vorkommen
+  return 1;
+}
+
+// Funktion zur Berechnung der astrologischen Daten
+function getAstrologicalData(planetName, customDate = null) {
+  const planet = planets[planetName];
+  if (planet === undefined) {
+    console.error(`Ungültiger Planet: ${planetName}. Verfügbare Planeten:`, Object.keys(planets).join(', '));
+    process.exit(1);
+  }
+
+  // Verwende das angegebene Datum oder das aktuelle Datum (mit Zeitzonenberücksichtigung)
+  let calcYear, calcMonth, calcDay, calcHour, calcMinute;
+  
+  if (customDate) {
+    calcYear = customDate.year;
+    calcMonth = customDate.month;
+    calcDay = customDate.day;
+    calcHour = customDate.hour;
+    calcMinute = customDate.minute;
+  } else {
+    // Verwende die aktuelle Zeit in der konfigurierten Zeitzone
+    const timeData = getCurrentTimeInTimezone();
+    calcYear = timeData.year;
+    calcMonth = timeData.month;
+    calcDay = timeData.day;
+    calcHour = timeData.hour;
+    calcMinute = timeData.minute;
+  }
+
+  const julianDay = swisseph.swe_julday(calcYear, calcMonth, calcDay, calcHour + calcMinute / 60, swisseph.SE_GREG_CAL);
+  const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
+  const result = swisseph.swe_calc_ut(julianDay, planet, flag);
+
+  if (result.error) {
+    console.error('Fehler bei der Berechnung:', result.error);
+    process.exit(1);
+  }
+
+  const longitude = result.longitude;
+  const signIndex = Math.floor(longitude / 30);
+  const degreeInSign = (longitude % 30).toFixed(2);
+  const sign = signs[signIndex];
+  const element = elements[signIndex];
+  const decan = decans[Math.floor((longitude % 30) / 10)];
+
+  const dignityInfo = dignities[planet];
+  let dignity = 'Neutral';
+  if (sign === dignityInfo.sign) {
+    dignity = 'Herrscher';
+  } else if (sign === dignityInfo.exaltation) {
+    dignity = 'Erhöhung';
+  } else if (sign === dignityInfo.fall) {
+    dignity = 'Fall';
+  } else if (sign === dignityInfo.detriment) {
+    dignity = 'Detriment';
+  }
+
+  return {
+    planet: planetName,
+    longitude,
+    sign,
+    degreeInSign,
+    dignity,
+    element,
+    decan
+  };
+}
+
+// Funktion zur Identifizierung kritischer Planeten
+function getCriticalPlanets(customDate = null) {
+  const criticalPlanets = [];
+  
+  // Kritische Grade: 0°, 13°, 26° (kardinale Grade) und 29° (anaretischer Grad)
+  const criticalDegrees = [0, 13, 26, 29];
+  const orb = 1; // Toleranz von 1 Grad
+  
+  // Verwende das angegebene Datum oder die aktuelle Zeit
+  let timeData;
+  if (customDate) {
+    timeData = customDate;
+  } else {
+    timeData = getCurrentTimeInTimezone();
+  }
+  
+  const julianDay = swisseph.swe_julday(
+    timeData.year, 
+    timeData.month, 
+    timeData.day, 
+    timeData.hour + timeData.minute / 60, 
+    swisseph.SE_GREG_CAL
+  );
+  
+  // Berechne Positionen aller Planeten
+  for (const [name, planetId] of Object.entries(planets)) {
+    const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
+    const result = swisseph.swe_calc_ut(julianDay, planetId, flag);
+    
+    if (result.error) {
+      console.error(`Fehler bei der Berechnung für ${name}:`, result.error);
+      continue;
+    }
+    
+    const longitude = result.longitude;
+    const degreeInSign = longitude % 30;
+    const signIndex = Math.floor(longitude / 30);
+    const sign = signs[signIndex];
+    
+    // Prüfe, ob der Planet auf einem kritischen Grad steht
+    const isCritical = criticalDegrees.some(criticalDegree => {
+      return Math.abs(degreeInSign - criticalDegree) <= orb;
+    });
+    
+    if (isCritical) {
+      criticalPlanets.push({
+        name,
+        sign,
+        degree: degreeInSign.toFixed(2),
+        isCritical: true,
+        criticalType: degreeInSign >= 28.5 ? 'Anaretisch (29°)' : 'Kardinal (0°, 13°, 26°)'
+      });
+    }
+  }
+  
+  return criticalPlanets;
+}
+
+// Funktion zur Berechnung von Planetenaspekten
+function calculatePlanetAspects(planetName, dateComponents, useHuberOrbs = false) {
+  // Berechne Planetenposition
+  const targetPlanetData = getAstrologicalData(planetName, dateComponents);
+  const targetPlanetLongitude = targetPlanetData.longitude;
+
+  // Berechne Positionen aller anderen Planeten
+  const planetPositions = {};
+  for (const [name, planetId] of Object.entries(planets)) {
+    if (name === planetName) continue;
+    const planetData = getAstrologicalData(name, dateComponents);
+    planetPositions[name] = planetData.longitude;
+  }
+
+  // Berechne Aspekte (Konjunktion, Opposition, Quadrat, Trigon, Sextil)
+  const aspects = [];
+  const aspectTypes = useHuberOrbs ? [
+    { name: 'Konjunktion', angle: 0, orb: 8 },
+    { name: 'Opposition', angle: 180, orb: 8 },
+    { name: 'Quadrat', angle: 90, orb: 6 },
+    { name: 'Trigon', angle: 120, orb: 6 },
+    { name: 'Sextil', angle: 60, orb: 4 }
+  ] : [
+    { name: 'Konjunktion', angle: 0, orb: 10 },
+    { name: 'Opposition', angle: 180, orb: 10 },
+    { name: 'Quadrat', angle: 90, orb: 8 },
+    { name: 'Trigon', angle: 120, orb: 8 },
+    { name: 'Sextil', angle: 60, orb: 6 }
+  ];
+
+  for (const [name, planetLongitude] of Object.entries(planetPositions)) {
+    const angleDiff = Math.abs(targetPlanetLongitude - planetLongitude) % 360;
+    const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+
+    for (const aspect of aspectTypes) {
+      if (Math.abs(normalizedAngle - aspect.angle) <= aspect.orb) {
+        aspects.push({
+          type: aspect.name,
+          planet: name,
+          angle: normalizedAngle.toFixed(2),
+          orb: Math.abs(normalizedAngle - aspect.angle).toFixed(2)
+        });
+      }
+    }
+  }
+
+  return aspects;
+}
+
+// Funktion zur Anzeige von Planetenaspekten
+function showPlanetAspects(planetName, dateComponents, useBirthData = false, useHuberOrbs = false) {
+  const aspects = calculatePlanetAspects(planetName, dateComponents, useHuberOrbs);
+  
+  const planetLabel = planetName.charAt(0).toUpperCase() + planetName.slice(1);
+  
+  console.log(`Aspekte für ${planetLabel}:`);
+  console.log('=================================================================');
+  console.log('| Aspekt      | Planet   | Winkel | Orb  |');
+  console.log('=================================================================');
+  
+  if (aspects.length === 0) {
+    console.log('Keine signifikanten Aspekte gefunden.');
+  } else {
+    aspects.forEach(aspect => {
+      const aspectName = aspect.type.padEnd(11, ' ');
+      const planetNameFormatted = aspect.planet.charAt(0).toUpperCase() + aspect.planet.slice(1);
+      const planetFormatted = planetNameFormatted.padEnd(8, ' ');
+      const angle = aspect.angle.padEnd(6, ' ');
+      const orb = aspect.orb.padEnd(4, ' ');
+      
+      console.log(`| ${aspectName} | ${planetFormatted} | ${angle}° | ${orb}° |`);
+    });
+  }
+  
+  console.log('=================================================================');
+  
+  if (useBirthData) {
+    console.log('\nDiese Analyse basiert auf deinem Geburtshoroskop.');
+  } else {
+    console.log('\nDiese Analyse basiert auf der aktuellen Planetenposition.');
+  }
+}
+
+// Funktion zur Berechnung aller aktiven Aspekte zwischen allen Planeten
+function getAllActiveAspects(dateComponents) {
+  const allAspects = [];
+  const planetNames = Object.keys(planets);
+  const seenAspects = new Set(); // Zur Vermeidung von Duplikaten
+  
+  // Berechne Aspekte für alle Planetenpaare
+  for (let i = 0; i < planetNames.length; i++) {
+    const planet1 = planetNames[i];
+    const aspects = calculatePlanetAspects(planet1, dateComponents, true); // Immer Huber-Orbs verwenden
+    
+    aspects.forEach(aspect => {
+      // Erstelle eine eindeutige Kennung für den Aspekt (alphabetisch sortiert)
+      const planetPair = [planet1, aspect.planet].sort().join('-');
+      const aspectKey = `${planetPair}-${aspect.type}`;
+      
+      // Füge den Aspekt nur hinzu, wenn er noch nicht existiert
+      if (!seenAspects.has(aspectKey)) {
+        seenAspects.add(aspectKey);
+        allAspects.push({
+          planet1: planet1,
+          planet2: aspect.planet,
+          type: aspect.type,
+          angle: aspect.angle,
+          orb: aspect.orb
+        });
+      }
+    });
+  }
+  
+  return allAspects;
+}
+
+// Funktion zur Überprüfung der Rückläufigkeit eines Planeten
+function isPlanetRetrograde(planetName, dateComponents) {
+  try {
+    const planet = planets[planetName];
+    if (planet === undefined) return false;
+    
+    // Berechne die Position mit Geschwindigkeitsinformation
+    const julianDay = swisseph.swe_julday(
+      dateComponents.year, 
+      dateComponents.month, 
+      dateComponents.day, 
+      dateComponents.hour + dateComponents.minute / 60, 
+      swisseph.SE_GREG_CAL
+    );
+    
+    const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
+    const result = swisseph.swe_calc_ut(julianDay, planet, flag);
+    
+    if (result.error) {
+      console.log('Fehler bei Rückläufigkeitsprüfung:', result.error);
+      return false;
+    }
+    
+    // Die Geschwindigkeit befindet sich in result.longitudeSpeed
+    // Swiss Ephemeris gibt die Geschwindigkeit als separate Eigenschaften zurück
+    if (result.longitudeSpeed !== undefined) {
+      return result.longitudeSpeed < 0;
+    }
+    
+    return false;
+  } catch (error) {
+    console.log('Fehler in isPlanetRetrograde:', error.message);
+    return false;
+  }
+}
+
+// Funktion zur Bestimmung der Aspekt-Phase (annähernd, exakt, separativ)
+function determineAspectPhase(planet1, planet2, dateComponents, aspectType, targetAngle) {
+  // Berechne aktuelle Positionen und Geschwindigkeiten
+  const planet1Data = getAstrologicalData(planet1, dateComponents);
+  const planet2Data = getAstrologicalData(planet2, dateComponents);
+  
+  // Berechne Positionen für einen leicht späteren Zeitpunkt (1 Tag später)
+  const nextDate = {
+    year: dateComponents.year,
+    month: dateComponents.month,
+    day: dateComponents.day + 1,
+    hour: dateComponents.hour,
+    minute: dateComponents.minute
+  };
+  
+  const planet1NextData = getAstrologicalData(planet1, nextDate);
+  const planet2NextData = getAstrologicalData(planet2, nextDate);
+  
+  // Berechne aktuellen Winkel
+  const currentAngleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
+  const currentNormalizedAngle = Math.min(currentAngleDiff, 360 - currentAngleDiff);
+  
+  // Berechne zukünftigen Winkel
+  const nextAngleDiff = Math.abs(planet1NextData.longitude - planet2NextData.longitude) % 360;
+  const nextNormalizedAngle = Math.min(nextAngleDiff, 360 - nextAngleDiff);
+  
+  // Bestimme die Phase basierend auf der Winkelentwicklung
+  const currentDistanceToTarget = Math.abs(currentNormalizedAngle - targetAngle);
+  const nextDistanceToTarget = Math.abs(nextNormalizedAngle - targetAngle);
+  
+  // Wenn der Winkel sich dem Ziel nähert = annähernd
+  // Wenn der Winkel genau auf dem Ziel ist = exakt  
+  // Wenn der Winkel sich vom Ziel entfernt = separativ
+  
+  if (currentDistanceToTarget < 0.5) {
+    return 'exakt';
+  } else if (nextDistanceToTarget < currentDistanceToTarget) {
+    return 'annähernd';
+  } else {
+    return 'separativ';
+  }
+}
+
+// Funktion zur Analyse der Elementverteilung
+function analyzeElementDistribution(dateComponents, useBirthData = false) {
+  const elementCounts = {
+    'Feuer': 0,
+    'Erde': 0,
+    'Luft': 0,
+    'Wasser': 0
+  };
+  
+  const planetElements = {};
+  
+  // Berechne Elemente aller Planeten
+  for (const [name, planetId] of Object.entries(planets)) {
+    const data = getAstrologicalData(name, dateComponents);
+    elementCounts[data.element]++;
+    planetElements[name] = data.element;
+  }
+  
+  // Berechne Gesamtzahl der Planeten
+  const totalPlanets = Object.keys(planets).length;
+  
+  // Berechne Prozentsätze
+  const elementPercentages = {};
+  for (const [element, count] of Object.entries(elementCounts)) {
+    elementPercentages[element] = ((count / totalPlanets) * 100).toFixed(1);
+  }
+  
+  // Erstelle horizontales Chart
+  console.log('Elementverteilung der Planeten:');
+  console.log('================================================================================');
+  
+  // Maximale Balkenlänge (pro Planet)
+  const maxBars = 20;
+  
+  for (const [element, count] of Object.entries(elementCounts)) {
+    const percentage = elementPercentages[element];
+    const barLength = Math.round((count / totalPlanets) * maxBars);
+    const bar = '|'.repeat(barLength);
+    const paddedBar = bar.padEnd(maxBars, ' ');
+    
+    console.log(`${element.padEnd(10)}: ${paddedBar} ${barLength.toString().padStart(2)}/${totalPlanets} (${percentage}%)`);
+  }
+  
+  console.log('================================================================================');
+  
+  // Zeige detaillierte Planeten-Element-Zuordnung
+  console.log('\nPlaneten nach Elementen:');
+  for (const [element, count] of Object.entries(elementCounts)) {
+    const planetsInElement = Object.entries(planetElements)
+      .filter(([_, el]) => el === element)
+      .map(([name]) => name.charAt(0).toUpperCase() + name.slice(1))
+      .join(', ');
+    
+    console.log(`${element}: ${planetsInElement}`);
+  }
+  
+  if (useBirthData) {
+    console.log('\nDiese Analyse basiert auf deinem Geburtshoroskop.');
+  } else {
+    console.log('\nDiese Analyse basiert auf der aktuellen Planetenposition.');
+  }
+  
+  return {
+    elementCounts,
+    elementPercentages,
+    planetElements
+  };
+}
+
+// Funktion zur Anzeige aller aktiven Aspekte
+function showAllActiveAspects(dateComponents, useBirthData = false) {
+  const allAspects = getAllActiveAspects(dateComponents);
+  
+  // Sortiere Aspekte nach Typ und dann nach Orb (genaueste zuerst)
+  const sortedAspects = [...allAspects].sort((a, b) => {
+    // Sortiere zuerst nach Aspekt-Typ
+    const aspectOrder = {
+      'Konjunktion': 1,
+      'Opposition': 2,
+      'Quadrat': 3,
+      'Trigon': 4,
+      'Sextil': 5
+    };
+    
+    const typeCompare = aspectOrder[a.type] - aspectOrder[b.type];
+    if (typeCompare !== 0) return typeCompare;
+    
+    // Dann nach Orb (kleinster Orb zuerst = genaueste Aspekte)
+    return parseFloat(a.orb) - parseFloat(b.orb);
+  });
+  
+  console.log('Aktive Aspekte (alle Planeten) - Klassifiziert nach Präzision:');
+  console.log('==========================================================================');
+  console.log('| Planet 1    | Planet 2    | Winkel | Orb  | Status      |');
+  console.log('==========================================================================');
+  
+  if (sortedAspects.length === 0) {
+    console.log('Keine signifikanten Aspekte gefunden.');
+  } else {
+    // Gruppiere nach Aspekt-Typ für bessere Übersicht
+    const aspectsByType = {};
+    sortedAspects.forEach(aspect => {
+      if (!aspectsByType[aspect.type]) {
+        aspectsByType[aspect.type] = [];
+      }
+      aspectsByType[aspect.type].push(aspect);
+    });
+    
+    // Zeige Aspekte gruppiert nach Typ
+    const aspectTypes = ['Konjunktion', 'Opposition', 'Quadrat', 'Trigon', 'Sextil'];
+    aspectTypes.forEach(type => {
+      if (aspectsByType[type]) {
+        console.log(`\n--- ${type} ---`);
+        aspectsByType[type].forEach(aspect => {
+          // Prüfe Rückläufigkeit für beide Planeten
+          const planet1Retrograde = isPlanetRetrograde(aspect.planet1, dateComponents);
+          const planet2Retrograde = isPlanetRetrograde(aspect.planet2, dateComponents);
+          
+          // Formatiere Planetenamen mit Rückläufigkeitskennzeichnung (R)
+          const planet1Formatted = aspect.planet1.charAt(0).toUpperCase() + aspect.planet1.slice(1) + (planet1Retrograde ? '(R)' : '');
+          const planet1Padded = planet1Formatted.padEnd(12, ' ');
+          const planet2Formatted = aspect.planet2.charAt(0).toUpperCase() + aspect.planet2.slice(1) + (planet2Retrograde ? '(R)' : '');
+          const planet2Padded = planet2Formatted.padEnd(12, ' ');
+          const angle = aspect.angle.padEnd(6, ' ');
+          const orb = aspect.orb.padEnd(4, ' ');
+          
+          // Bestimme die Aspekt-Phase basierend auf der Bewegungsrichtung
+          const aspectAngles = {
+            'Konjunktion': 0,
+            'Opposition': 180,
+            'Quadrat': 90,
+            'Trigon': 120,
+            'Sextil': 60
+          };
+          
+          const phase = determineAspectPhase(
+            aspect.planet1, 
+            aspect.planet2, 
+            dateComponents, 
+            aspect.type, 
+            aspectAngles[aspect.type]
+          );
+          const statusPadded = phase.padEnd(11, ' ');
+          
+          console.log(`| ${planet1Padded} | ${planet2Padded} | ${angle}° | ${orb}° | ${statusPadded} |`);
+        });
+      }
+    });
+  }
+  
+  console.log('\n==========================================================================');
+  console.log(`Gesamt: ${sortedAspects.length} aktive Aspekte gefunden`);
+  
+  if (useBirthData) {
+    console.log('\nDiese Analyse basiert auf deinem Geburtshoroskop.');
+  } else {
+    console.log('\nDiese Analyse basiert auf der aktuellen Planetenposition.');
+  }
+  
+  console.log('(R) = Rückläufiger Planet');
+}
+
+module.exports = {
+  calculateHouses,
+  getPlanetHouse,
+  getAstrologicalData,
+  calculatePlanetAspects,
+  showPlanetAspects,
+  getAllActiveAspects,
+  showAllActiveAspects,
+  getBirthDataFromConfig,
+  getCriticalPlanets,
+  getCurrentTimeInTimezone,
+  getTimezoneOffset,
+  isPlanetRetrograde,
+  determineAspectPhase,
+  calculateJulianDayUTC,
+  analyzeElementDistribution,
+  getPastAspects,
+  getAspectAngle,
+  getFutureAspects
+};
+
+// Funktion zur Berechnung vergangener Aspekte zwischen zwei Planeten
+function getPastAspects(planet1, planet2, aspectType, count, endDate = null) {
+  // Standardmäßig verwenden wir das aktuelle Datum als Enddatum
+  if (!endDate) {
+    endDate = getCurrentTimeInTimezone();
+  }
+  
+  const pastAspects = [];
+  const targetAngle = getAspectAngle(aspectType);
+  
+  if (targetAngle === null) {
+    console.error(`Ungültiger Aspekt-Typ: ${aspectType}`);
+    return [];
+  }
+  
+  // Wir gehen rückwärts in der Zeit, beginnend vom Enddatum
+  // Jeder Schritt ist 1 Tag rückwärts
+  let currentDate = {...endDate};
+  
+  // Maximal 500 Jahre zurückgehen, um Endlosschleifen zu vermeiden
+  const maxYears = 500;
+  const daysToCheck = maxYears * 365;
+  
+  // Wir verwenden eine sehr kleine Toleranz für exakte Aspekte (0.00001 Grad)
+  const exactOrb = 0.01;
+  
+  // Gehe rückwärts durch die Zeit
+  for (let i = 0; i < daysToCheck && pastAspects.length < count; i++) {
+    // Berechne einen Tag früher
+    currentDate = subtractDays(currentDate, 1);
+    
+    // Berechne die Positionen der beiden Planeten
+    const planet1Data = getAstrologicalData(planet1, currentDate);
+    const planet2Data = getAstrologicalData(planet2, currentDate);
+    
+    // Berechne den Winkel zwischen den Planeten
+    const angleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
+    const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+    
+    // Prüfe, ob der Winkel exakt dem Zielwinkel entspricht (mit minimaler ranz)
+    if (Math.abs(normalizedAngle - targetAngle) <= exactOrb) {
+      // Prüfe, ob dies ein exakter Aspekt ist (nicht nur annähernd)
+      // Wir prüfen auch den nächsten Tag, um sicherzustellen, dass es sich um einen exakten Punkt handelt
+      const nextDate = addDays(currentDate, 1);
+      const planet1NextData = getAstrologicalData(planet1, nextDate);
+      const planet2NextData = getAstrologicalData(planet2, nextDate);
+      
+      const nextAngleDiff = Math.abs(planet1NextData.longitude - planet2NextData.longitude) % 360;
+      const nextNormalizedAngle = Math.min(nextAngleDiff, 360 - nextAngleDiff);
+      
+      // Wenn der Winkel sich vom Ziel entfernt, ist dies ein exakter Aspekt
+      const currentDistance = Math.abs(normalizedAngle - targetAngle);
+      const nextDistance = Math.abs(nextNormalizedAngle - targetAngle);
+      
+      if (nextDistance > currentDistance) {
+        // Dies ist ein exakter Aspekt
+        // Wir prüfen auch, ob dieser Aspekt bereits in der Liste ist (mit 3 Tagen Abstand)
+        const isDuplicate = pastAspects.some(aspect => {
+          const daysDiff = Math.abs(
+            new Date(aspect.date.year, aspect.date.month - 1, aspect.date.day) -
+            new Date(currentDate.year, currentDate.month - 1, currentDate.day)
+          ) / (1000 * 60 * 60 * 24);
+          return daysDiff < 3; // Mindestens 3 Tage Abstand zwischen Aspekten
+        });
+        
+        if (!isDuplicate) {
+          pastAspects.push({
+            date: {...currentDate},
+            planet1: planet1,
+            planet2: planet2,
+            type: aspectType,
+            angle: normalizedAngle.toFixed(2),
+            planet1Position: `${planet1Data.sign} ${planet1Data.degreeInSign}°`,
+            planet2Position: `${planet2Data.sign} ${planet2Data.degreeInSign}°`
+          });
+        }
+      }
+    }
+  }
+  
+  return pastAspects;
+}
+
+// Hilfsfunktion zur Bestimmung des Zielwinkels für einen Aspekt
+function getAspectAngle(aspectType) {
+  const aspectAngles = {
+    'k': 0,      // Konjunktion
+    'konjunktion': 0,
+    'o': 180,    // Opposition
+    'opposition': 180,
+    'q': 90,     // Quadrat
+    'quadrat': 90,
+    't': 120,    // Trigon
+    'trigon': 120,
+    's': 60,     // Sextil
+    'sextil': 60
+  };
+  
+  return aspectAngles[aspectType.toLowerCase()] !== undefined 
+    ? aspectAngles[aspectType.toLowerCase()] 
+    : null;
+}
+
+// Hilfsfunktion zum Subtrahieren von Tagen von einem Datum (unterstützt auch gebrochene Tage)
+function subtractDays(date, days) {
+  // Konvertiere das Datum in Millisekunden seit Epoche
+  const originalDate = new Date(date.year, date.month - 1, date.day, date.hour, date.minute);
+  const millisecondsPerDay = 24 * 60 * 60 * 1000;
+  const millisecondsToSubtract = days * millisecondsPerDay;
+  
+  const newDate = new Date(originalDate.getTime() - millisecondsToSubtract);
+  return {
+    year: newDate.getFullYear(),
+    month: newDate.getMonth() + 1,
+    day: newDate.getDate(),
+    hour: newDate.getHours(),
+    minute: newDate.getMinutes()
+  };
+}
+
+// Hilfsfunktion zum Addieren von Tagen zu einem Datum (unterstützt auch gebrochene Tage)
+function addDays(date, days) {
+  // Konvertiere das Datum in Millisekunden seit Epoche
+  const originalDate = new Date(date.year, date.month - 1, date.day, date.hour, date.minute);
+  const millisecondsPerDay = 24 * 60 * 60 * 1000;
+  const millisecondsToAdd = days * millisecondsPerDay;
+  
+  const newDate = new Date(originalDate.getTime() + millisecondsToAdd);
+  return {
+    year: newDate.getFullYear(),
+    month: newDate.getMonth() + 1,
+    day: newDate.getDate(),
+    hour: newDate.getHours(),
+    minute: newDate.getMinutes()
+  };
+}
+
+// Funktion zur Berechnung zukünftiger Aspekte zwischen zwei Planeten
+function getFutureAspects(planet1, planet2, aspectType, count, startDate = null) {
+  // Standardmäßig verwenden wir das aktuelle Datum als Startdatum
+  if (!startDate) {
+    startDate = getCurrentTimeInTimezone();
+  }
+  
+  const futureAspects = [];
+  const targetAngle = getAspectAngle(aspectType);
+  
+  if (targetAngle === null) {
+    console.error(`Ungültiger Aspekt-Typ: ${aspectType}`);
+    return [];
+  }
+  
+  // Wir gehen vorwärts in der Zeit, beginnend vom Startdatum
+  let currentDate = {...startDate};
+  
+  // Maximal 1000 Jahre vorwärts gehen, um Endlosschleifen zu vermeiden
+  const maxYears = 1000;
+  const daysToCheck = maxYears * 365;
+  
+  // Wir verwenden eine größere Toleranz für exakte Aspekte (0.5 Grad)
+  const exactOrb = 0.01;
+  
+  // Bestimme die Schrittgröße basierend auf den Planeten
+  // Für langsame Planeten (Saturn, Uranus, Neptun, Pluto) verwenden wir kleinere Schritte
+  const slowPlanets = ['saturn', 'uranus', 'neptun', 'pluto'];
+  const isSlowAspect = slowPlanets.includes(planet1) && slowPlanets.includes(planet2);
+  const stepSize = isSlowAspect ? 0.1 : 1; // 0.1 Tage für langsame Planeten, 1 Tag für schnelle
+  
+  // Gehe vorwärts durch die Zeit
+  let i = 0;
+  while (i < daysToCheck && futureAspects.length < count) {
+    // Berechne den nächsten Schritt
+    currentDate = addDays(currentDate, stepSize);
+    
+    // Berechne die Positionen der beiden Planeten
+    const planet1Data = getAstrologicalData(planet1, currentDate);
+    const planet2Data = getAstrologicalData(planet2, currentDate);
+    
+    // Berechne den Winkel zwischen den Planeten
+    const angleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
+    const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+    
+    // Prüfe, ob der Winkel exakt dem Zielwinkel entspricht (mit minimaler Toleranz)
+    if (Math.abs(normalizedAngle - targetAngle) <= exactOrb) {
+      // Prüfe, ob dies ein exakter Aspekt ist (nicht nur annähernd)
+      // Wir prüfen auch den vorherigen Schritt, um sicherzustellen, dass es sich um einen exakten Punkt handelt
+      const prevDate = subtractDays(currentDate, stepSize);
+      const planet1PrevData = getAstrologicalData(planet1, prevDate);
+      const planet2PrevData = getAstrologicalData(planet2, prevDate);
+      
+      const prevAngleDiff = Math.abs(planet1PrevData.longitude - planet2PrevData.longitude) % 360;
+      const prevNormalizedAngle = Math.min(prevAngleDiff, 360 - prevAngleDiff);
+      
+      // Wenn der Winkel sich dem Ziel nähert, ist dies ein exakter Aspekt
+      const currentDistance = Math.abs(normalizedAngle - targetAngle);
+      const prevDistance = Math.abs(prevNormalizedAngle - targetAngle);
+      
+      if (currentDistance < prevDistance) {
+        // Dies ist ein exakter Aspekt
+        // Wir prüfen auch, ob dieser Aspekt bereits in der Liste ist (mit 3 Tagen Abstand)
+        const isDuplicate = futureAspects.some(aspect => {
+          const daysDiff = Math.abs(
+            new Date(aspect.date.year, aspect.date.month - 1, aspect.date.day) -
+            new Date(currentDate.year, currentDate.month - 1, currentDate.day)
+          ) / (1000 * 60 * 60 * 24);
+          return daysDiff < 3; // Mindestens 3 Tage Abstand zwischen Aspekten
+        });
+        
+        if (!isDuplicate) {
+          futureAspects.push({
+            date: {...currentDate},
+            planet1: planet1,
+            planet2: planet2,
+            type: aspectType,
+            angle: normalizedAngle.toFixed(2),
+            planet1Position: `${planet1Data.sign} ${planet1Data.degreeInSign}°`,
+            planet2Position: `${planet2Data.sign} ${planet2Data.degreeInSign}°`
+          });
+        }
+      }
+    }
+    
+    i += stepSize;
+  }
+  
+  return futureAspects;
+}