klio 1.2.6 → 1.2.9

package/README.md

@@ -119,6 +119,7 @@ Aspekte für Mond:
 
 Diese Analyse basiert auf der aktuellen Planetenposition.
 ```
+Kombiniere mit `--i --tr` und `--hs koch` für persönliche Transit-Aspekte
 
 ### Aspekte für einen Planeten (Geburtshoroskop)
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klio",
-  "version": "1.2.6",
+  "version": "1.2.9",
   "description": "Eine CLI für astrologische Berechnungen",
   "main": "src/main.js",
   "bin": {

package/src/astrology/astrologyService.js

@@ -148,7 +148,6 @@ function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false)
       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;
@@ -269,6 +268,9 @@ function getAstrologicalData(planetName, customDate = null) {
 
   // Verwende das angegebene Datum oder das aktuelle Datum (mit Zeitzonenberücksichtigung)
   let calcYear, calcMonth, calcDay, calcHour, calcMinute;
+  let timezoneOffsetMinutes;
+  let timezone = null;
+  let baseDate;
   
   if (customDate) {
     calcYear = customDate.year;
@@ -276,6 +278,18 @@ function getAstrologicalData(planetName, customDate = null) {
     calcDay = customDate.day;
     calcHour = customDate.hour;
     calcMinute = customDate.minute;
+    baseDate = customDate;
+    // Versuche, die Zeitzone vom customDate abzuleiten (z.B. Geburtsort)
+    if (customDate.location && customDate.location.timezone) {
+      timezone = customDate.location.timezone;
+    } else {
+      try {
+        const config = loadConfig();
+        if (config && config.currentLocation && config.currentLocation.timezone) {
+          timezone = config.currentLocation.timezone;
+        }
+      } catch (_) {}
+    }
   } else {
     // Verwende die aktuelle Zeit in der konfigurierten Zeitzone
     const timeData = getCurrentTimeInTimezone();
@@ -284,9 +298,24 @@ function getAstrologicalData(planetName, customDate = null) {
     calcDay = timeData.day;
     calcHour = timeData.hour;
     calcMinute = timeData.minute;
+    baseDate = timeData;
+    try {
+      const config = loadConfig();
+      if (config && config.currentLocation && config.currentLocation.timezone) {
+        timezone = config.currentLocation.timezone;
+      }
+    } catch (_) {}
   }
 
-  const julianDay = swisseph.swe_julday(calcYear, calcMonth, calcDay, calcHour + calcMinute / 60, swisseph.SE_GREG_CAL);
+  // Bestimme Offset in Minuten (Lokalzeit - UTC)
+  if (timezone) {
+    timezoneOffsetMinutes = getTimezoneOffset({ year: calcYear, month: calcMonth, day: calcDay, hour: calcHour, minute: calcMinute }, timezone);
+  } else {
+    // Fallback: Systemoffset umkehren, damit (Lokalzeit - UTC) entsteht
+    timezoneOffsetMinutes = -new Date().getTimezoneOffset();
+  }
+
+  const julianDay = calculateJulianDayUTC({ year: calcYear, month: calcMonth, day: calcDay, hour: calcHour, minute: calcMinute }, timezoneOffsetMinutes);
   const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
   const result = swisseph.swe_calc_ut(julianDay, planet, flag);
 
@@ -341,13 +370,18 @@ function getCriticalPlanets(customDate = null) {
     timeData = getCurrentTimeInTimezone();
   }
   
-  const julianDay = swisseph.swe_julday(
-    timeData.year, 
-    timeData.month, 
-    timeData.day, 
-    timeData.hour + timeData.minute / 60, 
-    swisseph.SE_GREG_CAL
-  );
+  // Berücksichtige die lokale Zeitzone für die Umrechnung nach UTC
+  let timezone = null;
+  try {
+    const config = loadConfig();
+    if (customDate && customDate.location && customDate.location.timezone) {
+      timezone = customDate.location.timezone;
+    } else if (config && config.currentLocation && config.currentLocation.timezone) {
+      timezone = config.currentLocation.timezone;
+    }
+  } catch (_) {}
+  const offsetMinutes = timezone ? getTimezoneOffset(timeData, timezone) : -new Date().getTimezoneOffset();
+  const julianDay = calculateJulianDayUTC(timeData, offsetMinutes);
   
   // Berechne Positionen aller Planeten
   for (const [name, planetId] of Object.entries(planets)) {
@@ -480,19 +514,19 @@ function findExactAspectTime(planet1, planet2, aspectType, startDate) {
     return null;
   }
   
-  // Wir suchen in einem größeren Zeitfenster (180 Tage vor und nach dem Startdatum)
-  // um den exakten Aspekt zu finden, egal ob in Vergangenheit oder Zukunft
+  // Wir suchen in einem vernünftigen Zeitfenster (90 Tage in der Zukunft)
+  // um den nächsten exakten Aspekt zu finden
   // Besonders wichtig für langsame Planeten wie Saturn, Uranus, Neptun, Pluto
   let bestMatch = null;
   let bestDistance = Infinity;
   
-  // Suche in einem Zeitfenster von 180 Tagen vor und nach dem Startdatum
-  const searchWindow = 180; // Tage
+  // Suche nur in der Zukunft (0-90 Tage nach dem Startdatum)
+  const searchWindow = 90; // Tage
   
-  // Wir suchen auch in kleineren Schritten (alle 3 Stunden), um präzisere Ergebnisse zu erhalten
-  const stepsPerDay = 8; // 3-Stunden-Schritte
+  // Wir suchen in kleineren Schritten (alle 2 Stunden), um präzisere Ergebnisse zu erhalten
+  const stepsPerDay = 12; // 2-Stunden-Schritte
   
-  for (let daysOffset = -searchWindow; daysOffset <= searchWindow; daysOffset++) {
+  for (let daysOffset = 0; daysOffset <= searchWindow; daysOffset++) {
     for (let hourOffset = 0; hourOffset < 24; hourOffset++) { // Jede Stunde
       for (let minuteOffset = 0; minuteOffset < 60; minuteOffset += 5) { // Alle 5 Minuten
         const testDate = addDays(startDate, daysOffset);
@@ -518,7 +552,56 @@ function findExactAspectTime(planet1, planet2, aspectType, startDate) {
   }
   
   // Wenn wir einen Aspekt gefunden haben, der nah genug am Ziel ist, geben wir ihn zurück
-  if (bestMatch && bestDistance <= 1.0) { // Toleranz von 1.0°
+  // Strengere Toleranz von 0.5° für bessere Genauigkeit
+  if (bestMatch && bestDistance <= 0.5) { // Toleranz von 0.5°
+    return bestMatch;
+  }
+  
+  return null;
+}
+
+// Funktion zum Finden des letzten exakten Aspekts in der Vergangenheit (für separative Phasen)
+function findLastExactAspectTime(planet1, planet2, aspectType, startDate) {
+  const targetAngle = getAspectAngle(aspectType);
+  
+  if (targetAngle === null) {
+    return null;
+  }
+  
+  // Suche in der Vergangenheit (bis zu 180 Tage vor dem Startdatum)
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  
+  // Suche in einem Zeitfenster von 180 Tagen vor dem Startdatum
+  const searchWindow = 180; // Tage
+  
+  for (let daysOffset = -searchWindow; daysOffset <= 0; daysOffset++) {
+    for (let hourOffset = 0; hourOffset < 24; hourOffset++) { // Jede Stunde
+      for (let minuteOffset = 0; minuteOffset < 60; minuteOffset += 5) { // Alle 5 Minuten
+        const testDate = addDays(startDate, daysOffset);
+        testDate.hour = hourOffset;
+        testDate.minute = minuteOffset;
+        
+        // Berechne die Positionen der beiden Planeten
+        const planet1Data = getAstrologicalData(planet1, testDate);
+        const planet2Data = getAstrologicalData(planet2, testDate);
+        
+        // Berechne den Winkel zwischen den Planeten
+        const angleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
+        const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+        const distanceToTarget = Math.abs(normalizedAngle - targetAngle);
+        
+        // Speichere das beste Ergebnis
+        if (distanceToTarget < bestDistance) {
+          bestDistance = distanceToTarget;
+          bestMatch = {...testDate};
+        }
+      }
+    }
+  }
+  
+  // Wenn wir einen Aspekt gefunden haben, der nah genug am Ziel ist, geben wir ihn zurück
+  if (bestMatch && bestDistance <= 0.5) { // Toleranz von 0.5°
     return bestMatch;
   }
   
@@ -565,13 +648,16 @@ function isPlanetRetrograde(planetName, dateComponents) {
     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
-    );
+    // Konvertiere Datum zu UTC basierend auf konfigurierter Zeitzone
+    let tz = null;
+    try {
+      const config = loadConfig();
+      if (config && config.currentLocation && config.currentLocation.timezone) {
+        tz = config.currentLocation.timezone;
+      }
+    } catch (_) {}
+    const off = tz ? getTimezoneOffset(dateComponents, tz) : -new Date().getTimezoneOffset();
+    const julianDay = calculateJulianDayUTC(dateComponents, off);
     
     const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
     const result = swisseph.swe_calc_ut(julianDay, planet, flag);
@@ -1132,6 +1218,213 @@ async function calculatePersonalTransits(transitDate = null, birthData = null) {
   };
 }
 
+// Funktion zur Berechnung persönlicher Transit-Aspekte
+function calculatePersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null) {
+  if (!birthData) {
+    birthData = getBirthDataFromConfig();
+    if (!birthData) {
+      console.error('Keine Geburtsdaten verfügbar für persönliche Transit-Aspekte.');
+      return null;
+    }
+  }
+
+  // Verwende aktuelles Datum, wenn kein Transitdatum angegeben
+  if (!transitDate) {
+    transitDate = getCurrentTimeInTimezone();
+  }
+
+  // Berechne aktuelle Planetenpositionen (Transit)
+  const transitPlanets = {};
+  for (const [name, planetId] of Object.entries(planets)) {
+    const data = getAstrologicalData(name, transitDate);
+    transitPlanets[name] = data.longitude;
+  }
+
+  // Berechne Geburtsplanetenpositionen (Radix)
+  const birthPlanets = {};
+  for (const [name, planetId] of Object.entries(planets)) {
+    const data = getAstrologicalData(name, birthData);
+    birthPlanets[name] = data.longitude;
+  }
+
+  // Berechne Aspekte zwischen Transit- und Geburtsplaneten
+  const aspects = [];
+  const aspectTypes = [
+    { 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 }
+  ];
+
+  // Vergleiche jeden Transitplaneten mit jedem Geburtsplaneten
+  for (const [transitName, transitLongitude] of Object.entries(transitPlanets)) {
+    for (const [birthName, birthLongitude] of Object.entries(birthPlanets)) {
+      // Überspringe, wenn es sich um denselben Planeten handelt
+      if (transitName === birthName) continue;
+
+      // Berechne den Winkelunterschied
+      const angleDiff = Math.abs(transitLongitude - birthLongitude) % 360;
+      const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+
+      // Prüfe auf Aspekte
+      for (const aspect of aspectTypes) {
+        if (Math.abs(normalizedAngle - aspect.angle) <= aspect.orb) {
+          aspects.push({
+            transitPlanet: transitName,
+            birthPlanet: birthName,
+            type: aspect.name,
+            angle: normalizedAngle.toFixed(2),
+            orb: Math.abs(normalizedAngle - aspect.angle).toFixed(2),
+            transitLongitude: transitLongitude,
+            birthLongitude: birthLongitude
+          });
+        }
+      }
+    }
+  }
+
+  // Filtere nach Zielplanet, falls angegeben
+  const filteredAspects = targetPlanet 
+    ? aspects.filter(aspect => aspect.transitPlanet === targetPlanet)
+    : aspects;
+
+  return {
+    transitDate: transitDate,
+    birthData: birthData,
+    aspects: filteredAspects
+  };
+}
+
+// Funktion zur Anzeige persönlicher Transit-Aspekte
+function showPersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null) {
+  const aspectData = calculatePersonalTransitAspects(transitDate, birthData, targetPlanet);
+  
+  if (!aspectData || aspectData.aspects.length === 0) {
+    console.log('Keine persönlichen Transit-Aspekte gefunden.');
+    return;
+  }
+
+  const transitDateDisplay = transitDate || getCurrentTimeInTimezone();
+  console.log(`Persönliche Transit-Aspekte (${transitDateDisplay.day}.${transitDateDisplay.month}.${transitDateDisplay.year}):`);
+  console.log('================================================================================');
+  console.log('| Transit     | Geburts    | Aspekt      | Orb   | Transit Pos | Geburts Pos |');
+  console.log('================================================================================');
+
+  // Hole zusätzliche Informationen für die Anzeige
+  const transitPlanetsData = {};
+  const birthPlanetsData = {};
+  
+  for (const [name] of Object.entries(planets)) {
+    transitPlanetsData[name] = getAstrologicalData(name, transitDateDisplay);
+    birthPlanetsData[name] = getAstrologicalData(name, birthData);
+  }
+
+  aspectData.aspects.forEach(aspect => {
+    const transitPlanetData = transitPlanetsData[aspect.transitPlanet];
+    const birthPlanetData = birthPlanetsData[aspect.birthPlanet];
+    
+    const transitPlanetFormatted = aspect.transitPlanet.charAt(0).toUpperCase() + aspect.transitPlanet.slice(1);
+    const birthPlanetFormatted = aspect.birthPlanet.charAt(0).toUpperCase() + aspect.birthPlanet.slice(1);
+    const aspectName = aspect.type.padEnd(11, ' ');
+    const orb = aspect.orb.padEnd(4, ' ');
+    const transitPos = `${transitPlanetData.sign} ${transitPlanetData.degreeInSign}°`;
+    const birthPos = `${birthPlanetData.sign} ${birthPlanetData.degreeInSign}°`;
+    
+    console.log(`| ${transitPlanetFormatted.padEnd(10)} | ${birthPlanetFormatted.padEnd(10)} | ${aspectName} | ${orb}° | ${transitPos.padEnd(11)} | ${birthPos.padEnd(11)} |`);
+  });
+
+  console.log('================================================================================');
+  console.log(`Gesamt: ${aspectData.aspects.length} persönliche Transit-Aspekte gefunden`);
+  console.log('\nErklärung: Diese Aspekte zeigen, wie die aktuellen Planetenpositionen');
+  console.log('mit deinen Geburtspositionen interagieren (Transit → Radix).');
+}
+
+// Funktion für kombinierte Analyse (Geburts- und Transit-Aspekte mit Häusern)
+async function showCombinedAnalysis(planetName, transitDate = null, birthData = null, houseSystem = 'K') {
+  if (!birthData) {
+    birthData = getBirthDataFromConfig();
+    if (!birthData) {
+      console.error('Keine Geburtsdaten verfügbar für kombinierte Analyse.');
+      return null;
+    }
+  }
+
+  // Verwende aktuelles Datum, wenn kein Transitdatum angegeben
+  if (!transitDate) {
+    transitDate = getCurrentTimeInTimezone();
+  }
+
+  // Berechne Häuser basierend auf Geburtsdaten
+  const birthJulianDay = calculateJulianDayUTC(birthData, getTimezoneOffset(birthData, birthData.location?.timezone || 'Europe/Zurich'));
+  const houses = await calculateHouses(birthJulianDay, houseSystem === 'koch' ? 'K' : houseSystem === 'wholesign' ? 'W' : 'G', true);
+
+  // Berechne aktuelle Planetenpositionen (Transit)
+  const transitPlanetData = getAstrologicalData(planetName, transitDate);
+  const transitLongitude = transitPlanetData.longitude;
+  const transitHouse = getPlanetHouse(transitLongitude, houses.house);
+
+  // Berechne Geburtsplanetenpositionen (Radix)
+  const birthPlanetData = getAstrologicalData(planetName, birthData);
+  const birthLongitude = birthPlanetData.longitude;
+  const birthHouse = getPlanetHouse(birthLongitude, houses.house);
+
+  // Berechne Geburtsaspekte für den Planeten
+  const birthAspects = calculatePlanetAspects(planetName, birthData, true);
+
+  // Berechne Transit-Aspekte für den Planeten
+  const transitAspectsData = calculatePersonalTransitAspects(transitDate, birthData, planetName);
+  const transitAspects = transitAspectsData ? transitAspectsData.aspects : [];
+
+  // Zeige kombinierte Analyse an
+  console.log(`Kombinierte Analyse für ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}:`);
+  console.log('================================================================================');
+  console.log(`Analyse-Datum: ${transitDate.day}.${transitDate.month}.${transitDate.year}`);
+  console.log(`Geburtsdatum: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+  console.log('');
+
+  // Zeige Planetenpositionen und Häuser
+  console.log('Positionen und Häuser:');
+  console.log('--------------------------------------------------------------------------------');
+  console.log(`Transit: ${transitPlanetData.sign} ${transitPlanetData.degreeInSign}° (Haus ${transitHouse})`);
+  console.log(`Geburt:  ${birthPlanetData.sign} ${birthPlanetData.degreeInSign}° (Haus ${birthHouse})`);
+  console.log('');
+
+  // Zeige Geburtsaspekte
+  if (birthAspects.length > 0) {
+    console.log('Geburtsaspekte (Radix → Radix):');
+    console.log('--------------------------------------------------------------------------------');
+    birthAspects.forEach(aspect => {
+      const aspectPlanetData = getAstrologicalData(aspect.planet, birthData);
+      const aspectHouse = getPlanetHouse(parseFloat(aspectPlanetData.degreeInSign) + (signs.indexOf(aspectPlanetData.sign) * 30), houses.house);
+      console.log(`${aspect.type.padEnd(12)} mit ${aspect.planet.padEnd(8)} (${aspectPlanetData.sign} ${aspectPlanetData.degreeInSign}° Haus ${aspectHouse}) - Orb: ${aspect.orb}°`);
+    });
+    console.log('');
+  }
+
+  // Zeige Transit-Aspekte
+  if (transitAspects.length > 0) {
+    console.log('Transit-Aspekte (Transit → Radix):');
+    console.log('--------------------------------------------------------------------------------');
+    transitAspects.forEach(aspect => {
+      const birthPlanetData = getAstrologicalData(aspect.birthPlanet, birthData);
+      const birthHouse = getPlanetHouse(parseFloat(birthPlanetData.degreeInSign) + (signs.indexOf(birthPlanetData.sign) * 30), houses.house);
+      console.log(`${aspect.type.padEnd(12)} mit ${aspect.birthPlanet.padEnd(8)} (${birthPlanetData.sign} ${birthPlanetData.degreeInSign}° Haus ${birthHouse}) - Orb: ${aspect.orb}°`);
+    });
+    console.log('');
+  }
+
+  return {
+    transitPlanetData,
+    birthPlanetData,
+    transitHouse,
+    birthHouse,
+    birthAspects,
+    transitAspects,
+    houses
+  };
+}
+
 // Funktion zur Analyse der Elementverteilung
 function analyzeElementDistribution(dateComponents, useBirthData = false) {
   const elementCounts = {
@@ -1321,9 +1614,13 @@ module.exports = {
   getAspectAngle,
   getFutureAspects,
   findExactAspectTime,
+  findLastExactAspectTime,
   detectAspectFigures,
   showAspectFigures,
-  calculatePersonalTransits
+  calculatePersonalTransits,
+  calculatePersonalTransitAspects,
+  showPersonalTransitAspects,
+  showCombinedAnalysis
 };
 
 // Funktion zur Berechnung vergangener Aspekte zwischen zwei Planeten

package/src/cli/cli.js

@@ -1,7 +1,7 @@
 const { Command } = require('commander');
 const { planets, signs } = require('../astrology/astrologyConstants');
 const { showRetrogradePlanets } = require('../astrology/retrogradeService');
-const { getCurrentTimeInTimezone, showAspectFigures, analyzeElementDistribution, getTimezoneOffset, calculateJulianDayUTC, calculateHouses, getAstrologicalData, getPlanetHouse, showPlanetAspects, calculatePlanetAspects, getAllActiveAspects, showAllActiveAspects, getBirthDataFromConfig, detectAspectFigures, calculatePersonalTransits } = require('../astrology/astrologyService');
+const { getCurrentTimeInTimezone, showAspectFigures, analyzeElementDistribution, getTimezoneOffset, calculateJulianDayUTC, calculateHouses, getAstrologicalData, getPlanetHouse, showPlanetAspects, calculatePlanetAspects, getAllActiveAspects, showAllActiveAspects, getBirthDataFromConfig, detectAspectFigures, calculatePersonalTransits, showPersonalTransitAspects, showCombinedAnalysis, calculatePersonalTransitAspects, determineAspectPhase, findExactAspectTime, findLastExactAspectTime, getAspectAngle, getFutureAspects, getPastAspects } = require('../astrology/astrologyService');
 const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel } = require('../config/configService');
 const { parseAppleHealthXML } = require('../health/healthService');
 const { analyzeStepsByPlanetSign, analyzeStressByPlanetAspects, analyzePlanetAspectsForSleep } = require('../health/healthAnalysis');
@@ -110,6 +110,8 @@ program
   .option('--el', 'Zeigt die Elementverteilung der Planeten in einem horizontalen Chart an')
   .option('--af', 'Zeigt aktive Aspektfiguren wie T-Quadrate, Große Trigone, etc. an')
   .option('--transite', 'Zeigt persönliche Transite basierend auf Geburtsdaten an')
+  .option('--transit-aspekte', 'Zeigt persönliche Transit-Aspekte (Transit → Radix) an')
+  .option('--tr', 'Zeigt persönliche Transit-Aspekte (Transit → Radix) an (Kurzform)')
   .option('--v <count>', 'Zeigt vergangene Aspekte zwischen zwei Planeten an (Format: --v <count> planet1 aspectType planet2)')
   .option('--z <count>', 'Zeigt zukünftige Aspekte zwischen zwei Planeten an (Format: --z <count> planet1 aspectType planet2)')
   .description('Zeigt astrologische Daten für einen Planeten an')
@@ -408,6 +410,185 @@ program
       return;
     }
 
+    // Kombinierte Analyse anzeigen, falls --a --i und --tr (oder --transit-aspekte) zusammen mit --hs angegeben
+    if ((options.a && shouldUseBirthData(options) && (options.transitAspekte || options.tr)) || 
+        (options.transitAspekte || options.tr) && options.hs) {
+      
+      // Geburtsdaten sind erforderlich
+      const birthData = getBirthDataFromConfig();
+      if (!birthData) {
+        console.error('Fehler: Kombinierte Analyse erfordert Geburtsdaten. Bitte führe --setup aus.');
+        process.exit(1);
+      }
+
+      // Benutzerdefiniertes Datum verwenden, falls angegeben
+      let transitDate = null;
+      if (options.d) {
+        // Versuche, das Datum als DD.MM.YYYY oder DD.MM.YYYY HH:MM zu parsen
+        const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+        const match = options.d.match(dateRegex);
+        
+        if (match) {
+          const day = parseInt(match[1], 10);
+          const month = parseInt(match[2], 10);
+          const year = parseInt(match[3], 10);
+          const hour = match[4] ? parseInt(match[4], 10) : 12; // Standard: 12 Uhr
+          const minute = match[5] ? parseInt(match[5], 10) : 0; // Standard: 0 Minuten
+          
+          // Überprüfe, ob das Datum gültig ist
+          const date = new Date(year, month - 1, day, hour, minute);
+          if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+            transitDate = {
+              day: day,
+              month: month,
+              year: year,
+              hour: hour,
+              minute: minute
+            };
+          } else {
+            console.error('Ungültiges Datum:', options.d);
+            console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM"');
+            process.exit(1);
+          }
+        } else {
+          console.error('Ungültiges Datum:', options.d);
+          console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM"');
+          process.exit(1);
+        }
+      }
+
+      // Haus-System bestimmen
+      const houseSystem = options.hs ? options.hs.toLowerCase() : 'koch';
+      
+      // Zeige kombinierte Analyse an
+      const targetPlanet = planetArg ? planetArg.toLowerCase() : null;
+      if (targetPlanet) {
+        await showCombinedAnalysis(targetPlanet, transitDate, birthData, houseSystem);
+      } else {
+        // Wenn kein Planet angegeben ist, zeige NUR die Transit-Aspekte-Tabelle
+        console.log('Transit-Aspekte (Transit → Radix):');
+        console.log('================================================================================');
+        console.log('| Transit     | Aspekt      | Mit Planet | Orb   | Transit Pos      | Transit Haus | Geburts Haus | Phase       | Exaktes Datum/Uhrzeit  |');
+        console.log('================================================================================');
+
+        // Berechne Häuser einmal für alle Planeten
+        const birthJulianDay = calculateJulianDayUTC(birthData, getTimezoneOffset(birthData, birthData.location?.timezone || 'Europe/Zurich'));
+        const houses = await calculateHouses(birthJulianDay, houseSystem === 'koch' ? 'K' : houseSystem === 'wholesign' ? 'W' : 'G', true);
+        const transitDateDisplay = transitDate || getCurrentTimeInTimezone();
+
+        // Zeige Transit-Aspekte für alle Planeten
+        for (const [planetName] of Object.entries(planets)) {
+          const transitPlanetData = getAstrologicalData(planetName, transitDateDisplay);
+          const transitHouse = getPlanetHouse(parseFloat(transitPlanetData.degreeInSign) + (signs.indexOf(transitPlanetData.sign) * 30), houses.house);
+          const transitAspectsData = calculatePersonalTransitAspects(transitDateDisplay, birthData, planetName);
+          const transitAspects = transitAspectsData ? transitAspectsData.aspects : [];
+          if (transitAspects.length > 0) {
+            transitAspects.forEach(aspect => {
+              const birthPlanetData = getAstrologicalData(aspect.birthPlanet, birthData);
+              const birthHouse = getPlanetHouse(parseFloat(birthPlanetData.degreeInSign) + (signs.indexOf(birthPlanetData.sign) * 30), houses.house);
+              
+              // Bestimme die Aspekt-Phase
+              const aspectAngles = {
+                'Konjunktion': 0,
+                'Opposition': 180,
+                'Quadrat': 90,
+                'Trigon': 120,
+                'Sextil': 60
+              };
+              const targetAngle = aspectAngles[aspect.type];
+              const phase = determineAspectPhase(planetName, aspect.birthPlanet, transitDateDisplay, aspect.type, targetAngle);
+              
+              // Berechne das genaue Datum und die Uhrzeit für diesen Aspekt
+              const exactDateTime = findExactAspectTime(planetName, aspect.birthPlanet, aspect.type, transitDateDisplay);
+              let dateTimeStr = '-';
+              if (exactDateTime) {
+                dateTimeStr = `${String(exactDateTime.day).padStart(2, '0')}.${String(exactDateTime.month).padStart(2, '0')}.${exactDateTime.year} ${String(exactDateTime.hour).padStart(2, '0')}:${String(exactDateTime.minute).padStart(2, '0')}`;
+              } else if (phase === 'separativ') {
+                // Für separative Phasen: Suche das letzte exakte Datum in der Vergangenheit
+                const lastExactDateTime = findLastExactAspectTime(planetName, aspect.birthPlanet, aspect.type, transitDateDisplay);
+                if (lastExactDateTime) {
+                  dateTimeStr = `${String(lastExactDateTime.day).padStart(2, '0')}.${String(lastExactDateTime.month).padStart(2, '0')}.${lastExactDateTime.year} ${String(lastExactDateTime.hour).padStart(2, '0')}:${String(lastExactDateTime.minute).padStart(2, '0')} (e)`;
+                }
+              }
+              
+              const transitPlanetFormatted = planetName.charAt(0).toUpperCase() + planetName.slice(1);
+              const aspectTypeFormatted = aspect.type.padEnd(11);
+              const aspectPlanetFormatted = aspect.birthPlanet.charAt(0).toUpperCase() + aspect.birthPlanet.slice(1);
+              const orbFormatted = aspect.orb.padEnd(4);
+              const transitPosFormatted = `${transitPlanetData.sign} ${transitPlanetData.degreeInSign}°`;
+              const transitHouseFormatted = transitHouse.toString().padEnd(11);
+              const birthHouseFormatted = birthHouse.toString().padEnd(11);
+              const phaseFormatted = phase === 'separativ' ? 'separativ'.padEnd(11) : phase.padEnd(11);
+              const dateTimeFormatted = dateTimeStr.padEnd(22);
+              
+              console.log(`| ${transitPlanetFormatted.padEnd(10)} | ${aspectTypeFormatted} | ${aspectPlanetFormatted.padEnd(10)} | ${orbFormatted}° | ${transitPosFormatted.padEnd(16)} | ${transitHouseFormatted} | ${birthHouseFormatted} | ${phaseFormatted} | ${dateTimeFormatted} |`);
+            });
+          }
+        }
+
+        console.log('================================================================================');
+        console.log(`\nAnalyse-Datum: ${transitDateDisplay.day}.${transitDateDisplay.month}.${transitDateDisplay.year}`);
+        console.log(`Geburtsdatum: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+
+      }
+      
+      return;
+    }
+
+    // Persönliche Transit-Aspekte anzeigen, falls --transit-aspekte oder --tr Option angegeben
+    if (options.transitAspekte || options.tr) {
+      // Geburtsdaten sind für Transit-Aspekte erforderlich
+      const birthData = getBirthDataFromConfig();
+      if (!birthData) {
+        console.error('Fehler: Persönliche Transit-Aspekte erfordern Geburtsdaten. Bitte führe --setup aus, um deine Geburtsdaten zu konfigurieren.');
+        process.exit(1);
+      }
+
+      // Benutzerdefiniertes Datum verwenden, falls angegeben
+      let transitDate = null;
+      if (options.d) {
+        // Versuche, das Datum als DD.MM.YYYY oder DD.MM.YYYY HH:MM zu parsen
+        const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+        const match = options.d.match(dateRegex);
+        
+        if (match) {
+          const day = parseInt(match[1], 10);
+          const month = parseInt(match[2], 10);
+          const year = parseInt(match[3], 10);
+          const hour = match[4] ? parseInt(match[4], 10) : 12; // Standard: 12 Uhr
+          const minute = match[5] ? parseInt(match[5], 10) : 0; // Standard: 0 Minuten
+          
+          // Überprüfe, ob das Datum gültig ist
+          const date = new Date(year, month - 1, day, hour, minute);
+          if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+            transitDate = {
+              day: day,
+              month: month,
+              year: year,
+              hour: hour,
+              minute: minute
+            };
+            console.log(`Verwende Transitdatum: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+          } else {
+            console.error('Ungültiges Datum:', options.d);
+            console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM" (mit Anführungszeichen für Datum mit Uhrzeit)');
+            process.exit(1);
+          }
+        } else {
+          console.error('Ungültiges Datum:', options.d);
+          console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM" (mit Anführungszeichen für Datum mit Uhrzeit)');
+          process.exit(1);
+        }
+      }
+
+      // Zeige persönliche Transit-Aspekte an
+      // Verwende den spezifischen Planeten, falls angegeben, oder alle Planeten
+      const targetPlanet = planetArg ? planetArg.toLowerCase() : null;
+      showPersonalTransitAspects(transitDate, birthData, targetPlanet);
+      
+      return;
+    }
+
     // Aspektfiguren anzeigen, falls --af Option angegeben (ohne Planet erforderlich)
     if (options.af) {
       // Geburtsdaten verwenden, falls --ich Option angegeben

package/src/health/fileAnalysis.js

@@ -28,10 +28,16 @@ async function analyzeHouseDistribution(planetName, folderPath, houseSystem = 'K
       const planetLongitude = planetData.longitude;
       
       // Berechne die Hausposition für dieses Datum
-      const julianDay = swisseph.swe_julday(
-        dateComponents.year, dateComponents.month, dateComponents.day,
-        dateComponents.hour + dateComponents.minute / 60, swisseph.SE_GREG_CAL
-      );
+      const { calculateJulianDayUTC, getTimezoneOffset, loadConfig } = require('../astrology/astrologyService');
+      let tz = null;
+      try {
+        const config = loadConfig();
+        if (config && config.currentLocation && config.currentLocation.timezone) {
+          tz = config.currentLocation.timezone;
+        }
+      } catch (_) {}
+      const off = tz ? getTimezoneOffset(dateComponents, tz) : -new Date().getTimezoneOffset();
+      const julianDay = calculateJulianDayUTC(dateComponents, off);
 
       const houses = await calculateHouses(julianDay, houseSystem);
       const planetHouse = getPlanetHouse(planetLongitude, houses.house);
@@ -89,10 +95,16 @@ async function filterFilesByHouse(planetName, folderPath, targetHouse, houseSyst
       const planetLongitude = planetData.longitude;
       
       // Berechne die Hausposition für dieses Datum
-      const julianDay = swisseph.swe_julday(
-        dateComponents.year, dateComponents.month, dateComponents.day,
-        dateComponents.hour + dateComponents.minute / 60, swisseph.SE_GREG_CAL
-      );
+      const { calculateJulianDayUTC, getTimezoneOffset, loadConfig } = require('../astrology/astrologyService');
+      let tz = null;
+      try {
+        const config = loadConfig();
+        if (config && config.currentLocation && config.currentLocation.timezone) {
+          tz = config.currentLocation.timezone;
+        }
+      } catch (_) {}
+      const off = tz ? getTimezoneOffset(dateComponents, tz) : -new Date().getTimezoneOffset();
+      const julianDay = calculateJulianDayUTC(dateComponents, off);
 
       const houses = await calculateHouses(julianDay, houseSystem);
       const planetHouse = getPlanetHouse(planetLongitude, houses.house);