klio 1.4.2 → 1.4.4

package/README.md

@@ -90,8 +90,6 @@ It's possible to analyze Apple Health data. This happens on the device and no se
 - **Step analysis**: `klio [planet] --apple <filepath> --steps` - Analyzes step patterns of any planet
 - **Stress analysis**: `klio [planet] --apple <filepath> --stress` - Analyzes stress patterns of planet sign stress based on HRV
 
-> Maybe I'll add some more in the future.
-
 ### CSV Analysis
 It's possible to analyze a csv with a column of either ISO date time or unix time stamp. 
 
@@ -100,9 +98,6 @@ It's possible to analyze a csv with a column of either ISO date time or unix tim
 
 The command also returns a Chi-Square. 
 
-You can research a lot of fun things with this. You find a lot of free datasets on Kaggle.
-
-
 ### Adding different charts
 
 - **Use personal data**: `--i` - Uses birth data from setup for calculations
@@ -127,6 +122,13 @@ Then, instead using `--i` for the commands from above you can use `--wp <id>` i.
 - **Past aspects**: `klio --v <count> [planet1] [aspect-type] [planet2]` - Shows past aspects (Format: --v <count> planet1 aspectType planet2) Available aspect types: c, o, s, t, se (conjunction, opposition, square, trine, sextile)
 - **Future aspects**: `klio --z <count> [planet1] [aspect-type] [planet2]` - Shows future aspects (Format: --z <count> planet1 aspectType planet2)
 
+### Planet Ingresses
+
+- **Planet ingress**: `klio [planet] --in [count]` - Shows when a planet enters a new zodiac sign. Optional count parameter for multiple ingresses (default: 1). Works with any planet (moon, mercury, venus, etc.)
+  - Example: `klio moon --in` - Shows next moon ingress
+  - Example: `klio saturn --in 2` - Shows next 2 Saturn ingresses (note: slow planets may have limited future data)
+  - Example: `klio mercury --in --d "15.03.2026"` - Shows next Mercury ingress from a specific date
+
 ### AI Integration
 
 - **AI model selection**: `--ai <model>` - Sets a specific AI model (e.g., "google/gemma-3n-e4b") for LM Studio ([lmstudio.ai](https://lmstudio.ai))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klio",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "A CLI for astrological calculations",
   "main": "src/main.js",
   "bin": {

package/src/astrology/astrologyService.js

@@ -2491,6 +2491,223 @@ function analyzeHouseDistributionSignificance(houseDistribution) {
   };
 }
 
+// Function to calculate the next planet ingress (when planet enters a new sign)
+function calculateNextPlanetIngress(planetName, startDate = null, count = 1) {
+  // Use current date if no start date is provided
+  const startDateObj = startDate ? new Date(startDate.year, startDate.month - 1, startDate.day, startDate.hour, startDate.minute) : new Date();
+  
+  const results = [];
+  let currentDate = new Date(startDateObj);
+  
+  // Calculate timezone offset for the start date
+  const config = loadConfig();
+  let timezone = 'Europe/Zurich'; // Default
+  
+  if (config && config.currentLocation && config.currentLocation.timezone) {
+    timezone = config.currentLocation.timezone;
+  }
+  
+  const timezoneOffsetMinutes = getTimezoneOffset({
+    year: currentDate.getFullYear(),
+    month: currentDate.getMonth() + 1,
+    day: currentDate.getDate(),
+    hour: currentDate.getHours(),
+    minute: currentDate.getMinutes()
+  }, timezone);
+  
+  // Get current planet position
+  const currentPlanetData = getAstrologicalData(planetName, {
+    year: currentDate.getFullYear(),
+    month: currentDate.getMonth() + 1,
+    day: currentDate.getDate(),
+    hour: currentDate.getHours(),
+    minute: currentDate.getMinutes()
+  });
+  
+  let currentSignIndex = signs.indexOf(currentPlanetData.sign);
+  let targetSignIndex = (currentSignIndex + 1) % 12; // Next sign
+  
+  for (let i = 0; i < count; i++) {
+    // Find the next ingress by checking positions in 1-hour increments
+    let foundIngress = false;
+    let ingressDate = null;
+    let attempts = 0;
+    
+    // Dynamic search strategy based on planet speed
+    const verySlowPlanets = ['saturn', 'uranus', 'neptune', 'pluto'];
+    const mediumSlowPlanets = ['jupiter'];
+    const isVerySlowPlanet = verySlowPlanets.includes(planetName);
+    const isMediumSlowPlanet = mediumSlowPlanets.includes(planetName);
+    
+    // Determine time step based on planet speed
+    const timeStepHours = isVerySlowPlanet ? 24 : 
+                          isMediumSlowPlanet ? 6 : 
+                          1; // Daily for very slow, 6-hourly for medium, hourly for fast
+    
+    // Maximum search window (in days) - calculate based on planet and requested count
+    // Mars: ~2 months per sign, so for multiple ingresses we need ~count * 60 days
+    // Other fast planets (Moon, Mercury, Venus, Sun): 90 days is sufficient
+    const fastPlanets = ['moon', 'mercury', 'venus', 'sun'];
+    const isFastPlanet = fastPlanets.includes(planetName);
+    const isMars = planetName === 'mars';
+    
+    const maxDays = isVerySlowPlanet ? 365 * 90 :
+                    isMediumSlowPlanet ? 365 * 90 :
+                    isMars ? Math.min(365 * 5, 90 * count) : // Mars: up to 5 years or count * 3 months
+                    isFastPlanet ? 90 :  // 30 days for fast planets (enough for multiple moon ingresses)
+                    365 * 90; // Default for other planets
+    const maxAttempts = maxDays * 24 / timeStepHours;
+    
+    while (!foundIngress && attempts < maxAttempts) {
+      attempts++;
+      currentDate.setHours(currentDate.getHours() + timeStepHours);
+      
+      const testPlanetData = getAstrologicalData(planetName, {
+        year: currentDate.getFullYear(),
+        month: currentDate.getMonth() + 1,
+        day: currentDate.getDate(),
+        hour: currentDate.getHours(),
+        minute: currentDate.getMinutes()
+      });
+      
+      const testSignIndex = signs.indexOf(testPlanetData.sign);
+      
+      if (testSignIndex === targetSignIndex) {
+        // Found the ingress! Now refine to get more precise time
+        ingressDate = findExactPlanetIngressTime(planetName, currentDate, targetSignIndex, timezoneOffsetMinutes);
+        foundIngress = true;
+      }
+    }
+    
+    if (foundIngress) {
+      results.push({
+        sign: signs[targetSignIndex],
+        date: ingressDate,
+        fromSign: signs[currentSignIndex]
+      });
+      
+      // Prepare for next ingress
+      currentSignIndex = targetSignIndex;
+      targetSignIndex = (currentSignIndex + 1) % 12;
+      // Convert ingressDate object to Date object
+      currentDate = new Date(ingressDate.year, ingressDate.month - 1, ingressDate.day, ingressDate.hour, ingressDate.minute);
+      // For fast planets, start searching a few hours after the ingress to avoid missing the next one
+      if (isFastPlanet) {
+        currentDate.setHours(currentDate.getHours() + 6); // Start 6 hours after ingress
+      }
+    } else {
+      const daysLimit = isVerySlowPlanet ? 365 * 90 :
+                       isMediumSlowPlanet ? 365 * 90 :
+                       isMars ? Math.min(365 * 5, 90 * count) :
+                       isFastPlanet ? 90 :
+                       365 * 90;
+      console.log(`Could not find ${planetName} ingress to ${signs[targetSignIndex]} within ${daysLimit} days`);
+      if (isVerySlowPlanet) {
+        console.log(`💡 Note: For very slow planets like ${planetName}, the ephemeris data may not extend far enough into the future.`);
+      } else if (isMediumSlowPlanet) {
+        console.log(`💡 Note: For medium-slow planets like ${planetName}, the ephemeris data may not extend far enough into the future.`);
+      } else if (isMars) {
+        console.log(`💡 Note: For Mars, the requested number of ingresses may be too high for the current search window.`);
+      } else {
+        console.log(`💡 Note: For ${planetName}, the requested number of ingresses may be too high.`);
+      }
+      console.log(`💡 Try requesting fewer ingresses or use a shorter time frame with the --d option.`);
+      // Continue to next iteration instead of breaking the entire loop
+      continue;
+    }
+  }
+  
+  return results;
+}
+
+// Helper function to find exact planet ingress time using binary search
+function findExactPlanetIngressTime(planetName, approximateDate, targetSignIndex, timezoneOffsetMinutes) {
+  const targetLongitude = targetSignIndex * 30; // Each sign is 30 degrees
+  
+  // Convert approximate date to Julian Day
+  const approxJulianDay = calculateJulianDayUTC({
+    year: approximateDate.getFullYear(),
+    month: approximateDate.getMonth() + 1,
+    day: approximateDate.getDate(),
+    hour: approximateDate.getHours(),
+    minute: approximateDate.getMinutes()
+  }, timezoneOffsetMinutes);
+  
+  // Binary search parameters
+  let low = approxJulianDay - 0.1; // 2.4 hours before
+  let high = approxJulianDay + 0.1; // 2.4 hours after
+  let precision = 0.0001; // About 1.44 minutes precision
+  
+  // Perform binary search
+  for (let i = 0; i < 50; i++) {
+    const mid = (low + high) / 2;
+    const result = swisseph.swe_calc_ut(mid, planets[planetName], swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED);
+    
+    if (result.error) {
+      // Fallback to Moshier
+      const moshierResult = swisseph.swe_calc_ut(mid, planets[planetName], swisseph.SEFLG_MOSEPH | swisseph.SEFLG_SPEED);
+      if (moshierResult.error) {
+        console.error(`Error calculating ${planetName} position:`, moshierResult.error);
+        break;
+      }
+      result.longitude = moshierResult.longitude;
+    }
+    
+    if (result.longitude >= targetLongitude) {
+      high = mid;
+    } else {
+      low = mid;
+    }
+    
+    if (high - low < precision) {
+      break;
+    }
+  }
+  
+  // Convert Julian Day back to date components
+  const finalJulianDay = (low + high) / 2;
+  return convertJulianDayToDate(finalJulianDay, timezoneOffsetMinutes);
+}
+
+// Helper function to convert Julian Day to date components
+function convertJulianDayToDate(julianDay, timezoneOffsetMinutes) {
+  // This is a simplified conversion - for more accuracy, use a proper algorithm
+  // We'll use the Swiss Ephemeris function if available
+  try {
+    const result = swisseph.swe_revjul(julianDay, swisseph.SE_GREG_CAL);
+    
+    // Extract minutes from the decimal part of the hour
+    const hour = Math.floor(result.hour);
+    const minute = Math.round((result.hour - hour) * 60);
+    
+    // Adjust for timezone
+    const utcDate = new Date(Date.UTC(result.year, result.month - 1, result.day, hour, minute));
+    utcDate.setMinutes(utcDate.getMinutes() + timezoneOffsetMinutes);
+    
+    return {
+      year: utcDate.getFullYear(),
+      month: utcDate.getMonth() + 1,
+      day: utcDate.getDate(),
+      hour: utcDate.getHours(),
+      minute: utcDate.getMinutes()
+    };
+  } catch (error) {
+    console.error('Error converting Julian Day to date:', error);
+    
+    // Fallback: return approximate date
+    const baseDate = new Date();
+    baseDate.setTime((julianDay - 2440587.5) * 86400000); // Convert Julian Day to milliseconds
+    
+    return {
+      year: baseDate.getFullYear(),
+      month: baseDate.getMonth() + 1,
+      day: baseDate.getDate(),
+      hour: baseDate.getHours(),
+      minute: baseDate.getMinutes()
+    };
+  }
+}
+
 
 module.exports = {
   calculateHouses,
@@ -2527,5 +2744,6 @@ module.exports = {
   analyzeSignDistributionSignificance,
   calculateAspectStatistics,
   calculatePlanetComboAspects,
-  showPlanetComboAspects
+  showPlanetComboAspects,
+  calculateNextPlanetIngress
 };

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, getPersonDataFromConfig, detectAspectFigures, calculatePersonalTransits, showPersonalTransitAspects, showCombinedAnalysis, calculatePersonalTransitAspects, determineAspectPhase, findExactAspectTime, findLastExactAspectTime, getAspectAngle, getFutureAspects, getPastAspects, analyzeCSVWithDatetime, analyzeHouseDistributionSignificance, analyzeAspectDistributionSignificance, analyzeSignDistributionSignificance, calculateAspectStatistics, calculatePlanetComboAspects, showPlanetComboAspects, getCriticalPlanets, getHouseSystemCode } = require('../astrology/astrologyService');
+const { getCurrentTimeInTimezone, showAspectFigures, analyzeElementDistribution, getTimezoneOffset, calculateJulianDayUTC, calculateHouses, getAstrologicalData, getPlanetHouse, showPlanetAspects, calculatePlanetAspects, getAllActiveAspects, showAllActiveAspects, getBirthDataFromConfig, getPersonDataFromConfig, detectAspectFigures, calculatePersonalTransits, showPersonalTransitAspects, showCombinedAnalysis, calculatePersonalTransitAspects, determineAspectPhase, findExactAspectTime, findLastExactAspectTime, getAspectAngle, getFutureAspects, getPastAspects, analyzeCSVWithDatetime, analyzeHouseDistributionSignificance, analyzeAspectDistributionSignificance, analyzeSignDistributionSignificance, calculateAspectStatistics, calculatePlanetComboAspects, showPlanetComboAspects, getCriticalPlanets, getHouseSystemCode, calculateNextPlanetIngress } = require('../astrology/astrologyService');
 const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel, setPerson1, setPerson2, setPerson, getPersonData, listPeople, deletePerson } = require('../config/configService');
 const { parseAppleHealthXML } = require('../health/healthService');
 const { analyzeStepsByPlanetSign, analyzeStressByPlanetAspects, analyzePlanetAspectsForSleep } = require('../health/healthAnalysis');
@@ -254,6 +254,7 @@ program
   .option('--v <count>', 'Shows past aspects between two planets (Format: --v <count> planet1 aspectType planet2)')
   .option('--z <count>', 'Shows future aspects between two planets (Format: --z <count> planet1 aspectType planet2)')
   .option('--csv <filepath>', 'Analyzes a CSV file with ISO-Datetime values or Unix timestamps')
+  .option('--in [count]', 'Shows next planet ingress (entering new sign). Optional count for multiple ingresses')
   .option('--gui', 'Launches the web interface for command history (port 37421)')
   .option('--gui-port <port>', 'Specify custom port for GUI server')
   .description('Shows astrological data for a planet')
@@ -1012,6 +1013,105 @@ program
       return;
     }
 
+    // Show next planet ingress if --in option is specified
+    if (options.in) {
+      // Determine the planet to use (default to moon if no planet specified)
+      const planetName = planetArg ? planetArg.toLowerCase() : 'moon';
+      
+      // Validate planet name
+      if (planets[planetName] === undefined) {
+        console.error(`Error: Invalid planet '${planetName}'. Available planets: ${Object.keys(planets).join(', ')}`);
+        process.exit(1);
+      }
+      
+      // Parse the count parameter (default to 1 if not specified)
+      const count = options.in && typeof options.in === 'string' && options.in.trim() ? parseInt(options.in) : 1;
+      
+      // Use custom date if specified
+      let customDate = null;
+      if (options.d) {
+        // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+        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; // Default: 12 o'clock
+          const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+          
+          // Check if the date is valid
+          const date = new Date(year, month - 1, day, hour, minute);
+          if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+            customDate = {
+              day: day,
+              month: month,
+              year: year,
+              hour: hour,
+              minute: minute
+            };
+            console.log(`Using custom date: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+          } else {
+            console.error('Invalid date:', options.d);
+            console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+            process.exit(1);
+          }
+        } else {
+          console.error('Invalid date:', options.d);
+          console.error('💡 Please use the format: DD.MM.YYYY or "DD.MM.YYYY HH:MM" (with quotes for date with time)');
+          process.exit(1);
+        }
+      }
+      
+      // Calculate next planet ingress(es)
+      const ingresses = calculateNextPlanetIngress(planetName, customDate, count);
+      
+      if (ingresses.length === 0) {
+        console.log(`No ${planetName} ingresses found.`);
+        return;
+      }
+      
+      const planetNameCapitalized = planetName.charAt(0).toUpperCase() + planetName.slice(1);
+      console.log(`Next ${planetNameCapitalized} Ingress(es):`);
+      console.log('================================================================================');
+      console.log('| #   | Date & Time           | From Sign    | To Sign      |');
+      console.log('================================================================================');
+      
+      ingresses.forEach((ingress, index) => {
+        const dateStr = `${ingress.date.day.toString().padStart(2, '0')}.${ingress.date.month.toString().padStart(2, '0')}.${ingress.date.year} ${ingress.date.hour.toString().padStart(2, '0')}:${ingress.date.minute.toString().padStart(2, '0')}`;
+        const fromSign = ingress.fromSign.padEnd(12, ' ');
+        const toSign = ingress.sign.padEnd(12, ' ');
+        
+        console.log(`| ${(index + 1).toString().padEnd(2)} | ${dateStr.padEnd(21)} | ${fromSign} | ${toSign} |`);
+      });
+      
+      console.log('================================================================================');
+      
+      if (count > 1) {
+        console.log(`\nShowing ${ingresses.length} ${planetName} ingresses starting from ${customDate ? 'the specified date' : 'now'}.`);
+      } else {
+        console.log(`\nShowing the next ${planetName} ingress from ${customDate ? 'the specified date' : 'now'}.`);
+      }
+      
+      // Handle AI request
+      if (options.p) {
+        const aiData = {
+          planet: planetName,
+          sign: 'Multiple',
+          degreeInSign: 'Multiple',
+          dignity: `Next ${planetName} ingress: ${ingresses[0].sign} at ${ingresses[0].date.day}.${ingresses[0].date.month}.${ingresses[0].date.year} ${ingresses[0].date.hour}:${ingresses[0].date.minute.toString().padStart(2, '0')}`,
+          element: 'Multiple',
+          decan: 'Multiple',
+          planetIngresses: ingresses
+        };
+        
+        await handleAIRequest(options, aiData);
+      }
+      
+      return;
+    }
+
     // For other options, a planet is required (except for --a or --s without planet)
     if (!planetArg && !options.a && !options.s) {
       console.error('Error: Planet is required for this operation.');