klio 1.4.9 → 1.5.1

package/src/astrology/astrologyService.js

@@ -1,9 +1,9 @@
-const swisseph = require('swisseph');
+const swisseph = require('./swissephAdapter');
 const fs = require('fs');
 const moment = require('moment-timezone');
 const csvParser = require('csv-parser');
 const { parse } = require('csv-parse/sync');
-const { planets, signs, elements, decans, dignities } = require('./astrologyConstants');
+const { planets, signs, elements, signTypes, decans, dignities } = require('./astrologyConstants');
 const { loadConfig } = require('../config/configService');
 const path = require('path');
 
@@ -50,11 +50,11 @@ function getCurrentTimeInTimezone() {
 }
 
 // Function to load birth data from configuration
-function getBirthDataFromConfig() {
+function getBirthDataFromConfig(userId = null) {
   try {
     // First try to load the new configuration
     const { loadConfig } = require('../config/configService');
-    const config = loadConfig();
+    const config = loadConfig(userId);
     
     if (config && config.birthData) {
       // Parse birth date (Format: DD.MM.YYYY)
@@ -78,32 +78,34 @@ function getBirthDataFromConfig() {
       };
     }
     
-    // If the new configuration was not found, try the old file
-    const configPath = path.join(__dirname, '../../astrocli-config.json');
-    if (fs.existsSync(configPath)) {
-      const configData = fs.readFileSync(configPath, 'utf8');
-      const oldConfig = JSON.parse(configData);
-      
-      if (oldConfig && oldConfig.birthData) {
-        // Parse birth date (Format: DD.MM.YYYY)
-        const dateParts = oldConfig.birthData.date.split('.');
-        const day = parseInt(dateParts[0]);
-        const month = parseInt(dateParts[1]);
-        const year = parseInt(dateParts[2]);
-        
-        // Parse birth time (Format: HH:MM)
-        const timeParts = oldConfig.birthData.time.split(':');
-        const hour = parseInt(timeParts[0]);
-        const minute = parseInt(timeParts[1]);
+    // If the new configuration was not found, try the old file (only for global config)
+    if (!userId) {
+      const configPath = path.join(__dirname, '../../astrocli-config.json');
+      if (fs.existsSync(configPath)) {
+        const configData = fs.readFileSync(configPath, 'utf8');
+        const oldConfig = JSON.parse(configData);
         
-        return {
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          location: oldConfig.birthData.location
-        };
+        if (oldConfig && oldConfig.birthData) {
+          // Parse birth date (Format: DD.MM.YYYY)
+          const dateParts = oldConfig.birthData.date.split('.');
+          const day = parseInt(dateParts[0]);
+          const month = parseInt(dateParts[1]);
+          const year = parseInt(dateParts[2]);
+          
+          // Parse birth time (Format: HH:MM)
+          const timeParts = oldConfig.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: oldConfig.birthData.location
+          };
+        }
       }
     }
   } catch (error) {
@@ -114,14 +116,14 @@ function getBirthDataFromConfig() {
 }
 
 // Function to load person data (including birth data)
-function getPersonDataFromConfig(personId = 'birth') {
+function getPersonDataFromConfig(personId = 'birth', userId = null) {
   try {
     const { getPersonData } = require('../config/configService');
     
     if (personId === 'birth') {
-      return getBirthDataFromConfig();
+      return getBirthDataFromConfig(userId);
     } else {
-      return getPersonData(personId);
+      return getPersonData(personId, userId);
     }
   } catch (error) {
     console.error(`Error loading data for ${personId}:`, error.message);
@@ -454,12 +456,18 @@ function getAstrologicalData(planetName, customDate = null) {
   };
 }
 
+
+
 // Function to identify critical planets
 function getCriticalPlanets(customDate = null) {
   const criticalPlanets = [];
   
-  // Critical degrees: 0°, 13°, 26° (cardinal degrees) and 29° (anaretic degree)
-  const criticalDegrees = [0, 13, 26, 29];
+  // Critical degrees by sign type:
+  // Cardinal signs (Aries, Cancer, Libra, Capricorn): 0°, 13°, 26°
+  // Fixed signs (Taurus, Leo, Scorpio, Aquarius): 8-9°, 21-22°
+  // Mutable signs (Gemini, Virgo, Sagittarius, Pisces): 4°, 17°
+  // Anaretic degree (all signs): 29°
+  
   const orb = 1; // Tolerance of 1 degree
   
   // Use the specified date or current time
@@ -502,19 +510,55 @@ function getCriticalPlanets(customDate = null) {
     const degreeInSign = longitude % 30;
     const signIndex = Math.floor(longitude / 30);
     const sign = signs[signIndex];
+    const signType = signTypes[signIndex];
+
+    // Determine critical degrees based on sign type
+    let isCritical = false;
+    let criticalType = '';
     
-    // Check if planet is on a critical degree
-    const isCritical = criticalDegrees.some(criticalDegree => {
-      return Math.abs(degreeInSign - criticalDegree) <= orb;
-    });
-    
+    // First check for Anaretic degree (29°) - applies to all signs
+    if (degreeInSign >= 28.8) { // 29° with 0.2° orb for precision
+      isCritical = true;
+      criticalType = 'Anaretic (29°)';
+    } else if (signType === 'Cardinal') {
+      // Cardinal: exact degrees 0°, 13°, 26° with orb
+      isCritical = [0, 13, 26].some(criticalDegree => {
+        return Math.abs(degreeInSign - criticalDegree) <= orb;
+      });
+      criticalType = 'Cardinal (0°, 13°, 26°)';
+    } else if (signType === 'Fixed') {
+      // Fixed: ranges 8-9° and 21-22°
+      isCritical = (degreeInSign >= 8 && degreeInSign <= 9) || (degreeInSign >= 21 && degreeInSign <= 22);
+      criticalType = 'Fixed (8-9°, 21-22°)';
+    } else if (signType === 'Mutable') {
+      // Mutable: exact degrees 4°, 17° with orb
+      isCritical = [4, 17].some(criticalDegree => {
+        return Math.abs(degreeInSign - criticalDegree) <= orb;
+      });
+      criticalType = 'Mutable (4°, 17°)';
+    }
+
     if (isCritical) {
+      // Simple interpretation based on modality challenges
+      let interpretation = '';
+      
+      if (criticalType === 'Cardinal (0°, 13°, 26°)') {
+        interpretation = 'Tendency to over-express. May push too hard or initiate prematurely.';
+      } else if (criticalType === 'Fixed (8-9°, 21-22°)') {
+        interpretation = 'Tendency to under-express. May resist change or hold on too tightly.';
+      } else if (criticalType === 'Mutable (4°, 17°)') {
+        interpretation = 'Path of ambivalence. May struggle with indecision or adapt excessively.';
+      } else if (criticalType === 'Anaretic (29°)') {
+        interpretation = 'Poised for change. At the end of a cycle, facing transition.';
+      }
+
       criticalPlanets.push({
         name,
         sign,
         degree: degreeInSign.toFixed(2),
         isCritical: true,
-        criticalType: degreeInSign >= 28.5 ? 'Anaretic (29°)' : 'Cardinal (0°, 13°, 26°)'
+        criticalType: criticalType,
+        interpretation: interpretation
       });
     }
   }
@@ -642,7 +686,7 @@ function showPlanetAspects(planetName, dateComponents, useBirthData = false, use
   
   console.log(`Aspects for ${planetLabel}:`);
   console.log('================================================================================');
-  console.log('| Aspect      | Planet   | Orb   | Exact Date/Time               |');
+  console.log('| Aspect      | Planet   | Orb   |');
   console.log('================================================================================');
   
   if (aspects.length === 0) {
@@ -654,14 +698,8 @@ function showPlanetAspects(planetName, dateComponents, useBirthData = false, use
       const planetFormatted = planetNameFormatted.padEnd(8, ' ');
       const orb = aspect.orb.padEnd(4, ' ');
       
-      // Calculate exact date and time for this aspect
-      const exactDateTime = findExactAspectTime(planetName, aspect.planet, aspect.type, dateComponents);
-      if (exactDateTime) {
-        const 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')}`;
-        console.log(`| ${aspectName} | ${planetFormatted} | ${orb}° | ${dateTimeStr} |`);
-      } else {
-        console.log(`| ${aspectName} | ${planetFormatted} | ${orb}° | Calculation failed |`);
-      }
+      // Exact time calculation removed
+      console.log(`| ${aspectName} | ${planetFormatted} | ${orb}° |`);
     });
   }
   
@@ -682,7 +720,7 @@ function showPlanetComboAspects(planetNames, dateComponents, useBirthData = fals
   
   console.log(`Aspects between ${planetLabels}:`);
   console.log('================================================================================');
-  console.log('| Planet 1     | Planet 2     | Aspect      | Orb   | Exact Date/Time               |');
+  console.log('| Planet 1     | Planet 2     | Aspect      | Orb   |');
   console.log('================================================================================');
   
   if (aspects.length === 0) {
@@ -696,14 +734,8 @@ function showPlanetComboAspects(planetNames, dateComponents, useBirthData = fals
       const aspectName = aspect.type.padEnd(11, ' ');
       const orb = aspect.orb.padEnd(4, ' ');
       
-      // Calculate exact date and time for this aspect
-      const exactDateTime = findExactAspectTime(aspect.planet1, aspect.planet2, aspect.type, dateComponents);
-      if (exactDateTime) {
-        const 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')}`;
-        console.log(`| ${planet1Padded} | ${planet2Padded} | ${aspectName} | ${orb}° | ${dateTimeStr} |`);
-      } else {
-        console.log(`| ${planet1Padded} | ${planet2Padded} | ${aspectName} | ${orb}° | Calculation failed |`);
-      }
+      // Exact time calculation removed
+      console.log(`| ${planet1Padded} | ${planet2Padded} | ${aspectName} | ${orb}° |`);
     });
   }
   
@@ -716,107 +748,7 @@ function showPlanetComboAspects(planetNames, dateComponents, useBirthData = fals
   }
 }
 
-// Helper function to calculate exact date and time for an exact aspect
-function findExactAspectTime(planet1, planet2, aspectType, startDate) {
-  const targetAngle = getAspectAngle(aspectType);
-  
-  if (targetAngle === null) {
-    return null;
-  }
-  
-  // We search in a reasonable time window (90 days in the future)
-  // to find the next exact aspect
-  // Especially important for slow planets like Saturn, Uranus, Neptune, Pluto
-  let bestMatch = null;
-  let bestDistance = Infinity;
-  
-  // Search only in the future (0-90 days after start date)
-  const searchWindow = 90; // days
-  
-  // We search in smaller steps (every 2 hours) to get more precise results
-  const stepsPerDay = 12; // 2-hour steps
-  
-  for (let daysOffset = 0; daysOffset <= searchWindow; daysOffset++) {
-    for (let hourOffset = 0; hourOffset < 24; hourOffset++) { // Every hour
-      for (let minuteOffset = 0; minuteOffset < 60; minuteOffset += 5) { // Every 5 minutes
-        const testDate = addDays(startDate, daysOffset);
-        testDate.hour = hourOffset;
-        testDate.minute = minuteOffset;
-        
-        // Calculate positions of both planets
-        const planet1Data = getAstrologicalData(planet1, testDate);
-        const planet2Data = getAstrologicalData(planet2, testDate);
-        
-        // Calculate angle between planets
-        const angleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
-        const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
-        const distanceToTarget = Math.abs(normalizedAngle - targetAngle);
-        
-        // Store the best result
-        if (distanceToTarget < bestDistance) {
-          bestDistance = distanceToTarget;
-          bestMatch = {...testDate};
-        }
-      }
-    }
-  }
-  
-  // If we found an aspect close enough to the target, return it
-  // Stricter tolerance of 0.5° for better accuracy
-  if (bestMatch && bestDistance <= 0.5) { // Tolerance of 0.5°
-    return bestMatch;
-  }
-  
-  return null;
-}
 
-// Function to find the last exact aspect in the past (for separative phases)
-function findLastExactAspectTime(planet1, planet2, aspectType, startDate) {
-  const targetAngle = getAspectAngle(aspectType);
-  
-  if (targetAngle === null) {
-    return null;
-  }
-  
-  // Search in the past (up to 180 days before start date)
-  let bestMatch = null;
-  let bestDistance = Infinity;
-  
-  // Search in a time window of 180 days before start date
-  const searchWindow = 180; // days
-  
-  for (let daysOffset = -searchWindow; daysOffset <= 0; daysOffset++) {
-    for (let hourOffset = 0; hourOffset < 24; hourOffset++) { // Every hour
-      for (let minuteOffset = 0; minuteOffset < 60; minuteOffset += 5) { // Every 5 minutes
-        const testDate = addDays(startDate, daysOffset);
-        testDate.hour = hourOffset;
-        testDate.minute = minuteOffset;
-        
-        // Calculate positions of both planets
-        const planet1Data = getAstrologicalData(planet1, testDate);
-        const planet2Data = getAstrologicalData(planet2, testDate);
-        
-        // Calculate angle between planets
-        const angleDiff = Math.abs(planet1Data.longitude - planet2Data.longitude) % 360;
-        const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
-        const distanceToTarget = Math.abs(normalizedAngle - targetAngle);
-        
-        // Store the best result
-        if (distanceToTarget < bestDistance) {
-          bestDistance = distanceToTarget;
-          bestMatch = {...testDate};
-        }
-      }
-    }
-  }
-  
-  // If we found an aspect close enough to the target, return it
-  if (bestMatch && bestDistance <= 0.5) { // Tolerance of 0.5°
-    return bestMatch;
-  }
-  
-  return null;
-}
 
 // Function to calculate all active aspects between all planets
 function getAllActiveAspects(dateComponents) {
@@ -1733,7 +1665,7 @@ function showAllActiveAspects(dateComponents, useBirthData = false) {
   
   console.log('Active Aspects (all planets) - Classified by Precision:');
   console.log('═══════════════════════════════════════════════════════════════════════════');
-  console.log('║ Planet 1     │ Planet 2     │ Orb    │ Status       │ Exact Date/Time              ║');
+  console.log('║ Planet 1     │ Planet 2     │ Orb    │ Status       ║');
   console.log('═══════════════════════════════════════════════════════════════════════════');
   
   if (sortedAspects.length === 0) {
@@ -1784,14 +1716,10 @@ function showAllActiveAspects(dateComponents, useBirthData = false) {
           );
           const statusPadded = phase.padEnd(11, ' ');
           
-          // Calculate the exact date and time for this aspect
-          const exactDateTime = findExactAspectTime(aspect.planet1, aspect.planet2, aspect.type, dateComponents);
-          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')}`;
-          }
+          // Exact time calculation removed
+          const dateTimeStr = '-';
           
-          console.log(`║ ${planet1Padded} │ ${planet2Padded} │ ${orb}° │ ${statusPadded} │ ${dateTimeStr} ║`);
+          console.log(`║ ${planet1Padded} │ ${planet2Padded} │ ${orb}° │ ${statusPadded} ║`);
         });
       }
     });
@@ -1904,16 +1832,25 @@ function analyzeSignDistributionSignificance(signDistribution) {
 function parseFilterCriteria(filterString) {
   if (!filterString) return null;
   
-  const parts = filterString.split(':');
-  if (parts.length !== 2) {
-    console.warn('Invalid filter format. Expected "column:value"');
-    return null;
+  // Check if multiple filters are provided (comma-separated)
+  const filterConditions = filterString.split(',').map(cond => cond.trim());
+  
+  const criteria = [];
+  
+  for (const condition of filterConditions) {
+    const parts = condition.split(':');
+    if (parts.length !== 2) {
+      console.warn(`Invalid filter format. Expected "column:value" but got "${condition}"`);
+      return null;
+    }
+    
+    criteria.push({
+      column: parts[0].trim(),
+      value: parts[1].trim()
+    });
   }
   
-  return {
-    column: parts[0].trim(),
-    value: parts[1].trim()
-  };
+  return criteria.length === 1 ? criteria[0] : criteria;
 }
 
 // Helper function to apply filter to records
@@ -1926,10 +1863,21 @@ function applyFilter(records, filterCriteria) {
   
   if (!parsedCriteria) return records;
   
-  return records.filter(record => {
-    const recordValue = record[parsedCriteria.column];
-    return recordValue && recordValue.toString() === parsedCriteria.value;
-  });
+  // Handle both single criteria and multiple criteria
+  if (Array.isArray(parsedCriteria)) {
+    return records.filter(record => {
+      return parsedCriteria.every(criterion => {
+        const recordValue = record[criterion.column];
+        return recordValue && recordValue.toString() === criterion.value;
+      });
+    });
+  } else {
+    // Single criteria (backward compatibility)
+    return records.filter(record => {
+      const recordValue = record[parsedCriteria.column];
+      return recordValue && recordValue.toString() === parsedCriteria.value;
+    });
+  }
 }
 
 function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'koch', analyzeAspects = false, partnerPlanet = null, filterCriteria = null) {
@@ -1939,6 +1887,7 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
 
     // Helper function to process results
     function processResults() {
+
       // Calculate house distribution
       const houseCounts = {};
       results.forEach(result => {
@@ -2004,15 +1953,33 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
 
         // Process each row
         for (const data of filteredRecords) {
-          // Look for a column with ISO-Datetime values or Unix-Timestamps
-          const datetimeColumns = Object.keys(data).filter(key => {
+          // Look for a column with datetime values, prioritizing specific date formats
+          const datetimeColumns = [];
+          
+          // First pass: look for YYYY-MM-DD format (most specific)
+          const yyyyMmDdColumns = Object.keys(data).filter(key => {
             const value = data[key];
-            // Check for ISO-8601 date
-            const isISO = moment(value, moment.ISO_8601, true).isValid();
-            // Check for Unix-Timestamp (number with 10 or 13 digits)
-            const isUnixTimestamp = /^\d{10,13}$/.test(value);
-            return isISO || isUnixTimestamp;
+            return /^\d{4}-\d{2}-\d{2}$/.test(value);
+          });
+          
+          // Second pass: look for Unix timestamps (10 or 13 digits)
+          const unixTimestampColumns = Object.keys(data).filter(key => {
+            const value = data[key];
+            return /^\d{10,13}$/.test(value);
+          });
+          
+          // Third pass: look for ISO-8601 dates (least specific, as it can match many formats)
+          const isoDateColumns = Object.keys(data).filter(key => {
+            const value = data[key];
+            // Only consider it an ISO date if it's not already matched by more specific patterns
+            if (yyyyMmDdColumns.includes(key) || unixTimestampColumns.includes(key)) {
+              return false;
+            }
+            return moment(value, moment.ISO_8601, true).isValid();
           });
+          
+          // Prioritize columns: YYYY-MM-DD first, then Unix timestamps, then ISO dates
+          datetimeColumns.push(...yyyyMmDdColumns, ...unixTimestampColumns, ...isoDateColumns);
 
           if (datetimeColumns.length > 0) {
             const datetimeValue = data[datetimeColumns[0]];
@@ -2023,6 +1990,10 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
               // Convert Unix-Timestamp to milliseconds (if 10 digits, multiply by 1000)
               const timestamp = datetimeValue.length === 10 ? parseInt(datetimeValue) * 1000 : parseInt(datetimeValue);
               datetime = moment(timestamp);
+            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValue)) {
+              // Handle as YYYY-MM-DD date format
+              // Parse as date only, set time to 12:00 (noon) as default
+              datetime = moment(datetimeValue + 'T12:00:00');
             } else {
               // Handle as ISO-8601 date
               datetime = moment(datetimeValue);
@@ -2121,8 +2092,10 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
           }
         }
 
-        // Check if all operations are completed
-        checkCompletion();
+        // Check if all operations are completed (only if no operations were started)
+        if (pendingOperations === 0) {
+          processResults();
+        }
 
         // Helper function to check completion
         function checkCompletion() {
@@ -2139,139 +2112,193 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
       }
     } else {
       // Standard file processing for local files
-      fs.createReadStream(filePath)
-          .pipe(csvParser())
-          .on('data', (data) => {
-            // Apply filter if specified
-            if (filterCriteria) {
-              const parsedCriteria = typeof filterCriteria === 'string' 
-                ? parseFilterCriteria(filterCriteria) 
+      try {
+        // Read the file content first
+        const csvData = fs.readFileSync(filePath, 'utf8');
+        
+        // Try to auto-detect delimiter by checking first few lines
+        let delimiter = ',';
+        const firstLines = csvData.split('\n').slice(0, 5).join('\n');
+        const commaCount = (firstLines.match(/,/g) || []).length;
+        const semicolonCount = (firstLines.match(/;/g) || []).length;
+        
+        // Use semicolon if it appears more frequently than comma
+        if (semicolonCount > commaCount) {
+          delimiter = ';';
+        }
+        
+        // Parse the CSV data with detected delimiter
+        const records = parse(csvData, {
+          columns: true,
+          skip_empty_lines: true,
+          delimiter: delimiter
+        });
+        
+        // Process each record
+        for (const data of records) {
+          // Apply filter if specified
+          if (filterCriteria) {
+            const parsedCriteria = typeof filterCriteria === 'string'
+                ? parseFilterCriteria(filterCriteria)
                 : filterCriteria;
+
+            if (parsedCriteria) {
+              let shouldSkip = false;
               
-              if (parsedCriteria) {
+              if (Array.isArray(parsedCriteria)) {
+                // Multiple criteria - all must match
+                shouldSkip = !parsedCriteria.every(criterion => {
+                  const recordValue = data[criterion.column];
+                  return recordValue && recordValue.toString() === criterion.value;
+                });
+              } else {
+                // Single criteria
                 const recordValue = data[parsedCriteria.column];
-                if (!recordValue || recordValue.toString() !== parsedCriteria.value) {
-                  return; // Skip this record
-                }
+                shouldSkip = !recordValue || recordValue.toString() !== parsedCriteria.value;
+              }
+              
+              if (shouldSkip) {
+                continue; // Skip this record
               }
             }
+          }
 
-            // Look for a column with ISO-Datetime values or Unix-Timestamps
-            const datetimeColumns = Object.keys(data).filter(key => {
-              const value = data[key];
-              // Check for ISO-8601 date
-              const isISO = moment(value, moment.ISO_8601, true).isValid();
-              // Check for Unix-Timestamp (number with 10 or 13 digits)
-              const isUnixTimestamp = /^\d{10,13}$/.test(value);
-              return isISO || isUnixTimestamp;
-            });
+          // Look for a column with ISO-Datetime values, YYYY-MM-DD dates, or Unix-Timestamps
+          const datetimeColumns = Object.keys(data).filter(key => {
+            const value = data[key];
+            // Check for ISO-8601 date
+            const isISO = moment(value, moment.ISO_8601, true).isValid();
+            // Check for YYYY-MM-DD date format
+            const isYYYYMMDD = /^\d{4}-\d{2}-\d{2}$/.test(value);
+            // Check for Unix-Timestamp (number with 10 or 13 digits)
+            const isUnixTimestamp = /^\d{10,13}$/.test(value);
+            return isISO || isYYYYMMDD || isUnixTimestamp;
+          });
 
-            if (datetimeColumns.length > 0) {
-              const datetimeValue = data[datetimeColumns[0]];
-              let datetime;
+          if (datetimeColumns.length > 0) {
+            const datetimeValue = data[datetimeColumns[0]];
+            let datetime;
 
-              // Check if it's a Unix-Timestamp
-              if (/^\d{10,13}$/.test(datetimeValue)) {
-                // Convert Unix-Timestamp to milliseconds (if 10 digits, multiply by 1000)
-                const timestamp = datetimeValue.length === 10 ? parseInt(datetimeValue) * 1000 : parseInt(datetimeValue);
-                datetime = moment(timestamp);
-              } else {
-                // Handle as ISO-8601 date
-                datetime = moment(datetimeValue);
-              }
+            // Check if it's a Unix-Timestamp
+            if (/^\d{10,13}$/.test(datetimeValue)) {
+              // Convert Unix-Timestamp to milliseconds (if 10 digits, multiply by 1000)
+              const timestamp = datetimeValue.length === 10 ? parseInt(datetimeValue) * 1000 : parseInt(datetimeValue);
+              datetime = moment(timestamp);
+            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValue)) {
+              // Handle as YYYY-MM-DD date format
+              // Parse as date only, set time to 12:00 (noon) as default
+              datetime = moment(datetimeValue + 'T12:00:00');
+            } else {
+              // Handle as ISO-8601 date
+              datetime = moment(datetimeValue);
+            }
 
-              // Convert the date to the format needed for astrological calculations
-              const dateComponents = {
-                year: datetime.year(),
-                month: datetime.month() + 1, // moment months are 0-based
-                day: datetime.date(),
-                hour: datetime.hour(),
-                minute: datetime.minute()
-              };
-
-              // Calculate the astrological data for the specified planet
-              let astroData;
-              try {
-                astroData = getAstrologicalData(planetName, dateComponents);
-              } catch (error) {
-                // If error, skip this record (e.g., if date is out of range)
-                return;
-              }
+            // Convert the date to the format needed for astrological calculations
+            const dateComponents = {
+              year: datetime.year(),
+              month: datetime.month() + 1, // moment months are 0-based
+              day: datetime.date(),
+              hour: datetime.hour(),
+              minute: datetime.minute()
+            };
+
+            // Calculate the astrological data for the specified planet
+            let astroData;
+            try {
+              astroData = getAstrologicalData(planetName, dateComponents);
+            } catch (error) {
+              // If error, skip this record (e.g., if date is out of range)
+              continue;
+            }
 
-              // Calculate the houses
-              const julianDay = calculateJulianDayUTC(dateComponents, -datetime.utcOffset());
-              calculateHouses(julianDay, getHouseSystemCode(houseSystem), false)
-                  .then(houses => {
-                    const planetLongitude = parseFloat(astroData.degreeInSign) + (signs.indexOf(astroData.sign) * 30);
-                    const house = getPlanetHouse(planetLongitude, houses.house);
-
-                    // Berechne Aspekte, falls angefordert
-                    let aspects = [];
-                    if (analyzeAspects) {
-                      try {
-                        aspects = calculatePlanetAspects(planetName, dateComponents, true);
-
-                        // Filter nach Partner-Planet, falls angegeben
-                        if (partnerPlanet) {
-                          aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
-                        }
-                      } catch (error) {
-                        // Ignoriere Fehler bei der Aspektberechnung für einzelne Datensätze
+            // Increase the counter for pending operations
+            pendingOperations++;
+
+            // Calculate the houses
+            const julianDay = calculateJulianDayUTC(dateComponents, -datetime.utcOffset());
+            calculateHouses(julianDay, getHouseSystemCode(houseSystem), false)
+                .then(houses => {
+                  const planetLongitude = parseFloat(astroData.degreeInSign) + (signs.indexOf(astroData.sign) * 30);
+                  const house = getPlanetHouse(planetLongitude, houses.house);
+
+                  // Berechne Aspekte, falls angefordert
+                  let aspects = [];
+                  if (analyzeAspects) {
+                    try {
+                      aspects = calculatePlanetAspects(planetName, dateComponents, true);
+
+                      // Filter nach Partner-Planet, falls angegeben
+                      if (partnerPlanet) {
+                        aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
                       }
+                    } catch (error) {
+                      // Ignoriere Fehler bei der Aspektberechnung für einzelne Datensätze
                     }
+                  }
 
-                    const result = {
-                      datetime: datetimeValue,
-                      planet: planetName,
-                      sign: astroData.sign,
-                      degreeInSign: astroData.degreeInSign,
-                      house: house
-                    };
+                  const result = {
+                    datetime: datetimeValue,
+                    planet: planetName,
+                    sign: astroData.sign,
+                    degreeInSign: astroData.degreeInSign,
+                    house: house
+                  };
 
-                    if (analyzeAspects) {
-                      result.aspects = aspects;
-                    }
+                  if (analyzeAspects) {
+                    result.aspects = aspects;
+                  }
+
+                  results.push(result);
+                  checkCompletion();
+                })
+                .catch(error => {
+                  console.error('Fehler bei der Hausberechnung:', error);
+
+                  // Berechne Aspekte auch bei Hausberechnungsfehler, falls angefordert
+                  let aspects = [];
+                  if (analyzeAspects) {
+                    try {
+                      aspects = calculatePlanetAspects(planetName, dateComponents, true);
 
-                    results.push(result);
-                  })
-                  .catch(error => {
-                    console.error('Fehler bei der Hausberechnung:', error);
-
-                    // Berechne Aspekte auch bei Hausberechnungsfehler, falls angefordert
-                    let aspects = [];
-                    if (analyzeAspects) {
-                      try {
-                        aspects = calculatePlanetAspects(planetName, dateComponents, true);
-
-                        // Filter nach Partner-Planet, falls angegeben
-                        if (partnerPlanet) {
-                          aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
-                        }
-                      } catch (error) {
-                        console.error('Fehler bei der Aspektberechnung:', error);
+                      // Filter nach Partner-Planet, falls angegeben
+                      if (partnerPlanet) {
+                        aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
                       }
+                    } catch (error) {
+                      console.error('Fehler bei der Aspektberechnung:', error);
                     }
+                  }
 
-                    results.push({
-                      datetime: datetimeValue,
-                      planet: planetName,
-                      sign: astroData.sign,
-                      degreeInSign: astroData.degreeInSign,
-                      house: 'N/A',
-                      ...(analyzeAspects ? {aspects} : {})
-                    });
+                  results.push({
+                    datetime: datetimeValue,
+                    planet: planetName,
+                    sign: astroData.sign,
+                    degreeInSign: astroData.degreeInSign,
+                    house: 'N/A',
+                    ...(analyzeAspects ? {aspects} : {})
                   });
-            }
-          })
-          .on('end', () => {
-            // Verarbeite die Ergebnisse
+                  checkCompletion();
+                });
+          }
+        }
+        
+        // Helper function to check completion
+        function checkCompletion() {
+          pendingOperations--;
+          if (pendingOperations === 0) {
             processResults();
-          })
-          .on('error', (error) => {
-            console.error('Fehler beim Lesen der CSV-Datei:', error);
-            reject(error);
-          });
-    }
+          }
+        }
+        
+        // Check if all operations are completed (only if no operations were started)
+        if (pendingOperations === 0) {
+          processResults();
+        }
+      } catch (error) {
+        console.error('Fehler beim Lesen der CSV-Datei:', error);
+        reject(error);
+      }
+  }
   })
 }
 
@@ -2812,8 +2839,6 @@ module.exports = {
   getPastAspects,
   getAspectAngle,
   getFutureAspects,
-  findExactAspectTime,
-  findLastExactAspectTime,
   analyzeCSVWithDatetime,
   detectAspectFigures,
   showAspectFigures,