klio 1.5.6 → 1.5.8

package/README.md

@@ -36,6 +36,25 @@ npm install -g klio
 klio [options]
 ```
 
+### Planet Selection
+
+By default, Klio uses traditional planets plus Chiron. You can customize which planets and asteroids are active:
+
+```bash
+# Show currently active planets
+klio --active-planets
+
+# Set custom active planets (comma-separated)
+klio --planets "Sun,Moon,Mercury,Venus,Chiron,Hygiea"
+
+klio --planets "Sun,Moon,Mercury,Venus,Mars,Jupiter,Saturn,Uranus,Neptune,Pluto"
+```
+
+Available planets: Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, Chiron, Hygiea
+
+> **Note:** By default, only Chiron is active among asteroids. Other asteroids like Hygiea must be explicitly enabled.
+=======
+
 ### Web Interface
 
 AstroCLI includes a web-based GUI that you can launch with the `--gui` flag:

package/package.json

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

package/src/astrology/astrologyConstants.js

@@ -13,6 +13,25 @@ const planets = {
   chiron: 15
 };
 
+// Asteroid constants for Swiss Ephemeris
+// Note: These use the SE_AST_OFFSET (10000) + asteroid number
+const asteroidConstants = {
+  ceres: 10001,    // Ceres = 10000 + 1
+  pallas: 10002,   // Pallas = 10000 + 2
+  hygiea: 10010,   // Hygiea = 10000 + 10
+  juno: 10003,     // Juno = 10000 + 3
+  vesta: 10004     // Vesta = 10000 + 4
+};
+
+// Asteroid names for Swiss Ephemeris (used as string identifiers)
+const asteroidNames = {
+  ceres: 'Ceres',
+  pallas: 'Pallas',
+  hygiea: 'Hygiea',
+  juno: 'Juno',
+  vesta: 'Vesta'
+};
+
 // Zodiac signs (English)
 const signs = [
   'Aries', 'Taurus', 'Gemini', 'Cancer', 'Leo', 'Virgo',
@@ -54,8 +73,18 @@ const dignities = {
   15: { sign: 'Virgo', exaltation: 'Pisces', fall: 'Virgo', detriment: 'Pisces' } // Chiron
 };
 
+// Asteroid dignities (using asteroid constants as keys)
+const asteroidDignities = {
+  10001: { sign: 'Taurus', exaltation: 'Virgo', fall: 'Scorpio', detriment: 'Scorpio' }, // Ceres
+  10002: { sign: 'Libra', exaltation: 'Aries', fall: 'Libra', detriment: 'Aries' }, // Pallas
+  10010: { sign: 'Virgo', exaltation: 'Pisces', fall: 'Virgo', detriment: 'Pisces' } // Hygiea
+};
+
 module.exports = {
   planets,
+  asteroidNames,
+  asteroidConstants,
+  asteroidDignities,
   signs,
   elements,
   signTypes,

package/src/astrology/astrologyService.js

@@ -3,7 +3,7 @@ const fs = require('fs');
 const moment = require('moment-timezone');
 const csvParser = require('csv-parser');
 const { parse } = require('csv-parse/sync');
-const { planets, signs, elements, signTypes, decans, dignities } = require('./astrologyConstants');
+const { planets, asteroidNames, asteroidConstants, asteroidDignities, signs, elements, signTypes, decans, dignities } = require('./astrologyConstants');
 const { loadConfig } = require('../config/configService');
 const path = require('path');
 
@@ -49,6 +49,17 @@ function getCurrentTimeInTimezone() {
   };
 }
 
+// Function to get active planets (filtered by configuration)
+function getActivePlanets() {
+  try {
+    const { getActivePlanets } = require('../config/configService');
+    return getActivePlanets();
+  } catch (error) {
+    // Fallback to default active planets if config service is not available
+    return ['sun', 'moon', 'mercury', 'venus', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune', 'pluto', 'chiron'];
+  }
+}
+
 // Function to load birth data from configuration
 function getBirthDataFromConfig(userId = null) {
   try {
@@ -377,7 +388,14 @@ function getPlanetHouse(planetLongitude, houseCusps) {
 // Function to calculate astrological data
 function getAstrologicalData(planetName, customDate = null) {
   const planet = planets[planetName];
-  if (planet === undefined) {
+  const isAsteroid = asteroidNames[planetName] !== undefined;
+  let asteroidId = null;
+  
+  if (isAsteroid) {
+    asteroidId = asteroidConstants[planetName];
+  }
+  
+  if (planet === undefined && !isAsteroid) {
     console.error(`Invalid planet: ${planetName}. Available planets:`, Object.keys(planets).join(', '));
     process.exit(1);
   }
@@ -433,16 +451,53 @@ function getAstrologicalData(planetName, customDate = null) {
 
   const julianDay = calculateJulianDayUTC({ year: calcYear, month: calcMonth, day: calcDay, hour: calcHour, minute: calcMinute }, timezoneOffsetMinutes);
   const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
-  let result = swisseph.swe_calc_ut(julianDay, planet, flag);
+  let result;
 
-  if (result.error && result.error.includes('not found')) {
-    // Fallback to Moshier if ephemeris files are missing
-    const moshierFlag = swisseph.SEFLG_MOSEPH | swisseph.SEFLG_SPEED;
-    result = swisseph.swe_calc_ut(julianDay, planet, moshierFlag);
-  }
+  if (isAsteroid) {
+    // Handle asteroid calculations using proper Swiss Ephemeris constants
+    if (asteroidId) {
+      // Use the same swe_calc_ut function but with asteroid ID
+      result = swisseph.swe_calc_ut(julianDay, asteroidId, flag);
+      
+      if (result.error && result.error.includes('not found')) {
+        // Fallback to Moshier if ephemeris files are missing
+        const moshierFlag = swisseph.SEFLG_MOSEPH | swisseph.SEFLG_SPEED;
+        result = swisseph.swe_calc_ut(julianDay, asteroidId, moshierFlag);
+      }
+      
+      if (result.error) {
+        console.warn(`⚠️  Could not calculate asteroid ${planetName}: ${result.error}`);
+        // Fallback to placeholder data if calculation fails
+        result = {
+          longitude: 0,
+          latitude: 0,
+          distance: 0,
+          longitudeSpeed: 0
+        };
+      }
+    } else {
+      console.warn(`⚠️  Unknown asteroid: ${planetName}`);
+      // Fallback to placeholder data for unknown asteroids
+      result = {
+        longitude: 0,
+        latitude: 0,
+        distance: 0,
+        longitudeSpeed: 0
+      };
+    }
+  } else {
+    // Handle regular planet calculations
+    result = swisseph.swe_calc_ut(julianDay, planet, flag);
+
+    if (result.error && result.error.includes('not found')) {
+      // Fallback to Moshier if ephemeris files are missing
+      const moshierFlag = swisseph.SEFLG_MOSEPH | swisseph.SEFLG_SPEED;
+      result = swisseph.swe_calc_ut(julianDay, planet, moshierFlag);
+    }
 
-  if (result.error) {
-    throw new Error(result.error);
+    if (result.error) {
+      throw new Error(result.error);
+    }
   }
 
   const longitude = result.longitude;
@@ -452,16 +507,20 @@ function getAstrologicalData(planetName, customDate = null) {
   const element = elements[signIndex];
   const decan = decans[Math.floor((longitude % 30) / 10)];
 
-  const dignityInfo = dignities[planet];
+  // Get dignity info - use asteroid dignities for asteroids, regular dignities for planets
+  const dignityInfo = isAsteroid ? asteroidDignities[asteroidId] : dignities[planet];
   let dignity = 'Neutral';
-  if (sign === dignityInfo.sign) {
-    dignity = 'Ruler';
-  } else if (sign === dignityInfo.exaltation) {
-    dignity = 'Exaltation';
-  } else if (sign === dignityInfo.fall) {
-    dignity = 'Fall';
-  } else if (sign === dignityInfo.detriment) {
-    dignity = 'Detriment';
+  
+  if (dignityInfo) {
+    if (sign === dignityInfo.sign) {
+      dignity = 'Ruler';
+    } else if (sign === dignityInfo.exaltation) {
+      dignity = 'Exaltation';
+    } else if (sign === dignityInfo.fall) {
+      dignity = 'Fall';
+    } else if (sign === dignityInfo.detriment) {
+      dignity = 'Detriment';
+    }
   }
 
   return {
@@ -510,8 +569,16 @@ function getCriticalPlanets(customDate = null) {
   const offsetMinutes = timezone ? getTimezoneOffset(timeData, timezone) : -new Date().getTimezoneOffset();
   const julianDay = calculateJulianDayUTC(timeData, offsetMinutes);
   
-  // Calculate positions of all planets
+  // Get active planets from configuration
+  const activePlanets = getActivePlanets();
+  
+  // Calculate positions of active planets only
   for (const [name, planetId] of Object.entries(planets)) {
+    // Skip planets that are not in the active list
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
+    
     const flag = swisseph.SEFLG_SWIEPH | swisseph.SEFLG_SPEED;
     let result = swisseph.swe_calc_ut(julianDay, planetId, flag);
     
@@ -772,12 +839,12 @@ function showPlanetComboAspects(planetNames, dateComponents, useBirthData = fals
 // Function to calculate all active aspects between all planets
 function getAllActiveAspects(dateComponents) {
   const allAspects = [];
-  const planetNames = Object.keys(planets);
+  const activePlanets = getActivePlanets();
   const seenAspects = new Set(); // To avoid duplicates
   
-  // Calculate aspects for all planet pairs
-  for (let i = 0; i < planetNames.length; i++) {
-    const planet1 = planetNames[i];
+  // Calculate aspects for active planet pairs only
+  for (let i = 0; i < activePlanets.length; i++) {
+    const planet1 = activePlanets[i];
     const aspects = calculatePlanetAspects(planet1, dateComponents, true); // Always use Huber orbs
     
     aspects.forEach(aspect => {
@@ -1349,16 +1416,25 @@ async function calculatePersonalTransits(transitDate = null, birthData = null) {
   const birthJulianDay = calculateJulianDayUTC(birthData, getTimezoneOffset(birthData, birthData.location?.timezone || 'Europe/Zurich'));
   const houses = await calculateHouses(birthJulianDay, 'K', true, birthData.location || null); // Always Koch house system for transits
 
-  // Calculate current planet positions (Transit)
+  // Get active planets from configuration
+  const activePlanets = getActivePlanets();
+  
+  // Calculate current planet positions (Transit) for active planets only
   const transitPlanets = {};
   for (const [name, planetId] of Object.entries(planets)) {
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
     const data = getAstrologicalData(name, transitDate);
     transitPlanets[name] = data;
   }
 
-  // Calculate birth planet positions (Radix)
+  // Calculate birth planet positions (Radix) for active planets only
   const birthPlanets = {};
   for (const [name, planetId] of Object.entries(planets)) {
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
     const data = getAstrologicalData(name, birthData);
     birthPlanets[name] = data;
   }
@@ -1385,7 +1461,7 @@ async function calculatePersonalTransits(transitDate = null, birthData = null) {
 }
 
 // Function to calculate personal transit aspects
-function calculatePersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null) {
+function calculatePersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null, useHuberOrbs = true) {
   if (!birthData) {
     birthData = getBirthDataFromConfig();
     if (!birthData) {
@@ -1399,52 +1475,79 @@ function calculatePersonalTransitAspects(transitDate = null, birthData = null, t
     transitDate = getCurrentTimeInTimezone();
   }
 
-  // Calculate current planet positions (Transit)
+  // Get active planets from configuration
+  const activePlanets = getActivePlanets();
+  
+  // Calculate current planet positions (Transit) for active planets only
   const transitPlanets = {};
   for (const [name, planetId] of Object.entries(planets)) {
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
     const data = getAstrologicalData(name, transitDate);
     transitPlanets[name] = data.longitude;
   }
 
-  // Calculate birth planet positions (Radix)
+  // Calculate birth planet positions (Radix) for active planets only
   const birthPlanets = {};
   for (const [name, planetId] of Object.entries(planets)) {
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
     const data = getAstrologicalData(name, birthData);
     birthPlanets[name] = data.longitude;
   }
 
   // Calculate aspects between transit and birth planets
   const aspects = [];
-  const aspectTypes = [
+  // Use the same orb model as other aspect calculations; default to Huber orbs
+  const aspectTypes = useHuberOrbs ? [
     { name: 'Conjunction', angle: 0, orb: 8 },
     { name: 'Opposition', angle: 180, orb: 8 },
     { name: 'Square', angle: 90, orb: 6 },
     { name: 'Trine', angle: 120, orb: 6 },
-    { name: 'Sextile', angle: 60, orb: 4 }
+    { name: 'Sextile', angle: 60, orb: 4 },
+    { name: 'Quincunx', angle: 150, orb: 3 }
+  ] : [
+    { name: 'Conjunction', angle: 0, orb: 10 },
+    { name: 'Opposition', angle: 180, orb: 10 },
+    { name: 'Square', angle: 90, orb: 8 },
+    { name: 'Trine', angle: 120, orb: 8 },
+    { name: 'Sextile', angle: 60, orb: 6 },
+    { name: 'Quincunx', angle: 150, orb: 4 }
   ];
 
   // Compare each transit planet with each birth planet
   for (const [transitName, transitLongitude] of Object.entries(transitPlanets)) {
+    // If filtering by target planet, only calculate for that transit planet
+    if (targetPlanet && transitName !== targetPlanet) continue;
+
     for (const [birthName, birthLongitude] of Object.entries(birthPlanets)) {
       // Skip if it's the same planet
       if (transitName === birthName) continue;
 
-      // Calculate the angle difference
-      const angleDiff = Math.abs(transitLongitude - birthLongitude) % 360;
-      const normalizedAngle = Math.min(angleDiff, 360 - angleDiff);
+      // Calculate the angle between the two planets
+      let rawDiff = transitLongitude - birthLongitude;
+      let angleDiff = ((rawDiff % 360) + 360) % 360;
 
-      // Check for aspects
+      // Check for aspects using the actual angle
       for (const aspect of aspectTypes) {
-        if (Math.abs(normalizedAngle - aspect.angle) <= aspect.orb) {
+        // Check both the angle and its complement (360 - angle)
+        const diff1 = Math.abs(angleDiff - aspect.angle);
+        const diff2 = Math.abs((360 - angleDiff) - aspect.angle);
+        const diff = Math.min(diff1, diff2);
+
+        if (diff <= aspect.orb) {
           aspects.push({
             transitPlanet: transitName,
             birthPlanet: birthName,
             type: aspect.name,
-            angle: normalizedAngle.toFixed(2),
-            orb: Math.abs(normalizedAngle - aspect.angle).toFixed(2),
+            angle: angleDiff.toFixed(2),
+            orb: diff.toFixed(2),
             transitLongitude: transitLongitude,
             birthLongitude: birthLongitude
           });
+          break; // Only match one aspect per planet pair
         }
       }
     }
@@ -1463,8 +1566,8 @@ function calculatePersonalTransitAspects(transitDate = null, birthData = null, t
 }
 
 // Function to display personal transit aspects
-function showPersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null) {
-  const aspectData = calculatePersonalTransitAspects(transitDate, birthData, targetPlanet);
+function showPersonalTransitAspects(transitDate = null, birthData = null, targetPlanet = null, useHuberOrbs = true) {
+  const aspectData = calculatePersonalTransitAspects(transitDate, birthData, targetPlanet, useHuberOrbs);
   
   if (!aspectData || aspectData.aspects.length === 0) {
     console.log('No personal transit aspects found.');
@@ -1472,7 +1575,7 @@ function showPersonalTransitAspects(transitDate = null, birthData = null, target
   }
 
   const transitDateDisplay = transitDate || getCurrentTimeInTimezone();
-  console.log(`Personal Transit Aspects (${transitDateDisplay.day}.${transitDateDisplay.month}.${transitDateDisplay.year}):`);
+  console.log(`Personal Transit Aspects (${transitDateDisplay.day}.${transitDateDisplay.month}.${transitDateDisplay.year}) [${(aspectData && aspectData.aspects.length>0) ? (useHuberOrbs ? 'Huber orbs' : 'Standard orbs') : ''}]:`);
   console.log('================================================================================');
   console.log('| Transit     | Birth      | Aspect      | Orb   | Transit Pos | Birth Pos   |');
   console.log('================================================================================');
@@ -1606,15 +1709,23 @@ function analyzeElementDistribution(dateComponents, useBirthData = false) {
   
   const planetElements = {};
   
-  // Calculate elements of all planets
+  // Get active planets from configuration
+  const activePlanets = getActivePlanets();
+  
+  // Calculate elements of active planets only
   for (const [name, planetId] of Object.entries(planets)) {
+    // Skip planets that are not in the active list
+    if (!activePlanets.includes(name)) {
+      continue;
+    }
+    
     const data = getAstrologicalData(name, dateComponents);
     elementCounts[data.element]++;
     planetElements[name] = data.element;
   }
   
-  // Calculate total number of planets
-  const totalPlanets = Object.keys(planets).length;
+  // Calculate total number of active planets
+  const totalPlanets = activePlanets.length;
   
   // Calculate percentages
   const elementPercentages = {};
@@ -1859,7 +1970,7 @@ function parseFilterCriteria(filterString) {
   const filterConditions = filterString.split(',').map(cond => cond.trim());
   
   const criteria = [];
-  const operatorRegex = /^(.+?)\s*(>=|<=|!=|=|>|<|\*|!)\s*(.+)$/;
+  const operatorRegex = /^(.+?)\s*(>=|<=|!=|=|>|<)\s*(.+)$/;
   
   for (const condition of filterConditions) {
     const operatorMatch = condition.match(operatorRegex);
@@ -1872,23 +1983,33 @@ function parseFilterCriteria(filterString) {
       continue;
     }
 
-    // Check for contains (*) or excludes (!) operators in the value part
-    const containsMatch = condition.match(/^(.+?):\*(.+)$/);
-    if (containsMatch) {
-      criteria.push({
-        column: containsMatch[1].trim(),
-        operator: '*',
-        value: containsMatch[2].trim()
-      });
-      continue;
-    }
-
-    const excludesMatch = condition.match(/^(.+?):!(.+)$/);
-    if (excludesMatch) {
+    // Check for wildcard patterns in the value (new enhanced syntax)
+    const wildcardMatch = condition.match(/^([^:]+):(.+)$/);
+    if (wildcardMatch) {
+      const column = wildcardMatch[1].trim();
+      const value = wildcardMatch[2].trim();
+      
+      // Remove * and ! from the value for contains/excludes operations
+      const cleanValue = value.replace(/^[*!]+/, '').replace(/[*!]+$/, '');
+      
+      // Check if value contains * or starts with !
+      if (value.includes('*') || value.startsWith('!')) {
+        // Use * operator for contains matching (remove * from value)
+        // Use ! operator for excludes matching (remove ! from value)
+        const operator = value.startsWith('!') ? '!' : '*';
+        criteria.push({
+          column: column,
+          operator: operator,
+          value: cleanValue
+        });
+        continue;
+      }
+      
+      // Regular equality match
       criteria.push({
-        column: excludesMatch[1].trim(),
-        operator: '!',
-        value: excludesMatch[2].trim()
+        column: column,
+        operator: '=',
+        value: value
       });
       continue;
     }
@@ -2074,6 +2195,13 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
             const trimmed = value != null ? value.toString().trim() : '';
             return /^\d{2}\/\d{2}\/\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(trimmed);
           });
+
+          // Second pass alternative: look for DD.MM.YYYY format (optional time)
+          const ddMmYyyyDotColumns = Object.keys(data).filter(key => {
+            const value = data[key];
+            const trimmed = value != null ? value.toString().trim() : '';
+            return /^\d{2}\.\d{2}\.\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(trimmed);
+          });
           
           // Third pass: look for Unix timestamps (10 or 13 digits)
           const unixTimestampColumns = Object.keys(data).filter(key => {
@@ -2093,8 +2221,8 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
             return moment(trimmed, moment.ISO_8601, true).isValid();
           });
           
-            // Prioritize columns: YYYY-MM-DD, DD/MM/YYYY, Unix timestamps, then ISO dates
-            datetimeColumns.push(...yyyyMmDdColumns, ...ddMmYyyyColumns, ...unixTimestampColumns, ...isoDateColumns);
+            // Prioritize columns: YYYY-MM-DD, DD/MM/YYYY, DD.MM.YYYY, Unix timestamps, then ISO dates
+            datetimeColumns.push(...yyyyMmDdColumns, ...ddMmYyyyColumns, ...ddMmYyyyDotColumns, ...unixTimestampColumns, ...isoDateColumns);
             
             if (datetimeColumns.length > 0) {
               datetimeValue = data[datetimeColumns[0]];
@@ -2121,6 +2249,15 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
               if (datetime.isValid() && !hasTime) {
                 datetime = datetime.hour(12).minute(0);
               }
+            } else if (/^\d{2}\.\d{2}\.\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(datetimeValueTrimmed)) {
+              // Handle as DD.MM.YYYY (optional time)
+              const hasTime = /\d{1,2}:\d{2}/.test(datetimeValueTrimmed);
+              // Replace dots with slashes to use the same parsing logic
+              const datetimeValueWithSlashes = datetimeValueTrimmed.replace(/\./g, '/');
+              datetime = moment(datetimeValueWithSlashes, ['DD/MM/YYYY HH:mm:ss', 'DD/MM/YYYY HH:mm', 'DD/MM/YYYY'], true);
+              if (datetime.isValid() && !hasTime) {
+                datetime = datetime.hour(12).minute(0);
+              }
             } else {
               // Handle as ISO-8601 date
               datetime = moment(datetimeValueTrimmed);
@@ -2324,9 +2461,11 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
             const isYYYYMMDD = /^\d{4}-\d{2}-\d{2}$/.test(trimmed);
             // Check for DD/MM/YYYY date format
             const isDDMMYYYY = /^\d{2}\/\d{2}\/\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(trimmed);
+            // Check for DD.MM.YYYY date format
+            const isDDMMYYYYDot = /^\d{2}\.\d{2}\.\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(trimmed);
             // Check for Unix-Timestamp (number with 10 or 13 digits)
             const isUnixTimestamp = /^\d{10,13}$/.test(trimmed);
-            return isISO || isYYYYMMDD || isDDMMYYYY || isUnixTimestamp;
+            return isISO || isYYYYMMDD || isDDMMYYYY || isDDMMYYYYDot || isUnixTimestamp;
           });
 
             if (datetimeColumns.length > 0) {
@@ -2354,6 +2493,15 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
               if (datetime.isValid() && !hasTime) {
                 datetime = datetime.hour(12).minute(0);
               }
+            } else if (/^\d{2}\.\d{2}\.\d{4}(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(datetimeValueTrimmed)) {
+              // Handle as DD.MM.YYYY (optional time)
+              const hasTime = /\d{1,2}:\d{2}/.test(datetimeValueTrimmed);
+              // Replace dots with slashes to use the same parsing logic
+              const datetimeValueWithSlashes = datetimeValueTrimmed.replace(/\./g, '/');
+              datetime = moment(datetimeValueWithSlashes, ['DD/MM/YYYY HH:mm:ss', 'DD/MM/YYYY HH:mm', 'DD/MM/YYYY'], true);
+              if (datetime.isValid() && !hasTime) {
+                datetime = datetime.hour(12).minute(0);
+              }
             } else {
               // Handle as ISO-8601 date
               datetime = moment(datetimeValueTrimmed);
@@ -3053,7 +3201,10 @@ module.exports = {
   calculateNextPlanetIngress,
   calculateAstrologicalAngles,
   longitudeToSignDegree,
-  calculateTransitFrequency
+  calculateTransitFrequency,
+  // Filter functions for testing
+  parseFilterCriteria,
+  applyFilter
 };
 
 // Function to calculate how often a transit occurs between two planets

package/src/cli/cli.js

@@ -393,7 +393,7 @@ program
   .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('--date-col <column>', 'Specifies the column name containing date values (e.g., --date-col "Buchungsdatum")')
-  .option('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee")')
+  .option('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee", "Item:*coffee*", "Item:!bad*")')
   .option('--title <title>', 'Title for the chart image (generates PNG image when provided)')
   .option('--in [count]', 'Shows next planet ingress (entering new sign). Optional count for multiple ingresses')
   .option('--wiki <occupation>', 'Fetches people from Wikidata by occupation and checks for specific aspects (Format: planet1 aspectType planet2 --wiki <occupation> [limit])')
@@ -401,6 +401,8 @@ program
   .option('--gui-port <port>', 'Specify custom port for GUI server')
   .option('--gui-verbose', 'Enable verbose logging for GUI server')
   .option('--o', 'Shows how often this transit occurs in the sky (frequency calculation)')
+  .option('--planets <list>', 'Select active planets and asteroids (comma-separated, e.g., "Sun,Moon,Mercury,Venus,Hygiea")')
+  .option('--active-planets', 'Show the currently active planets')
   .description('Shows astrological data for a planet')
   .action(async (planetArg, planet2Arg, options) => {
     // If planet2Arg is an object, it contains the options (commander behavior)
@@ -875,46 +877,68 @@ program
         const houses = await calculateHouses(birthJulianDay, getHouseSystemCode(houseSystem), true);
         const transitDateDisplay = transitDate || getCurrentTimeInTimezone();
 
-        // Show transit aspects for all planets
+        // Collect all transit aspects first
+        const allAspects = [];
         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 transitAspectsData = calculatePersonalTransitAspects(transitDateDisplay, birthData, planetName, true);
           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);
-              
-              // Determine aspect phase
-              const aspectAngles = {
-                'Conjunction': 0,
-                'Opposition': 180,
-                'Square': 90,
-                'Trine': 120,
-                'Sextile': 60
-              };
-              const targetAngle = aspectAngles[aspect.type];
-              const phase = determineAspectPhase(planetName, aspect.birthPlanet, transitDateDisplay, aspect.type, targetAngle);
-              
-              // Exact time calculation removed
-              const dateTimeStr = '-';
-              
-              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} |`);
+          
+          // Add planet data to each aspect for later display
+          transitAspects.forEach(aspect => {
+            allAspects.push({
+              planetName: planetName,
+              transitPlanetData: transitPlanetData,
+              transitHouse: transitHouse,
+              aspect: aspect,
+              birthPlanetData: getAstrologicalData(aspect.birthPlanet, birthData),
+              birthHouse: getPlanetHouse(parseFloat(getAstrologicalData(aspect.birthPlanet, birthData).degreeInSign) + (signs.indexOf(getAstrologicalData(aspect.birthPlanet, birthData).sign) * 30), houses.house)
             });
-          }
+          });
         }
 
+        // Sort all aspects by orb (smallest orb first)
+        allAspects.sort((a, b) => {
+          return parseFloat(a.aspect.orb) - parseFloat(b.aspect.orb);
+        });
+
+        // Display sorted aspects
+        allAspects.forEach(aspectData => {
+          const planetName = aspectData.planetName;
+          const transitPlanetData = aspectData.transitPlanetData;
+          const transitHouse = aspectData.transitHouse;
+          const aspect = aspectData.aspect;
+          const birthPlanetData = aspectData.birthPlanetData;
+          const birthHouse = aspectData.birthHouse;
+          
+          // Determine aspect phase
+          const aspectAngles = {
+            'Conjunction': 0,
+            'Opposition': 180,
+            'Square': 90,
+            'Trine': 120,
+            'Sextile': 60
+          };
+          const targetAngle = aspectAngles[aspect.type];
+          const phase = determineAspectPhase(planetName, aspect.birthPlanet, transitDateDisplay, aspect.type, targetAngle);
+          
+          // Exact time calculation removed
+          const dateTimeStr = '-';
+          
+          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} |`);
+        });
+
         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')}`);
@@ -975,13 +999,13 @@ program
       // Show personal transit aspects
       // Use the specific planet if specified, or all planets
       const targetPlanet = planetArg ? planetArg.toLowerCase() : null;
-      showPersonalTransitAspects(transitDate, birthData, targetPlanet);
+      showPersonalTransitAspects(transitDate, birthData, targetPlanet, true);
       
       // Handle AI request for personal transit aspects
       if (options.p) {
         // Get the transit aspects data for AI
         const { calculatePersonalTransitAspects } = require('../astrology/astrologyService');
-        const transitAspectsData = calculatePersonalTransitAspects(transitDate, birthData, targetPlanet);
+        const transitAspectsData = calculatePersonalTransitAspects(transitDate, birthData, targetPlanet, true);
         const transitAspects = transitAspectsData ? transitAspectsData.aspects : [];
         
         const aiData = {
@@ -1207,6 +1231,21 @@ program
       return;
     }
 
+    // Set active planets if --planets option is specified (no planet required)
+    if (options.planets) {
+      const { setActivePlanets } = require('../config/configService');
+      setActivePlanets(options.planets);
+      return;
+    }
+
+    // Show active planets if --active-planets option is specified (no planet required)
+    if (options.activePlanets) {
+      const { getActivePlanets } = require('../config/configService');
+      const activePlanets = getActivePlanets();
+      console.log('Active planets:', activePlanets.join(', '));
+      return;
+    }
+
     // Set AI model if --ai option is specified (no planet required)
     if (options.ai) {
       setAIModel(options.ai);

package/src/cli/cliService.js

@@ -160,13 +160,15 @@ class CLIService {
       .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('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee")')
+      .option('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee", "Item:*coffee*", "Item:!bad*")')
       .option('--title <title>', 'Title for the chart image (generates PNG image when provided)')
       .option('--in [count]', 'Shows next planet ingress (entering new sign). Optional count for multiple ingresses')
       .option('--wiki <occupation>', 'Fetches people from Wikidata by occupation and checks for specific aspects (Format: planet1 aspectType planet2 --wiki <occupation> [limit])')
       .option('--gui', 'Launches the web interface for command history (port 37421)')
       .option('--gui-port <port>', 'Specify custom port for GUI server')
       .option('--o', 'Shows how often this transit occurs in the sky (frequency calculation)')
+      .option('--planets <list>', 'Select active planets and asteroids (comma-separated, e.g., "Sun,Moon,Mercury,Venus,Hygiea")')
+      .option('--active-planets', 'Show the currently active planets')
       .description('Shows astrological data for a planet')
       .action(this.handleCommand.bind(this));
   }
@@ -652,6 +654,21 @@ class CLIService {
         return { success: true, output: output.join('\n') };
       }
 
+      // Set active planets if --planets option is specified (no planet required)
+      if (actualOptions.planets) {
+        const { setActivePlanets } = require('../config/configService');
+        setActivePlanets(actualOptions.planets, userId);
+        return { success: true, output: output.join('\n') };
+      }
+
+      // Show active planets if --active-planets option is specified (no planet required)
+      if (actualOptions.activePlanets) {
+        const { getActivePlanets } = require('../config/configService');
+        const activePlanets = getActivePlanets(userId);
+        console.log('Active planets:', activePlanets.join(', '));
+        return { success: true, output: output.join('\n') };
+      }
+
       // Delete person if --delete-person option is specified (no planet required)
       if (actualOptions.deletePerson) {
         deletePerson(actualOptions.deletePerson, userId);

package/src/config/configService.js

@@ -456,6 +456,52 @@ function setAIModel(modelName, userId = null) {
   return false;
 }
 
+// Function to set active planets
+function setActivePlanets(planetList, userId = null) {
+  const config = loadConfig(userId) || {
+    currentLocation: null,
+    birthData: null,
+    setupDate: new Date().toISOString()
+  };
+
+  // Get available planets for validation
+  const { planets } = require('../astrology/astrologyConstants');
+  const availablePlanets = Object.keys(planets);
+
+  // Convert comma-separated string to array and normalize planet names
+  const planetsArray = planetList.split(',').map(p => p.trim().toLowerCase());
+  
+  // Validate planet names
+  const invalidPlanets = planetsArray.filter(p => !availablePlanets.includes(p));
+  if (invalidPlanets.length > 0) {
+    console.error(`Error: Invalid planet names: ${invalidPlanets.join(', ')}`);
+    console.error(`Available planets: ${availablePlanets.join(', ')}`);
+    return false;
+  }
+  
+  config.activePlanets = planetsArray;
+
+  if (saveConfig(config, userId)) {
+    console.log(`Active planets set: ${planetsArray.join(', ')}`);
+    return true;
+  }
+  return false;
+}
+
+// Function to get active planets (with defaults)
+function getActivePlanets(userId = null) {
+  const config = loadConfig(userId);
+  
+  // Default active planets (traditional planets + Chiron, excluding other asteroids)
+  const defaultActivePlanets = ['sun', 'moon', 'mercury', 'venus', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune', 'pluto', 'chiron'];
+  
+  if (config && config.activePlanets && Array.isArray(config.activePlanets)) {
+    return config.activePlanets;
+  }
+  
+  return defaultActivePlanets;
+}
+
 // Function to set a custom system prompt
 function setSystemPrompt(prompt, userId = null) {
   const config = loadConfig(userId) || {
@@ -903,5 +949,8 @@ module.exports = {
   showNotes,
   searchNotesBySituation,
   // Add helper functions for user-specific operations
-  getConfigPath
+  getConfigPath,
+  // Planet selection functions
+  setActivePlanets,
+  getActivePlanets
 };