klio 1.5.2 → 1.5.4

package/README.md

@@ -1,4 +1,4 @@
-# Klio - Astrological CLI Tool
+# Klio
 
 A command-line tool for astrological calculations, health analysis, and personalized astrology insights.
 
@@ -144,8 +144,6 @@ Then, instead using `--i` for the commands from above you can use `--wp <id>` or
 - **Transits**: `klio --tr` - Shows personal transits based on birth data. Combine with `--wp <id or --i>` and optional  `--d <"DD.MM.YYYY HH:MM>`
 - **Transit Houses**: `klio --s --tra --i`
 
-
-
 ### Past and Future Aspects
 
 - **Past aspects**: `klio --v <count> [planet1] [aspect-type] [planet2]` - Shows past aspects (Format: --v <count> planet1 aspectType planet2) Available aspect types: c, o, s, t, se (conjunction, opposition, square, trine, sextile)
@@ -187,6 +185,75 @@ When were the files created on a system folder and in which house was the planet
 - **House filters**: `--h1` through `--h12` - Filters files with planet in specific houses
 
 
+## Note Taking
+
+Klio includes a note-taking system:
+
+### Basic Note Taking
+
+- **Add a note to any astrological situation**: `klio [planet] --note "your observation"`
+  - Example: `klio saturn --note "Boundaries, Limitations..."`
+  - Example: `klio moon --note "Full moon in Scorpio"`
+
+- **List all notes**: `klio --notes` - Shows all saved notes with timestamps and astrological context
+
+- **Search notes**: `klio --search-notes "keyword"` - Searches notes by astrological situation
+  - Example: `klio --search-notes "house"` - Finds all house-related notes
+  - Example: `klio --search-notes "saturn"` - Finds all Saturn-related notes
+
+### House Notation
+
+- **House-specific notes**: `klio h[n] --note "house observation"`
+  - Example: `klio h[4] --note "4th house observation - family matters"`
+  - Example: `klio h[10] --note "10th house - career focus"`
+
+- **Planet in house notes**: `klio h[n] [planet] --note "planet in house observation"`
+  - Example: `klio h[4] moon --note "Moon in 4th house - emotional security"`
+  - Example: `klio h[7] venus --note "Venus in 7th house - relationship harmony"`
+
+### Aspect Notation
+
+- **Aspect-specific notes**: `klio [planet1] [planet2] --note "aspect observation" --aspect [type]`
+  - Example: `klio saturn moon --note "Saturn conjunction Moon - emotional challenges" --aspect c`
+  - Example: `klio venus mars --note "Venus square Mars - relationship tension" --aspect s`
+  - Example: `klio jupiter uranus --note "Jupiter trine Uranus - sudden opportunities" --aspect t`
+
+### Aspect Type Shorthands
+
+- `c` - Conjunction
+- `s` - Square  
+- `t` - Trine
+- `se` - Sextile
+- `o` - Opposition
+
+### Advanced Features
+
+- **House system integration**: Notes include house information when using `--hs` option
+- **Date-specific notes**: Use `--d` option to add notes for specific dates
+- **JSON storage**: All notes are stored with full astrological context in `~/.config/astrocli/notes.json`
+
+### Examples
+
+```bash
+# Basic planet note
+klio mars --note "Mars in Aries - high energy period"
+
+# House note
+klio h[7] --note "7th house focus - relationships this month"
+
+# Planet in house note  
+klio h[10] saturn --note "Saturn in 10th house - career challenges"
+
+# Aspect note with shorthand
+klio sun moon --note "Sun trine Moon - emotional harmony" --aspect t
+
+# List all notes
+klio --notes
+
+# Search for specific notes
+klio --search-notes "saturn"
+```
+
 ## License
 
 ISC

package/package.json

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

package/src/astrology/astrologyService.js

@@ -194,8 +194,13 @@ function getHouseSystemCode(houseSystemName) {
 }
 
 // Function to calculate houses
-function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false) {
+function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false, locationOverride = null) {
   return new Promise((resolve, reject) => {
+    if (!Number.isFinite(julianDay)) {
+      reject('Invalid Julian Day');
+      return;
+    }
+
     // Load the configured location data
     const configPath = path.join(__dirname, '../../astrocli-config.json');
     let config;
@@ -210,7 +215,13 @@ function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false)
     
     let latitude, longitude, locationName;
     
-    if (useBirthLocation && config && config.birthData && config.birthData.location) {
+    if (locationOverride && locationOverride.latitude != null && locationOverride.longitude != null) {
+      latitude = locationOverride.latitude;
+      longitude = locationOverride.longitude;
+      locationName = locationOverride.name
+        ? `${locationOverride.name}${locationOverride.country ? `, ${locationOverride.country}` : ''}`
+        : 'Custom location';
+    } else if (useBirthLocation && config && config.birthData && config.birthData.location) {
       // Use birth location for birth charts
       latitude = config.birthData.location.latitude;
       longitude = config.birthData.location.longitude;
@@ -222,6 +233,14 @@ function calculateHouses(julianDay, houseSystem = 'K', useBirthLocation = false)
       locationName = config && config.currentLocation ? `${config.currentLocation.name}, ${config.currentLocation.country}` : 'Berlin, Germany';
     }
 
+    latitude = parseFloat(latitude);
+    longitude = parseFloat(longitude);
+    if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+      latitude = defaultLatitude;
+      longitude = defaultLongitude;
+      locationName = 'Berlin, Germany';
+    }
+
     swisseph.swe_houses(julianDay, latitude, longitude, houseSystem, function(result) {
       if (result.error) {
         if (result.error.includes('not found')) {
@@ -1328,7 +1347,7 @@ async function calculatePersonalTransits(transitDate = null, birthData = null) {
 
   // Calculate houses based on birth data (ASC-based)
   const birthJulianDay = calculateJulianDayUTC(birthData, getTimezoneOffset(birthData, birthData.location?.timezone || 'Europe/Zurich'));
-  const houses = await calculateHouses(birthJulianDay, 'K', true); // Always Koch house system for transits
+  const houses = await calculateHouses(birthJulianDay, 'K', true, birthData.location || null); // Always Koch house system for transits
 
   // Calculate current planet positions (Transit)
   const transitPlanets = {};
@@ -1467,7 +1486,11 @@ function showPersonalTransitAspects(transitDate = null, birthData = null, target
     birthPlanetsData[name] = getAstrologicalData(name, birthData);
   }
 
-  aspectData.aspects.forEach(aspect => {
+  const sortedAspects = [...aspectData.aspects].sort((a, b) => {
+    return parseFloat(a.orb) - parseFloat(b.orb);
+  });
+
+  sortedAspects.forEach(aspect => {
     const transitPlanetData = transitPlanetsData[aspect.transitPlanet];
     const birthPlanetData = birthPlanetsData[aspect.birthPlanet];
     
@@ -1504,7 +1527,7 @@ async function showCombinedAnalysis(planetName, transitDate = null, birthData =
 
   // Calculate houses based on birth data
   const birthJulianDay = calculateJulianDayUTC(birthData, getTimezoneOffset(birthData, birthData.location?.timezone || 'Europe/Zurich'));
-  const houses = await calculateHouses(birthJulianDay, getHouseSystemCode(houseSystem), true);
+  const houses = await calculateHouses(birthJulianDay, getHouseSystemCode(houseSystem), true, birthData.location || null);
 
   // Calculate current planet positions (Transit)
   const transitPlanetData = getAstrologicalData(planetName, transitDate);
@@ -1836,16 +1859,28 @@ function parseFilterCriteria(filterString) {
   const filterConditions = filterString.split(',').map(cond => cond.trim());
   
   const criteria = [];
+  const operatorRegex = /^(.+?)\s*(>=|<=|!=|=|>|<)\s*(.+)$/;
   
   for (const condition of filterConditions) {
+    const operatorMatch = condition.match(operatorRegex);
+    if (operatorMatch) {
+      criteria.push({
+        column: operatorMatch[1].trim(),
+        operator: operatorMatch[2],
+        value: operatorMatch[3].trim()
+      });
+      continue;
+    }
+
     const parts = condition.split(':');
     if (parts.length !== 2) {
-      console.warn(`Invalid filter format. Expected "column:value" but got "${condition}"`);
+      console.warn(`Invalid filter format. Expected "column:value" or "column > value" but got "${condition}"`);
       return null;
     }
-    
+
     criteria.push({
       column: parts[0].trim(),
+      operator: '=',
       value: parts[1].trim()
     });
   }
@@ -1863,19 +1898,45 @@ function applyFilter(records, filterCriteria) {
   
   if (!parsedCriteria) return records;
   
+  const matchesCriterion = (recordValue, criterion) => {
+    if (recordValue === undefined || recordValue === null) return false;
+    const recordValueStr = recordValue.toString().trim();
+    const valueStr = criterion.value.toString().trim();
+    const recordNum = parseFloat(recordValueStr);
+    const valueNum = parseFloat(valueStr);
+    const bothNumeric = Number.isFinite(recordNum) && Number.isFinite(valueNum);
+
+    switch (criterion.operator || '=') {
+      case '=':
+        return recordValueStr === valueStr;
+      case '!=':
+        return recordValueStr !== valueStr;
+      case '>':
+        return bothNumeric ? recordNum > valueNum : false;
+      case '>=':
+        return bothNumeric ? recordNum >= valueNum : false;
+      case '<':
+        return bothNumeric ? recordNum < valueNum : false;
+      case '<=':
+        return bothNumeric ? recordNum <= valueNum : false;
+      default:
+        return false;
+    }
+  };
+
   // 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;
+        return matchesCriterion(recordValue, criterion);
       });
     });
   } else {
     // Single criteria (backward compatibility)
     return records.filter(record => {
       const recordValue = record[parsedCriteria.column];
-      return recordValue && recordValue.toString() === parsedCriteria.value;
+      return matchesCriterion(recordValue, parsedCriteria);
     });
   }
 }
@@ -1959,44 +2020,66 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
           // First pass: look for YYYY-MM-DD format (most specific)
           const yyyyMmDdColumns = Object.keys(data).filter(key => {
             const value = data[key];
-            return /^\d{4}-\d{2}-\d{2}$/.test(value);
+            const trimmed = value != null ? value.toString().trim() : '';
+            return /^\d{4}-\d{2}-\d{2}$/.test(trimmed);
+          });
+
+          // Second pass: look for DD/MM/YYYY format (optional time)
+          const ddMmYyyyColumns = 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);
           });
           
-          // Second pass: look for Unix timestamps (10 or 13 digits)
+          // Third 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);
+            const trimmed = value != null ? value.toString().trim() : '';
+            return /^\d{10,13}$/.test(trimmed);
           });
           
-          // Third pass: look for ISO-8601 dates (least specific, as it can match many formats)
+          // Fourth 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];
+            const trimmed = value != null ? value.toString().trim() : '';
             // Only consider it an ISO date if it's not already matched by more specific patterns
-            if (yyyyMmDdColumns.includes(key) || unixTimestampColumns.includes(key)) {
+            if (yyyyMmDdColumns.includes(key) || ddMmYyyyColumns.includes(key) || unixTimestampColumns.includes(key)) {
               return false;
             }
-            return moment(value, moment.ISO_8601, true).isValid();
+            return moment(trimmed, moment.ISO_8601, true).isValid();
           });
           
-          // Prioritize columns: YYYY-MM-DD first, then Unix timestamps, then ISO dates
-          datetimeColumns.push(...yyyyMmDdColumns, ...unixTimestampColumns, ...isoDateColumns);
+          // Prioritize columns: YYYY-MM-DD, DD/MM/YYYY, Unix timestamps, then ISO dates
+          datetimeColumns.push(...yyyyMmDdColumns, ...ddMmYyyyColumns, ...unixTimestampColumns, ...isoDateColumns);
 
           if (datetimeColumns.length > 0) {
             const datetimeValue = data[datetimeColumns[0]];
+            const datetimeValueTrimmed = datetimeValue != null ? datetimeValue.toString().trim() : '';
             let datetime;
 
             // Check if it's a Unix-Timestamp
-            if (/^\d{10,13}$/.test(datetimeValue)) {
+            if (/^\d{10,13}$/.test(datetimeValueTrimmed)) {
               // Convert Unix-Timestamp to milliseconds (if 10 digits, multiply by 1000)
-              const timestamp = datetimeValue.length === 10 ? parseInt(datetimeValue) * 1000 : parseInt(datetimeValue);
+              const timestamp = datetimeValueTrimmed.length === 10 ? parseInt(datetimeValueTrimmed) * 1000 : parseInt(datetimeValueTrimmed);
               datetime = moment(timestamp);
-            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValue)) {
+            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValueTrimmed)) {
               // 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');
+              datetime = moment(datetimeValueTrimmed + 'T12:00:00');
+            } 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);
+              datetime = moment(datetimeValueTrimmed, ['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(datetimeValue);
+              datetime = moment(datetimeValueTrimmed);
+            }
+
+            if (!datetime.isValid()) {
+              continue;
             }
 
             // Convert the date to the format needed for astrological calculations
@@ -2017,11 +2100,39 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
               continue;
             }
 
+            if (!Number.isFinite(astroData.longitude)) {
+              continue;
+            }
+
             // Increase the counter for pending operations
             pendingOperations++;
 
             // Calculate the houses
             const julianDay = calculateJulianDayUTC(dateComponents, -datetime.utcOffset());
+            if (!Number.isFinite(julianDay)) {
+              let aspects = [];
+              if (analyzeAspects) {
+                try {
+                  aspects = calculatePlanetAspects(planetName, dateComponents, true);
+
+                  if (partnerPlanet) {
+                    aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
+                  }
+                } catch (error) {}
+              }
+
+              results.push({
+                datetime: datetimeValue,
+                planet: planetName,
+                sign: astroData.sign,
+                degreeInSign: astroData.degreeInSign,
+                house: 'N/A',
+                ...(analyzeAspects ? { aspects } : {})
+              });
+              pendingOperations--;
+              continue;
+            }
+
             calculateHouses(julianDay, getHouseSystemCode(houseSystem), false)
                 .then(houses => {
                   const planetLongitude = parseFloat(astroData.degreeInSign) + (signs.indexOf(astroData.sign) * 30);
@@ -2134,63 +2245,54 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
           delimiter: delimiter
         });
         
+        const filteredRecords = filterCriteria ? applyFilter(records, filterCriteria) : records;
+
         // 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 {
-                // Single criteria
-                const recordValue = data[parsedCriteria.column];
-                shouldSkip = !recordValue || recordValue.toString() !== parsedCriteria.value;
-              }
-              
-              if (shouldSkip) {
-                continue; // Skip this record
-              }
-            }
-          }
+        for (const data of filteredRecords) {
 
-          // Look for a column with ISO-Datetime values, YYYY-MM-DD dates, or Unix-Timestamps
+          // Look for a column with ISO-Datetime values, YYYY-MM-DD dates, DD/MM/YYYY dates (optional time), or Unix-Timestamps
           const datetimeColumns = Object.keys(data).filter(key => {
             const value = data[key];
+            const trimmed = value != null ? value.toString().trim() : '';
             // Check for ISO-8601 date
-            const isISO = moment(value, moment.ISO_8601, true).isValid();
+            const isISO = moment(trimmed, moment.ISO_8601, true).isValid();
             // Check for YYYY-MM-DD date format
-            const isYYYYMMDD = /^\d{4}-\d{2}-\d{2}$/.test(value);
+            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 Unix-Timestamp (number with 10 or 13 digits)
-            const isUnixTimestamp = /^\d{10,13}$/.test(value);
-            return isISO || isYYYYMMDD || isUnixTimestamp;
+            const isUnixTimestamp = /^\d{10,13}$/.test(trimmed);
+            return isISO || isYYYYMMDD || isDDMMYYYY || isUnixTimestamp;
           });
 
           if (datetimeColumns.length > 0) {
             const datetimeValue = data[datetimeColumns[0]];
+            const datetimeValueTrimmed = datetimeValue != null ? datetimeValue.toString().trim() : '';
             let datetime;
 
             // Check if it's a Unix-Timestamp
-            if (/^\d{10,13}$/.test(datetimeValue)) {
+            if (/^\d{10,13}$/.test(datetimeValueTrimmed)) {
               // Convert Unix-Timestamp to milliseconds (if 10 digits, multiply by 1000)
-              const timestamp = datetimeValue.length === 10 ? parseInt(datetimeValue) * 1000 : parseInt(datetimeValue);
+              const timestamp = datetimeValueTrimmed.length === 10 ? parseInt(datetimeValueTrimmed) * 1000 : parseInt(datetimeValueTrimmed);
               datetime = moment(timestamp);
-            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValue)) {
+            } else if (/^\d{4}-\d{2}-\d{2}$/.test(datetimeValueTrimmed)) {
               // 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');
+              datetime = moment(datetimeValueTrimmed + 'T12:00:00');
+            } 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);
+              datetime = moment(datetimeValueTrimmed, ['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(datetimeValue);
+              datetime = moment(datetimeValueTrimmed);
+            }
+
+            if (!datetime.isValid()) {
+              continue;
             }
 
             // Convert the date to the format needed for astrological calculations
@@ -2211,11 +2313,39 @@ function analyzeCSVWithDatetime(filePath, planetName = 'moon', houseSystem = 'ko
               continue;
             }
 
+            if (!Number.isFinite(astroData.longitude)) {
+              continue;
+            }
+
             // Increase the counter for pending operations
             pendingOperations++;
 
             // Calculate the houses
             const julianDay = calculateJulianDayUTC(dateComponents, -datetime.utcOffset());
+            if (!Number.isFinite(julianDay)) {
+              let aspects = [];
+              if (analyzeAspects) {
+                try {
+                  aspects = calculatePlanetAspects(planetName, dateComponents, true);
+
+                  if (partnerPlanet) {
+                    aspects = aspects.filter(a => a.planet.toLowerCase() === partnerPlanet.toLowerCase());
+                  }
+                } catch (error) {}
+              }
+
+              results.push({
+                datetime: datetimeValue,
+                planet: planetName,
+                sign: astroData.sign,
+                degreeInSign: astroData.degreeInSign,
+                house: 'N/A',
+                ...(analyzeAspects ? { aspects } : {})
+              });
+              pendingOperations--;
+              continue;
+            }
+
             calculateHouses(julianDay, getHouseSystemCode(houseSystem), false)
                 .then(houses => {
                   const planetLongitude = parseFloat(astroData.degreeInSign) + (signs.indexOf(astroData.sign) * 30);

package/src/cli/cli.js

@@ -2,7 +2,7 @@ const { Command } = require('commander');
 const { planets, signs } = require('../astrology/astrologyConstants');
 const { showRetrogradePlanets } = require('../astrology/retrogradeService');
 const { getCurrentTimeInTimezone, showAspectFigures, analyzeElementDistribution, getTimezoneOffset, calculateJulianDayUTC, calculateHouses, getAstrologicalData, getPlanetHouse, showPlanetAspects, calculatePlanetAspects, getAllActiveAspects, showAllActiveAspects, getBirthDataFromConfig, getPersonDataFromConfig, detectAspectFigures, calculatePersonalTransits, showPersonalTransitAspects, showCombinedAnalysis, calculatePersonalTransitAspects, determineAspectPhase, getAspectAngle, getFutureAspects, getPastAspects, analyzeCSVWithDatetime, analyzeHouseDistributionSignificance, analyzeAspectDistributionSignificance, analyzeSignDistributionSignificance, calculateAspectStatistics, calculatePlanetComboAspects, showPlanetComboAspects, getCriticalPlanets, getHouseSystemCode, calculateNextPlanetIngress, calculateAstrologicalAngles, longitudeToSignDegree, calculateTransitFrequency } = require('../astrology/astrologyService');
-const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel, setPerson1, setPerson2, setPerson, getPersonData, listPeople, deletePerson } = require('../config/configService');
+const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel, setPerson1, setPerson2, setPerson, getPersonData, listPeople, deletePerson, saveNote, showNotes, searchNotesBySituation } = require('../config/configService');
 const { parseAppleHealthXML } = require('../health/healthService');
 const { analyzeStepsByPlanetSign, analyzeStressByPlanetAspects, analyzePlanetAspectsForSleep, analyzeLateNightAspects, analyzeAllNighterAspects } = require('../health/healthAnalysis');
 const { getFileCreationDate, parseDateToComponents } = require('../utils/fileUtils');
@@ -159,6 +159,136 @@ const shouldUseBirthData = (options) => {
   return options.i;
 };
 
+// Helper function to parse aspect type shorthands
+const parseAspectType = (aspectCode) => {
+  const aspectMap = {
+    'c': 'Conjunction',
+    'con': 'Conjunction',
+    'conjunction': 'Conjunction',
+    'o': 'Opposition',
+    'opp': 'Opposition',
+    'opposition': 'Opposition',
+    's': 'Square',
+    'sq': 'Square',
+    'square': 'Square',
+    't': 'Trine',
+    'tri': 'Trine',
+    'trine': 'Trine',
+    'se': 'Sextile',
+    'sex': 'Sextile',
+    'sextile': 'Sextile'
+  };
+  
+  return aspectMap[aspectCode.toLowerCase()] || aspectCode;
+};
+
+// Helper function to parse house notation h[n]
+const parseHouseNotation = (arg) => {
+  const houseMatch = arg.match(/^h\[(\d+)\]$/);
+  if (houseMatch) {
+    const houseNumber = parseInt(houseMatch[1]);
+    if (houseNumber >= 1 && houseNumber <= 12) {
+      return { isHouse: true, houseNumber: houseNumber };
+    }
+  }
+  return { isHouse: false };
+};
+
+// Helper function to create a note for the current astrological situation
+const createAstrologicalNote = async (planetArg, planet2Arg, options, customDate = null, aspectType = null) => {
+  try {
+    // Get current date if not provided
+    const currentDate = customDate || getCurrentTimeInTimezone();
+    
+    // Parse planet arguments for special notations
+    const planet1Parse = parseHouseNotation(planetArg);
+    const planet2Parse = planet2Arg ? parseHouseNotation(planet2Arg) : { isHouse: false };
+    
+    // Create the note data structure
+    const noteData = {
+      content: options.note,
+      timestamp: new Date().toISOString()
+    };
+    
+    // Handle different astrological notations
+    if (planet1Parse.isHouse) {
+      // House notation: h[n]
+      noteData.house = planet1Parse.houseNumber;
+      noteData.astrologicalSituation = `House ${planet1Parse.houseNumber}`;
+      
+      if (planet2Arg && !planet2Parse.isHouse) {
+        // House with planet: h[n] planet
+        const planetData = getAstrologicalData(planet2Arg, currentDate);
+        noteData.planet = planet2Arg;
+        noteData.astrologicalSituation = `${planet2Arg} in House ${planet1Parse.houseNumber} (${planetData.sign} ${planetData.degreeInSign}°)`;
+      }
+    } else if (aspectType) {
+      // Explicit aspect notation: planet1 aspectType planet2 (e.g., saturn c moon)
+      const planet1Data = getAstrologicalData(planetArg, currentDate);
+      let planet2Data = null;
+      
+      if (planet2Arg) {
+        planet2Data = getAstrologicalData(planet2Arg, currentDate);
+      }
+      
+      noteData.planet1 = planetArg;
+      noteData.aspectType = aspectType;
+      noteData.astrologicalSituation = `${planetArg} ${aspectType}`;
+      
+      if (planet2Arg) {
+        noteData.planet2 = planet2Arg;
+        noteData.astrologicalSituation += ` ${planet2Arg} (${planet1Data.sign} ${planet1Data.degreeInSign}° ${aspectType} ${planet2Data.sign} ${planet2Data.degreeInSign}°)`;
+      } else {
+        noteData.astrologicalSituation += ` (${planet1Data.sign} ${planet1Data.degreeInSign}°)`;
+      }
+    } else if (planetArg && planet2Arg) {
+      // Two planets - check if there's an aspect between them
+      const planet1Data = getAstrologicalData(planetArg, currentDate);
+      const aspects = calculatePlanetAspects(planetArg, currentDate);
+      const aspectWithPlanet2 = aspects.find(a => a.planet === planet2Arg);
+      
+      if (aspectWithPlanet2) {
+        noteData.planet1 = planetArg;
+        noteData.planet2 = planet2Arg;
+        noteData.aspectType = aspectWithPlanet2.type;
+        noteData.astrologicalSituation = `${planetArg} ${aspectWithPlanet2.type} ${planet2Arg} (${planet1Data.sign} ${planet1Data.degreeInSign}°)`;
+      } else {
+        noteData.planet1 = planetArg;
+        noteData.planet2 = planet2Arg;
+        noteData.astrologicalSituation = `${planetArg} and ${planet2Arg} (no current aspect)`;
+      }
+    } else if (planetArg) {
+      // Single planet
+      const planetData = getAstrologicalData(planetArg, currentDate);
+      noteData.planet = planetArg;
+      noteData.astrologicalSituation = `${planetArg} in ${planetData.sign} (${planetData.degreeInSign}°)`;
+      
+      // Add house information if available
+      if (options.hs) {
+        const houseSystem = options.hs.toLowerCase();
+        const julianDay = getJulianDay(currentDate, shouldUseBirthData(options));
+        const houses = await calculateHouses(julianDay, getHouseSystemCode(houseSystem), shouldUseBirthData(options));
+        const planetLongitude = parseFloat(planetData.degreeInSign) + (signs.indexOf(planetData.sign) * 30);
+        const house = getPlanetHouse(planetLongitude, houses.house);
+        noteData.house = house;
+        noteData.astrologicalSituation += ` in house ${house}`;
+      }
+    } else {
+      // General situation
+      noteData.astrologicalSituation = 'General astrological situation';
+    }
+    
+    // Add date information
+    noteData.date = currentDate;
+    
+    // Save the note
+    saveNote(noteData);
+    
+  } catch (error) {
+    console.error('Error creating note:', error.message);
+  }
+};
+
 // Function to calculate the Julian Day in UTC
 // This function is defined before use to avoid initialization issues
 const getJulianDay = (customDate = null, useBirthData = false) => {
@@ -251,6 +381,10 @@ program
   .option('--delete-person <id>', 'Deletes a person')
   .option('--t <days>', 'Time limit (e.g. 7d, 30d, 90d, 14d)')
   .option('--p <prompt>', 'Asks a question to the AI model (e.g. "Which careers suit this position?")')
+  .option('--note <content>', 'Adds a note to the current astrological situation')
+  .option('--notes', 'Shows all saved notes')
+  .option('--search-notes <situation>', 'Searches notes by astrological situation')
+  .option('--aspect <type>', 'Specifies aspect type for note (c, s, t, se, o)')
   .option('--el', 'Shows the element distribution of planets in a horizontal chart')
   .option('--af', 'Shows active aspect figures like T-squares, Grand Trines, etc.')
   .option('--tra', 'Shows personal transits based on birth data')
@@ -987,6 +1121,32 @@ program
       return;
     }
 
+    // Show all notes if --notes option is specified (no planet required)
+    if (options.notes) {
+      showNotes();
+      return;
+    }
+
+    // Search notes if --search-notes option is specified (no planet required)
+    if (options.searchNotes) {
+      const results = searchNotesBySituation(options.searchNotes);
+      if (results.length === 0) {
+        console.log(`No notes found for situation: "${options.searchNotes}"`);
+      } else {
+        console.log(`Found ${results.length} notes for situation: "${options.searchNotes}"`);
+        console.log('================================================================================');
+        results.forEach((note, index) => {
+          console.log(`Note ${index + 1}:`);
+          console.log(`Date: ${new Date(note.timestamp).toLocaleString()}`);
+          if (note.content) {
+            console.log(`Content: ${note.content}`);
+          }
+          console.log('');
+        });
+      }
+      return;
+    }
+
     // Create/update person 1 if --person1 option is specified (no planet required)
     if (options.person1) {
       await setPerson1(options.person1);
@@ -1269,6 +1429,56 @@ program
       process.exit(1);
     }
 
+    // Handle note creation if --note option is specified
+    if (options.note) {
+      // Determine the custom date if specified
+      let customDate = null;
+      if (options.d) {
+        // Try to parse the date as DD.MM.YYYY or DD.MM.YYYY HH:MM
+        const dateRegex = /^(\d{1,2})\.(\d{1,2})\.(\d{4})(?:\s+(\d{1,2}):(\d{2}))?$/;
+        const match = options.d.match(dateRegex);
+        
+        if (match) {
+          const day = parseInt(match[1], 10);
+          const month = parseInt(match[2], 10);
+          const year = parseInt(match[3], 10);
+          const hour = match[4] ? parseInt(match[4], 10) : 12; // Default: 12 o'clock
+          const minute = match[5] ? parseInt(match[5], 10) : 0; // Default: 0 minutes
+           
+          // Check if the date is valid
+          const date = new Date(year, month - 1, day, hour, minute);
+          if (date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day) {
+            customDate = {
+              day: day,
+              month: month,
+              year: year,
+              hour: hour,
+              minute: minute
+            };
+          }
+        }
+      }
+      
+      // Check if we have an explicit aspect option
+      let planet1 = planetArg;
+      let aspectType = null;
+      let planet2 = planet2Arg;
+      
+      // Handle explicit aspect notation via --aspect option
+      if (options.aspect) {
+        aspectType = parseAspectType(options.aspect);
+      }
+      
+      // Create the note with the parsed arguments
+      await createAstrologicalNote(planet1, planet2, options, customDate, aspectType);
+      
+      // If only --note is specified, don't continue with other processing
+      if (!options.a && !options.s && !options.hs && !options.k && !options.c && !options.rx && !options.el && !options.af && !options.tra && !options.tr && !options.in && !options.o && !options.p) {
+        console.log('✓ Note saved successfully!');
+        return;
+      }
+    }
+
     // Show table view of all planet positions if --s option is specified
     if (options.s) {
       // Use person data for house calculation if --p1, --p2 or --i option is specified

package/src/cli/cliService.js

@@ -889,7 +889,7 @@ class CLIService {
             const julianDayForHouses = getJulianDayUTCForHouses();
             const useBirthLocation = birthData !== null;
             
-            houses = await calculateHouses(julianDayForHouses, getHouseSystemCode(houseSystem), useBirthLocation);
+            houses = await calculateHouses(julianDayForHouses, getHouseSystemCode(houseSystem), useBirthLocation, birthData ? birthData.location : null);
           } catch (error) {
             console.error('Error calculating houses:', error);
           }

package/src/config/configService.js

@@ -264,6 +264,134 @@ function deletePerson(personId, userId = null) {
   return saveConfig(config, userId);
 }
 
+// Function to get the notes file path
+function getNotesPath(userId = null) {
+  if (process.env.KLIO_NOTES_PATH) {
+    return process.env.KLIO_NOTES_PATH;
+  }
+  let configDir;
+  
+  // Determine configuration directory based on operating system
+  if (process.platform === 'win32') {
+    // Windows: Use %APPDATA%\astrocli
+    configDir = path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'astrocli');
+  } else if (process.platform === 'darwin') {
+    // macOS: Use ~/Library/Application Support/astrocli
+    configDir = path.join(os.homedir(), 'Library', 'Application Support', 'astrocli');
+  } else {
+    // Linux and other Unix systems: Use ~/.config/astrocli
+    configDir = path.join(os.homedir(), '.config', 'astrocli');
+  }
+  
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  
+  // For user-specific notes, create user directory
+  if (userId) {
+    const userDir = path.join(configDir, 'users', userId);
+    if (!fs.existsSync(userDir)) {
+      fs.mkdirSync(userDir, { recursive: true });
+    }
+    return path.join(userDir, 'notes.json');
+  }
+  
+  return path.join(configDir, 'notes.json');
+}
+
+// Function to save a note
+function saveNote(noteData, userId = null) {
+  try {
+    const notesPath = getNotesPath(userId);
+    let notes = [];
+    
+    // Load existing notes if file exists
+    if (fs.existsSync(notesPath)) {
+      const notesData = fs.readFileSync(notesPath, 'utf8');
+      notes = JSON.parse(notesData);
+    }
+    
+    // Add timestamp if not provided
+    if (!noteData.timestamp) {
+      noteData.timestamp = new Date().toISOString();
+    }
+    
+    // Add the new note
+    notes.push(noteData);
+    
+    // Sort notes by timestamp (newest first)
+    notes.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    
+    // Save the notes
+    fs.writeFileSync(notesPath, JSON.stringify(notes, null, 2));
+    console.log('✓ Note successfully saved!');
+    console.log(`📁 Location: ${notesPath}`);
+    return true;
+  } catch (error) {
+    console.error('Error saving note:', error.message);
+    return false;
+  }
+}
+
+// Function to load all notes
+function loadNotes(userId = null) {
+  try {
+    const notesPath = getNotesPath(userId);
+    if (fs.existsSync(notesPath)) {
+      const notesData = fs.readFileSync(notesPath, 'utf8');
+      return JSON.parse(notesData);
+    }
+  } catch (error) {
+    console.error('Error loading notes:', error.message);
+  }
+  return [];
+}
+
+// Function to show all notes
+function showNotes(userId = null) {
+  const notes = loadNotes(userId);
+  
+  if (notes.length === 0) {
+    console.log('No notes found.');
+    return;
+  }
+  
+  console.log('Your astrological notes:');
+  console.log('========================');
+  
+  notes.forEach((note, index) => {
+    console.log(`Note ${index + 1}:`);
+    console.log(`Date: ${new Date(note.timestamp).toLocaleString()}`);
+    
+    if (note.astrologicalSituation) {
+      console.log(`Astrological Situation: ${note.astrologicalSituation}`);
+    }
+    
+    if (note.planet1 && note.aspectType && note.planet2) {
+      console.log(`Aspect: ${note.planet1} ${note.aspectType} ${note.planet2}`);
+    }
+    
+    if (note.moonHouse) {
+      console.log(`Moon House: ${note.moonHouse}`);
+    }
+    
+    if (note.content) {
+      console.log(`Content: ${note.content}`);
+    }
+    
+    console.log('');
+  });
+}
+
+// Function to search notes by astrological situation
+function searchNotesBySituation(situation, userId = null) {
+  const notes = loadNotes(userId);
+  return notes.filter(note => 
+    note.astrologicalSituation && note.astrologicalSituation.toLowerCase().includes(situation.toLowerCase())
+  );
+}
+
 // Function to create/set person 1 (for backward compatibility)
 async function setPerson1(personString, userId = null) {
   return await setPerson('p1', personString, userId);
@@ -769,6 +897,11 @@ module.exports = {
   getPersonData,
   listPeople,
   deletePerson,
+  // Note functions
+  saveNote,
+  loadNotes,
+  showNotes,
+  searchNotesBySituation,
   // Add helper functions for user-specific operations
   getConfigPath
 };