klio 1.4.9 → 1.5.0

package/README.md

@@ -98,6 +98,7 @@ It's possible to analyze a csv with a column of either ISO date time or unix tim
 - **Show house and sign distribution of the datetime column**: `klio [planet] --csv <file-path>`
 - **Show aspect type distribution between two planets:** `klio [planet1] [planet2] --csv <file-path> --a`
 - **Filter CSV data by column value:** `klio [planet] --csv <file-path> --filter "column:value"` (e.g., `--filter "Item:coffee"`)
+- **Filter CSV data by multiple conditions:** `klio [planet] --csv <file-path> --filter "column1:value1,column2:value2"` (e.g., `--filter "FTR:H,HomeTeam:Liverpool"`)
 - **Creating a bar chart**: Create a bar chart and save the image to the downloads' folder. The image shows the aspect distribution of your csv datetime values: `klio moon sun --csv /home/user/Downloads/coffee.csv  --filter "Item:cookie" --a --title "Eaten cookies during sun-moon aspects"`
 
 - The command also returns a Chi-Square. 

package/package.json

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

package/src/astrology/astrologyConstants.js

@@ -24,6 +24,12 @@ const elements = [
   'Air', 'Water', 'Fire', 'Earth', 'Air', 'Water'
 ];
 
+// Sign types (Cardinal, Fixed, Mutable)
+const signTypes = [
+  'Cardinal', 'Fixed', 'Mutable', 'Cardinal', 'Fixed', 'Mutable',
+  'Cardinal', 'Fixed', 'Mutable', 'Cardinal', 'Fixed', 'Mutable'
+];
+
 // Decans
 const decans = [
   '1st Decan', '2nd Decan', '3rd Decan',
@@ -50,6 +56,7 @@ module.exports = {
   planets,
   signs,
   elements,
+  signTypes,
   decans,
   dignities
 };

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, decans, dignities } = require('./astrologyConstants');
+const { planets, signs, elements, signTypes, decans, dignities } = require('./astrologyConstants');
 const { loadConfig } = require('../config/configService');
 const path = require('path');
 
@@ -454,12 +454,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 +508,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
       });
     }
   }
@@ -1904,16 +1946,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 +1977,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 +2001,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 +2067,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 +2104,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 +2206,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 +2226,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;
+            }
+
+            // 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
+            // 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);
+      }
+  }
   })
 }
 

package/src/cli/cli.js

@@ -341,6 +341,54 @@ program
         }
       }
       
+      // Use custom date if specified (overrides person data)
+      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);
+        }
+      }
+      
+      // If no custom date is specified, use current date
+      if (!customDate) {
+        const currentTime = getCurrentTimeInTimezone();
+        customDate = {
+          day: currentTime.day,
+          month: currentTime.month,
+          year: currentTime.year,
+          hour: currentTime.hour,
+          minute: currentTime.minute
+        };
+      }
+      
       const criticalPlanets = getCriticalPlanets(customDate);
       
       if (criticalPlanets.length === 0) {
@@ -348,18 +396,20 @@ program
         return;
       }
       
-      console.log('========================================================');
-      console.log('| Planet   | Sign     | Degree  | Type               |');
-      console.log('========================================================');
+      console.log('================================================================================================================');
+      console.log('| Planet   | Sign     | Degree  | Type               | Interpretation                                  |');
+      console.log('================================================================================================================');
       
       criticalPlanets.forEach(planet => {
         const planetName = planet.name.charAt(0).toUpperCase() + planet.name.slice(1);
         const sign = planet.sign.padEnd(10, ' ');
         const degree = planet.degree.padEnd(5, ' ');
-        console.log(`| ${planetName.padEnd(8)} | ${sign} | ${degree} | ${planet.criticalType} |`);
+        const criticalType = planet.criticalType.padEnd(20, ' ');
+        const interpretation = planet.interpretation.padEnd(46, ' ');
+        console.log(`| ${planetName.padEnd(8)} | ${sign} | ${degree} | ${criticalType} | ${interpretation} |`);
       });
       
-      console.log('========================================================');
+      console.log('================================================================================================================');
       if (shouldUseBirthData(options)) {
         console.log('\nThis analysis is based on your birth chart.');
       } else {