klio 1.4.8 → 1.5.0

package/README.md

@@ -97,8 +97,11 @@ 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. 
+- The command also returns a Chi-Square. 
 
 ### Adding different charts
 
@@ -109,7 +112,7 @@ The command also returns a Chi-Square.
   - `--people` - Lists all saved persons
   - `--delete-person <id>` - Deletes a person
 
-Then, instead using `--i` for the commands from above you can use `--wp <id>` i.e. `--wp john`
+Then, instead using `--i` for the commands from above you can use `--wp <id>` or  `--wp john`
 
 ### Advanced Features
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klio",
-  "version": "1.4.8",
+  "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
       });
     }
   }
@@ -1900,13 +1942,66 @@ function analyzeSignDistributionSignificance(signDistribution) {
   };
 }
 
-function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'koch', analyzeAspects = false, partnerPlanet = null) {
+// Helper function to parse filter criteria
+function parseFilterCriteria(filterString) {
+  if (!filterString) 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 criteria.length === 1 ? criteria[0] : criteria;
+}
+
+// Helper function to apply filter to records
+function applyFilter(records, filterCriteria) {
+  if (!filterCriteria || !records || records.length === 0) return records;
+  
+  const parsedCriteria = typeof filterCriteria === 'string' 
+    ? parseFilterCriteria(filterCriteria) 
+    : filterCriteria;
+  
+  if (!parsedCriteria) return records;
+  
+  // 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) {
   return new Promise(async (resolve, reject) => {
     const results = [];
     let pendingOperations = 0;
 
     // Helper function to process results
     function processResults() {
+
       // Calculate house distribution
       const houseCounts = {};
       results.forEach(result => {
@@ -1967,17 +2062,38 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
           skip_empty_lines: true
         });
 
+        // Apply filter if specified
+        const filteredRecords = filterCriteria ? applyFilter(records, filterCriteria) : records;
+
         // Process each row
-        for (const data of records) {
-          // Look for a column with ISO-Datetime values or Unix-Timestamps
-          const datetimeColumns = Object.keys(data).filter(key => {
+        for (const data of filteredRecords) {
+          // 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]];
@@ -1988,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);
@@ -2086,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() {
@@ -2104,125 +2226,193 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
       }
     } else {
       // Standard file processing for local files
-      fs.createReadStream(filePath)
-          .pipe(csvParser())
-          .on('data', (data) => {
-            // 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;
-            });
-
-            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);
+      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 (Array.isArray(parsedCriteria)) {
+                // Multiple criteria - all must match
+                shouldSkip = !parsedCriteria.every(criterion => {
+                  const recordValue = data[criterion.column];
+                  return recordValue && recordValue.toString() === criterion.value;
+                });
               } else {
-                // Handle as ISO-8601 date
-                datetime = moment(datetimeValue);
+                // Single criteria
+                const recordValue = data[parsedCriteria.column];
+                shouldSkip = !recordValue || recordValue.toString() !== parsedCriteria.value;
               }
-
-              // 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;
+              
+              if (shouldSkip) {
+                continue; // Skip this record
               }
+            }
+          }
+
+          // 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;
+
+            // 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 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 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
                     }
+                  }
+
+                  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);
 
-                    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);
+                  // 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);
                     }
+                  }
 
-                    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

@@ -11,6 +11,16 @@ const swisseph = require('swisseph');
 const path = require('path');
 const fs = require('fs');
 
+// Import chart generation and downloads folder utilities
+let chartGenerator = null;
+let downloadsFolder = null;
+try {
+  chartGenerator = require('../utils/chartGenerator');
+  downloadsFolder = require('../utils/downloadsFolder');
+} catch (error) {
+  console.debug('Chart generation utilities not available');
+}
+
 // Wikidata service import
 let wikidataService = null;
 try {
@@ -265,6 +275,8 @@ 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('--filter <column:value>', 'Filters CSV data by column:value (e.g., --filter "Item:coffee")')
+  .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)')
@@ -329,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) {
@@ -336,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 {
@@ -1495,8 +1557,9 @@ program
       const planet = planetArg ? planetArg.toLowerCase() : 'moon';
       const houseSystem = actualOptions.hs ? actualOptions.hs.toLowerCase() : 'koch';
       const analyzeAspects = actualOptions.a || false;
+      const filterCriteria = actualOptions.filter;
       
-      analyzeCSVWithDatetime(actualOptions.csv, planet, houseSystem, analyzeAspects, planet2)
+      analyzeCSVWithDatetime(actualOptions.csv, planet, houseSystem, analyzeAspects, planet2, filterCriteria)
         .then(({ results, houseDistribution, signDistribution, aspectStatistics }) => {
           if (results.length === 0) {
             console.log('No valid ISO-Datetime values found in the CSV file.');
@@ -1614,6 +1677,60 @@ program
             // Also show total number of records and house system
             console.log(`\nIn Total: ${results.length}`);
             console.log(`House system: ${houseSystem.charAt(0).toUpperCase() + houseSystem.slice(1)}`);
+            
+            // Generate chart image if --title option is provided
+            if (actualOptions.title && chartGenerator && downloadsFolder) {
+              try {
+                // Get the downloads folder path
+                const downloadsPath = downloadsFolder.getValidDownloadsFolder();
+                
+                // Create a safe filename from the title
+                const safeTitle = actualOptions.title
+                  .replace(/[^a-zA-Z0-9\s\-_.]/g, '')
+                  .substring(0, 50)
+                  .trim();
+                
+                const timestamp = new Date().toISOString()
+                  .replace(/[:.]/g, '-')
+                  .substring(0, 19);
+                
+                const filename = `${timestamp}_${safeTitle}.png`;
+                const outputPath = path.join(downloadsPath, filename);
+                
+                console.log(`\n📊 Generating chart image: ${filename}`);
+                console.log(`💾 Saving to: ${outputPath}`);
+                
+                // Calculate statistics for the chart
+                let chartStats = null;
+                if (analyzeAspects && aspectStatistics) {
+                  const { analyzeAspectDistributionSignificance } = require('../astrology/astrologyService');
+                  chartStats = analyzeAspectDistributionSignificance(aspectStatistics);
+                } else if (houseDistribution) {
+                  const { analyzeHouseDistributionSignificance } = require('../astrology/astrologyService');
+                  chartStats = analyzeHouseDistributionSignificance(houseDistribution);
+                }
+                
+                // Generate the chart
+                const chartData = {
+                  houseDistribution: houseDistribution || { counts: {}, total: results.length },
+                  aspectStatistics: aspectStatistics || { types: [], counts: {}, total: 0 },
+                  results: results,
+                  statistics: chartStats
+                };
+                
+                return chartGenerator.generateBarChart(
+                  chartData,
+                  actualOptions.title,
+                  outputPath,
+                  analyzeAspects // Show aspects if --a option was used
+                ).then(imagePath => {
+                  console.log(`✅ Chart image successfully saved to: ${imagePath}`);
+                  console.log(`📁 You can find it in your Downloads folder`);
+                });
+              } catch (error) {
+                console.error('❌ Error generating chart image:', error.message);
+              }
+            }
           }
         })
         .catch(error => {
@@ -2509,8 +2626,9 @@ program
       const planet = planetArg ? planetArg.toLowerCase() : 'moon';
       const houseSystem = actualOptions.hs ? actualOptions.hs.toLowerCase() : 'koch';
       const analyzeAspects = actualOptions.a || false;
+      const filterCriteria = actualOptions.filter;
       
-      analyzeCSVWithDatetime(actualOptions.csv, planet, houseSystem, analyzeAspects, planet2)
+      analyzeCSVWithDatetime(actualOptions.csv, planet, houseSystem, analyzeAspects, planet2, filterCriteria)
         .then(({ results, houseDistribution, signDistribution, aspectStatistics }) => {
           if (results.length === 0) {
             console.log('No valid ISO-Datetime values found in the CSV file.');

package/src/utils/chartGenerator.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generate a bar chart SVG from CSV analysis data
+ * @param {Object} data - CSV analysis data
+ * @param {string} title - Chart title
+ * @param {string} outputPath - Output file path
+ * @param {boolean} showAspects - Whether to show aspects or house distribution
+ * @returns {Promise<string>} Path to the generated image
+ */
+async function generateBarChart(data, title, outputPath, showAspects = false) {
+  // SVG dimensions
+  const width = 1200;
+  const height = 800;
+  const padding = 60;
+  const chartWidth = width - 2 * padding;
+  const chartHeight = height - 2 * padding;
+  const titleHeight = 80;
+  const legendHeight = 100;
+
+  // Colors
+  const barColors = ['#4e79a7', '#f28e2b', '#e15759', '#76b7b2', '#59a14f', '#edc948', '#b07aa1', '#ff9da7', '#9c755f', '#bab0ac'];
+
+  // Prepare data for charting
+  let chartData, labels, maxValue, dataType;
+
+  if (showAspects && data.aspectStatistics) {
+    // Aspect statistics chart
+    dataType = 'Aspects';
+    chartData = data.aspectStatistics.types.map((type, index) => ({
+      label: type,
+      value: data.aspectStatistics.counts[type] || 0,
+      color: barColors[index % barColors.length]
+    }));
+    maxValue = Math.max(...chartData.map(d => d.value), 10);
+  } else {
+    // House distribution chart (default)
+    dataType = 'House Distribution';
+    chartData = [];
+    
+    // Ensure houseDistribution exists and has counts
+    const houseDist = data.houseDistribution || { counts: {} };
+    
+    for (let i = 1; i <= 12; i++) {
+      chartData.push({
+        label: `House ${i}`,
+        value: houseDist.counts[i] || 0,
+        color: barColors[(i-1) % barColors.length]
+      });
+    }
+    
+    maxValue = Math.max(...chartData.map(d => d.value), 10);
+  }
+
+  // Calculate bar dimensions
+  const barCount = chartData.length;
+  const barWidth = chartWidth / barCount / 1.5;
+  const maxBarHeight = chartHeight - titleHeight - legendHeight;
+  const yScale = maxBarHeight / maxValue;
+
+  // Generate SVG
+  const svgContent = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg">
+  <!-- Background -->
+  <rect width="100%" height="100%" fill="#f8f9fa"/>
+
+  <!-- Title -->
+  <text x="${width/2}" y="${padding + titleHeight/2 + 10}" font-family="Arial" font-size="24" font-weight="bold" text-anchor="middle" fill="#333333">${title}</text>
+  
+  <!-- Statistical Subtitle -->
+  ${data.statistics ? `
+  <text x="${width/2}" y="${padding + titleHeight/2 + 40}" font-family="Arial" font-size="16" font-weight="bold" text-anchor="middle" fill="#666666">
+    χ²(${data.statistics.degreesOfFreedom}) = ${data.statistics.chiSquare}, p ${data.statistics.isSignificant ? '&lt; 0.05' : '≥ 0.05'}, Cramer's V = ${data.statistics.effectSize}
+  </text>
+  ` : ''}
+
+  <!-- Y-axis grid lines -->
+  ${Array.from({length: 6}).map((_, i) => {
+    const y = height - padding - (i * maxBarHeight / 5);
+    return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}" stroke="#e0e0e0" stroke-width="1"/>`;
+  }).join('')}
+
+  <!-- Y-axis labels -->
+  ${Array.from({length: 6}).map((_, i) => {
+    const y = height - padding - (i * maxBarHeight / 5);
+    const value = Math.round(maxValue * (i / 5));
+    return `<text x="${padding - 10}" y="${y + 4}" font-family="Arial" font-size="14" text-anchor="end" fill="#666666">${value}</text>`;
+  }).join('')}
+
+  <!-- X-axis -->
+  <line x1="${padding}" y1="${height - padding}" x2="${width - padding}" y2="${height - padding}" stroke="#666666" stroke-width="2"/>
+
+  <!-- Bars -->
+  ${chartData.map((d, index) => {
+    const barHeight = d.value * yScale;
+    const x = padding + (index * (barWidth * 1.5)) + barWidth / 2;
+    const y = height - padding - barHeight;
+    
+    return `
+    <rect x="${x - barWidth / 2}" y="${y}" width="${barWidth}" height="${barHeight}" fill="${d.color}"/>
+    ${barHeight > 20 ? `<text x="${x}" y="${y + 20}" font-family="Arial" font-size="14" font-weight="bold" text-anchor="middle" fill="white">${d.value}</text>` : ''}
+    `;
+  }).join('')}
+
+  <!-- X-axis labels -->
+  ${chartData.map((d, index) => {
+    const x = padding + (index * (barWidth * 1.5)) + barWidth / 2;
+    const y = height - padding + 25;
+    return `<text x="${x}" y="${y}" font-family="Arial" font-size="14" text-anchor="middle" fill="#666666">${d.label}</text>`;
+  }).join('')}
+</svg>`;
+
+  // Save the SVG file
+  return new Promise((resolve, reject) => {
+    fs.writeFile(outputPath, svgContent, 'utf8', (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(outputPath);
+      }
+    });
+  });
+}
+
+module.exports = {
+  generateBarChart
+};

package/src/utils/downloadsFolder.js

@@ -0,0 +1,70 @@
+const path = require('path');
+const os = require('os');
+
+/**
+ * Gets the default downloads folder path for the current operating system
+ * @returns {string} Path to the downloads folder
+ */
+function getDownloadsFolder() {
+  const homeDir = os.homedir();
+  
+  switch (process.platform) {
+    case 'win32':
+      // Windows: %USERPROFILE%\Downloads
+      return path.join(homeDir, 'Downloads');
+    
+    case 'darwin':
+      // macOS: ~/Downloads
+      return path.join(homeDir, 'Downloads');
+    
+    case 'linux':
+      // Linux: Check common locations
+      const xdgDownload = process.env.XDG_DOWNLOAD_DIR;
+      if (xdgDownload) {
+        return xdgDownload;
+      }
+      // Fallback to ~/Downloads
+      return path.join(homeDir, 'Downloads');
+    
+    default:
+      // Fallback for other platforms
+      return path.join(homeDir, 'Downloads');
+  }
+}
+
+/**
+ * Ensures the downloads folder exists and is writable
+ * @returns {string} Valid downloads folder path
+ */
+function getValidDownloadsFolder() {
+  const fs = require('fs');
+  const downloadsFolder = getDownloadsFolder();
+  
+  try {
+    // Check if folder exists
+    if (!fs.existsSync(downloadsFolder)) {
+      // Try to create it
+      fs.mkdirSync(downloadsFolder, { recursive: true });
+    }
+    
+    // Check if folder is writable
+    const testFile = path.join(downloadsFolder, '.write_test_' + Date.now());
+    try {
+      fs.writeFileSync(testFile, 'test');
+      fs.unlinkSync(testFile);
+      return downloadsFolder;
+    } catch (error) {
+      // Fallback to current directory if downloads folder is not writable
+      console.warn(`⚠️  Downloads folder not writable: ${downloadsFolder}, using current directory`);
+      return process.cwd();
+    }
+  } catch (error) {
+    console.warn(`⚠️  Could not access downloads folder: ${error.message}, using current directory`);
+    return process.cwd();
+  }
+}
+
+module.exports = {
+  getDownloadsFolder,
+  getValidDownloadsFolder
+};