klio 1.2.2 → 1.2.3

package/README.md

@@ -174,6 +174,44 @@ Nächste 5 Konjunktionen zwischen saturn und neptun:
 ================================================================================
 ```
 
+### Aspektfiguren 
+```bash
+klio --af
+````
+Kombiniere mit `--i`, `--d`, `--hs` oder `--p`
+```bash
+klio --af --d "01.12.2025" --hs koch
+Verwende benutzerdefiniertes Datum: 1.12.2025 19:00
+Aktive Aspektfiguren:
+═══════════════════════════════════════════════════════════════════════════
+
+Großes Trigon:
+────────────────────────────────────────────────────────────────────────────────
+1. Planeten: Jupiter, Merkur, Saturn
+   Planetenpositionen:
+   - Jupiter: Krebs 24.48° (Haus 1)
+   - Merkur: Skorpion 21.07° (Haus 5)
+   - Saturn: Fische 25.17° (Haus 10)
+   Trigone: jupiter-merkur, jupiter-saturn, merkur-saturn
+
+Kite (Drachen):
+────────────────────────────────────────────────────────────────────────────────
+1. Planeten: Jupiter, Merkur, Saturn, Uranus
+   Planetenpositionen:
+   - Jupiter: Krebs 24.48° (Haus 1)
+   - Merkur: Skorpion 21.07° (Haus 5)
+   - Saturn: Fische 25.17° (Haus 10)
+   - Uranus: Stier 29.02° (Haus 11)
+   Trigon: jupiter-merkur, jupiter-saturn, merkur-saturn
+   Opposition: merkur-uranus
+
+═══════════════════════════════════════════════════════════════════════════
+Gesamt: 2 Aspektfigur(en) gefunden
+
+Diese Analyse basiert auf der aktuellen Planetenposition.
+
+```
+
 #### Elementverteilung
 ```bash
 klio --el 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klio",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Eine CLI für astrologische Berechnungen",
   "main": "src/main.js",
   "bin": {

package/src/astrology/astrologyService.js

@@ -637,6 +637,448 @@ function determineAspectPhase(planet1, planet2, dateComponents, aspectType, targ
   }
 }
 
+// Funktion zur Erkennung von Aspektfiguren
+function detectAspectFigures(dateComponents, houseSystem = null, useBirthData = false, houses = null) {
+  const allAspects = getAllActiveAspects(dateComponents);
+  const aspectFigures = [];
+  
+  // Hole die astrologischen Daten für alle Planeten, um Zeichen und Häuser zu erhalten
+  const planetDataCache = {};
+  const allPlanets = new Set(allAspects.flatMap(aspect => [aspect.planet1, aspect.planet2]));
+  
+  allPlanets.forEach(planetName => {
+    planetDataCache[planetName] = getAstrologicalData(planetName, dateComponents);
+  });
+  
+  // Häuser werden jetzt von der CLI übergeben, keine Berechnung mehr nötig
+  // Falls houses null ist, werden keine Hausinformationen angezeigt
+  
+  // Erstelle eine einfache Darstellung der Aspekte für die Mustererkennung
+  const aspectMap = {};
+  allAspects.forEach(aspect => {
+    const key1 = `${aspect.planet1}-${aspect.planet2}`;
+    const key2 = `${aspect.planet2}-${aspect.planet1}`;
+    
+    if (!aspectMap[key1] && !aspectMap[key2]) {
+      aspectMap[key1] = {
+        type: aspect.type,
+        angle: parseFloat(aspect.angle),
+        planets: [aspect.planet1, aspect.planet2]
+      };
+    }
+  });
+  
+  // 1. T-Quadrat Erkennung
+  // Ein T-Quadrat besteht aus:
+  // - Zwei Oppositionen (180°) 
+  // - Vier Quadrate (90°)
+  // - Drei Planeten, wobei zwei in Opposition stehen und der dritte mit beiden ein Quadrat bildet
+  
+  const planetsInAspects = new Set();
+  allAspects.forEach(aspect => {
+    planetsInAspects.add(aspect.planet1);
+    planetsInAspects.add(aspect.planet2);
+  });
+  
+  // Suche nach T-Quadrat Mustern
+  const tSquares = [];
+  
+  // Durchsuche alle Planetenkombinationen
+  const planetsArray = Array.from(planetsInAspects);
+  
+  for (let i = 0; i < planetsArray.length; i++) {
+    for (let j = i + 1; j < planetsArray.length; j++) {
+      for (let k = j + 1; k < planetsArray.length; k++) {
+        const planetA = planetsArray[i];
+        const planetB = planetsArray[j];
+        const planetC = planetsArray[k];
+        
+        // Prüfe, ob wir eine Opposition zwischen zwei Planeten haben
+        const opposition1 = allAspects.find(a => 
+          ((a.planet1 === planetA && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetA)) && 
+          a.type === 'Opposition'
+        );
+        
+        const opposition2 = allAspects.find(a => 
+          ((a.planet1 === planetA && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetA)) && 
+          a.type === 'Opposition'
+        );
+        
+        const opposition3 = allAspects.find(a => 
+          ((a.planet1 === planetB && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetB)) && 
+          a.type === 'Opposition'
+        );
+        
+        // Prüfe auf T-Quadrat Muster
+        if (opposition1) {
+          // Planet A und B in Opposition, prüfe ob Planet C mit beiden ein Quadrat bildet
+          const squareAC = allAspects.find(a => 
+            ((a.planet1 === planetA && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetA)) && 
+            a.type === 'Quadrat'
+          );
+          
+          const squareBC = allAspects.find(a => 
+            ((a.planet1 === planetB && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetB)) && 
+            a.type === 'Quadrat'
+          );
+          
+          if (squareAC && squareBC) {
+            tSquares.push({
+              type: 'T-Quadrat',
+              planets: [planetA, planetB, planetC],
+              opposition: `${planetA}-${planetB}`,
+              squares: [`${planetA}-${planetC}`, `${planetB}-${planetC}`],
+              focusPlanet: planetC
+            });
+          }
+        }
+        
+        if (opposition2) {
+          // Planet A und C in Opposition, prüfe ob Planet B mit beiden ein Quadrat bildet
+          const squareAB = allAspects.find(a => 
+            ((a.planet1 === planetA && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetA)) && 
+            a.type === 'Quadrat'
+          );
+          
+          const squareCB = allAspects.find(a => 
+            ((a.planet1 === planetC && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetC)) && 
+            a.type === 'Quadrat'
+          );
+          
+          if (squareAB && squareCB) {
+            tSquares.push({
+              type: 'T-Quadrat',
+              planets: [planetA, planetB, planetC],
+              opposition: `${planetA}-${planetC}`,
+              squares: [`${planetA}-${planetB}`, `${planetC}-${planetB}`],
+              focusPlanet: planetB
+            });
+          }
+        }
+        
+        if (opposition3) {
+          // Planet B und C in Opposition, prüfe ob Planet A mit beiden ein Quadrat bildet
+          const squareAB = allAspects.find(a => 
+            ((a.planet1 === planetA && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetA)) && 
+            a.type === 'Quadrat'
+          );
+          
+          const squareAC = allAspects.find(a => 
+            ((a.planet1 === planetA && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetA)) && 
+            a.type === 'Quadrat'
+          );
+          
+          if (squareAB && squareAC) {
+            tSquares.push({
+              type: 'T-Quadrat',
+              planets: [planetA, planetB, planetC],
+              opposition: `${planetB}-${planetC}`,
+              squares: [`${planetA}-${planetB}`, `${planetA}-${planetC}`],
+              focusPlanet: planetA
+            });
+          }
+        }
+      }
+    }
+  }
+  
+  // 2. Großes Trigon Erkennung
+  // Ein Großes Trigon besteht aus drei Trigon-Aspekten (120°), die ein gleichseitiges Dreieck bilden
+  const grandTrines = [];
+  
+  // Suche nach drei Planeten, die alle durch Trigone verbunden sind
+  for (let i = 0; i < planetsArray.length; i++) {
+    for (let j = i + 1; j < planetsArray.length; j++) {
+      for (let k = j + 1; k < planetsArray.length; k++) {
+        const planetA = planetsArray[i];
+        const planetB = planetsArray[j];
+        const planetC = planetsArray[k];
+        
+        const trineAB = allAspects.find(a => 
+          ((a.planet1 === planetA && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetA)) && 
+          a.type === 'Trigon'
+        );
+        
+        const trineAC = allAspects.find(a => 
+          ((a.planet1 === planetA && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetA)) && 
+          a.type === 'Trigon'
+        );
+        
+        const trineBC = allAspects.find(a => 
+          ((a.planet1 === planetB && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetB)) && 
+          a.type === 'Trigon'
+        );
+        
+        if (trineAB && trineAC && trineBC) {
+          grandTrines.push({
+            type: 'Großes Trigon',
+            planets: [planetA, planetB, planetC],
+            trines: [`${planetA}-${planetB}`, `${planetA}-${planetC}`, `${planetB}-${planetC}`]
+          });
+        }
+      }
+    }
+  }
+  
+  // 3. Großes Kreuz Erkennung
+  // Ein Großes Kreuz besteht aus zwei Oppositionen und vier Quadraten
+  const grandCrosses = [];
+  
+  // Suche nach vier Planeten, die zwei Oppositionen und vier Quadrate bilden
+  for (let i = 0; i < planetsArray.length; i++) {
+    for (let j = i + 1; j < planetsArray.length; j++) {
+      for (let k = j + 1; k < planetsArray.length; k++) {
+        for (let l = k + 1; l < planetsArray.length; l++) {
+          const planetA = planetsArray[i];
+          const planetB = planetsArray[j];
+          const planetC = planetsArray[k];
+          const planetD = planetsArray[l];
+          
+          // Prüfe auf zwei Oppositionen
+          const opposition1 = allAspects.find(a => 
+            ((a.planet1 === planetA && a.planet2 === planetB) || (a.planet1 === planetB && a.planet2 === planetA)) && 
+            a.type === 'Opposition'
+          );
+          
+          const opposition2 = allAspects.find(a => 
+            ((a.planet1 === planetC && a.planet2 === planetD) || (a.planet1 === planetD && a.planet2 === planetC)) && 
+            a.type === 'Opposition'
+          );
+          
+          if (opposition1 && opposition2) {
+            // Prüfe auf vier Quadrate zwischen den Planeten
+            const squareAC = allAspects.find(a => 
+              ((a.planet1 === planetA && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetA)) && 
+              a.type === 'Quadrat'
+            );
+            
+            const squareAD = allAspects.find(a => 
+              ((a.planet1 === planetA && a.planet2 === planetD) || (a.planet1 === planetD && a.planet2 === planetA)) && 
+              a.type === 'Quadrat'
+            );
+            
+            const squareBC = allAspects.find(a => 
+              ((a.planet1 === planetB && a.planet2 === planetC) || (a.planet1 === planetC && a.planet2 === planetB)) && 
+              a.type === 'Quadrat'
+            );
+            
+            const squareBD = allAspects.find(a => 
+              ((a.planet1 === planetB && a.planet2 === planetD) || (a.planet1 === planetD && a.planet2 === planetB)) && 
+              a.type === 'Quadrat'
+            );
+            
+            if (squareAC && squareAD && squareBC && squareBD) {
+              grandCrosses.push({
+                type: 'Großes Kreuz',
+                planets: [planetA, planetB, planetC, planetD],
+                oppositions: [`${planetA}-${planetB}`, `${planetC}-${planetD}`],
+                squares: [`${planetA}-${planetC}`, `${planetA}-${planetD}`, `${planetB}-${planetC}`, `${planetB}-${planetD}`]
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  // 4. Yod (Finger Gottes) Erkennung
+  // Ein Yod besteht aus zwei Quinkunx-Aspekten (150°), die auf einen dritten Planeten zeigen
+  const yods = [];
+  
+  // Suche nach Quinkunx-Aspekten (150°)
+  const quincunxes = allAspects.filter(a => a.type === 'Quinkunx');
+  
+  // Gruppiere Quinkunx-Aspekte nach dem Fokusplaneten
+  const quincunxByFocus = {};
+  quincunxes.forEach(q => {
+    if (!quincunxByFocus[q.planet2]) {
+      quincunxByFocus[q.planet2] = [];
+    }
+    quincunxByFocus[q.planet2].push(q.planet1);
+  });
+  
+  // Suche nach Planeten mit mindestens zwei Quinkunx-Aspekten
+  for (const [focusPlanet, sourcePlanets] of Object.entries(quincunxByFocus)) {
+    if (sourcePlanets.length >= 2) {
+      // Prüfe, ob die beiden Quelleplaneten durch ein Sextil (60°) verbunden sind
+      const source1 = sourcePlanets[0];
+      const source2 = sourcePlanets[1];
+      
+      const sextile = allAspects.find(a => 
+        ((a.planet1 === source1 && a.planet2 === source2) || (a.planet1 === source2 && a.planet2 === source1)) && 
+        a.type === 'Sextil'
+      );
+      
+      if (sextile) {
+        yods.push({
+          type: 'Yod (Finger Gottes)',
+          planets: [source1, source2, focusPlanet],
+          quincunxes: [`${source1}-${focusPlanet}`, `${source2}-${focusPlanet}`],
+          sextile: `${source1}-${source2}`,
+          focusPlanet: focusPlanet
+        });
+      }
+    }
+  }
+  
+  // 5. Kite (Drachen) Erkennung
+  // Ein Kite besteht aus einem Großen Trigon mit einem zusätzlichen Planeten, der mit einem der Trigon-Planeten in Opposition steht
+  const kites = [];
+  
+  // Durchsuche alle Großen Trigone
+  grandTrines.forEach(trine => {
+    const [planetA, planetB, planetC] = trine.planets;
+    
+    // Suche nach einem vierten Planeten, der mit einem der Trigon-Planeten in Opposition steht
+    const allPlanets = new Set(planetsInAspects);
+    
+    for (const planet of allPlanets) {
+      if (planet !== planetA && planet !== planetB && planet !== planetC) {
+        const oppositionA = allAspects.find(a => 
+          ((a.planet1 === planetA && a.planet2 === planet) || (a.planet1 === planet && a.planet2 === planetA)) && 
+          a.type === 'Opposition'
+        );
+        
+        const oppositionB = allAspects.find(a => 
+          ((a.planet1 === planetB && a.planet2 === planet) || (a.planet1 === planet && a.planet2 === planetB)) && 
+          a.type === 'Opposition'
+        );
+        
+        const oppositionC = allAspects.find(a => 
+          ((a.planet1 === planetC && a.planet2 === planet) || (a.planet1 === planet && a.planet2 === planetC)) && 
+          a.type === 'Opposition'
+        );
+        
+        if (oppositionA || oppositionB || oppositionC) {
+          kites.push({
+            type: 'Kite (Drachen)',
+            planets: [planetA, planetB, planetC, planet],
+            trine: trine.trines,
+            opposition: oppositionA ? `${planetA}-${planet}` : oppositionB ? `${planetB}-${planet}` : `${planetC}-${planet}`
+          });
+        }
+      }
+    }
+  });
+  
+  // Füge alle gefundenen Aspektfiguren zusammen
+  if (tSquares.length > 0) {
+    aspectFigures.push(...tSquares);
+  }
+  if (grandTrines.length > 0) {
+    aspectFigures.push(...grandTrines);
+  }
+  if (grandCrosses.length > 0) {
+    aspectFigures.push(...grandCrosses);
+  }
+  if (yods.length > 0) {
+    aspectFigures.push(...yods);
+  }
+  if (kites.length > 0) {
+    aspectFigures.push(...kites);
+  }
+  
+  // Füge Zeichen und Häuserinformationen zu jeder Aspektfigur hinzu
+  aspectFigures.forEach(figure => {
+    figure.planetDetails = {};
+    figure.planets.forEach(planetName => {
+      const planetData = planetDataCache[planetName];
+      if (planetData) {
+        figure.planetDetails[planetName] = {
+          sign: planetData.sign,
+          degree: planetData.degreeInSign,
+          element: planetData.element,
+          dignity: planetData.dignity
+        };
+        
+        // Füge Hausinformation hinzu, falls Häuser berechnet wurden
+        if (houses && houses.house) {
+          const planetLongitude = parseFloat(planetData.degreeInSign) + (signs.indexOf(planetData.sign) * 30);
+          const house = getPlanetHouse(planetLongitude, houses.house);
+          figure.planetDetails[planetName].house = house;
+        }
+      }
+    });
+  });
+  
+  return aspectFigures;
+}
+
+// Funktion zur Anzeige von Aspektfiguren
+function showAspectFigures(dateComponents, useBirthData = false, houseSystem = null, houses = null) {
+  const aspectFigures = detectAspectFigures(dateComponents, houseSystem, useBirthData, houses);
+  
+  if (aspectFigures.length === 0) {
+    console.log('Keine Aspektfiguren gefunden.');
+    return;
+  }
+  
+  console.log('Aktive Aspektfiguren:');
+  console.log('═══════════════════════════════════════════════════════════════════════════');
+  
+  // Gruppiere nach Figur-Typ
+  const figuresByType = {};
+  aspectFigures.forEach(figure => {
+    if (!figuresByType[figure.type]) {
+      figuresByType[figure.type] = [];
+    }
+    figuresByType[figure.type].push(figure);
+  });
+  
+  // Zeige jede Figur an
+  for (const [type, figures] of Object.entries(figuresByType)) {
+    console.log(`\n${type}:`);
+    console.log('─'.repeat(80));
+    
+    figures.forEach((figure, index) => {
+      console.log(`${index + 1}. Planeten: ${figure.planets.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(', ')}`);
+      
+      // Zeige Zeichen und Häuserinformationen an
+      if (figure.planetDetails) {
+        console.log('   Planetenpositionen:');
+        figure.planets.forEach(planetName => {
+          const details = figure.planetDetails[planetName];
+          if (details) {
+            const planetDisplay = planetName.charAt(0).toUpperCase() + planetName.slice(1);
+            let positionInfo = `   - ${planetDisplay}: ${details.sign} ${details.degree}°`;
+            if (details.house) {
+              positionInfo += ` (Haus ${details.house})`;
+            }
+            console.log(positionInfo);
+          }
+        });
+      }
+      
+      if (figure.type === 'T-Quadrat') {
+        console.log(`   Opposition: ${figure.opposition}`);
+        console.log(`   Quadrate: ${figure.squares.join(', ')}`);
+        console.log(`   Fokusplanet: ${figure.focusPlanet.charAt(0).toUpperCase() + figure.focusPlanet.slice(1)}`);
+      } else if (figure.type === 'Großes Trigon') {
+        console.log(`   Trigone: ${figure.trines.join(', ')}`);
+      } else if (figure.type === 'Großes Kreuz') {
+        console.log(`   Oppositionen: ${figure.oppositions.join(', ')}`);
+        console.log(`   Quadrate: ${figure.squares.join(', ')}`);
+      } else if (figure.type === 'Yod (Finger Gottes)') {
+        console.log(`   Quinkunxe: ${figure.quincunxes.join(', ')}`);
+        console.log(`   Sextil: ${figure.sextile}`);
+        console.log(`   Fokusplanet: ${figure.focusPlanet.charAt(0).toUpperCase() + figure.focusPlanet.slice(1)}`);
+      } else if (figure.type === 'Kite (Drachen)') {
+        console.log(`   Trigon: ${figure.trine.join(', ')}`);
+        console.log(`   Opposition: ${figure.opposition}`);
+      }
+    });
+  }
+  
+  console.log('\n═══════════════════════════════════════════════════════════════════════════');
+  console.log(`Gesamt: ${aspectFigures.length} Aspektfigur(en) gefunden`);
+  
+  if (useBirthData) {
+    console.log('\nDiese Analyse basiert auf deinem Geburtshoroskop.');
+  } else {
+    console.log('\nDiese Analyse basiert auf der aktuellen Planetenposition.');
+  }
+}
+
 // Funktion zur Analyse der Elementverteilung
 function analyzeElementDistribution(dateComponents, useBirthData = false) {
   const elementCounts = {
@@ -825,7 +1267,9 @@ module.exports = {
   getPastAspects,
   getAspectAngle,
   getFutureAspects,
-  findExactAspectTime
+  findExactAspectTime,
+  detectAspectFigures,
+  showAspectFigures
 };
 
 // Funktion zur Berechnung vergangener Aspekte zwischen zwei Planeten

package/src/cli/cli.js

@@ -1,25 +1,7 @@
 const { Command } = require('commander');
-const { 
-  getAstrologicalData, 
-  calculateHouses, 
-  getPlanetHouse, 
-  getBirthDataFromConfig, 
-  getCriticalPlanets, 
-  showPlanetAspects, 
-  getCurrentTimeInTimezone, 
-  calculatePlanetAspects, 
-  showAllActiveAspects, 
-  getAllActiveAspects, 
-  calculateJulianDayUTC,
-  getTimezoneOffset,
-  analyzeElementDistribution,
-  getPastAspects,
-  getFutureAspects,
-  getAspectAngle,
-  findExactAspectTime
-} = require('../astrology/astrologyService');
 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, detectAspectFigures } = require('../astrology/astrologyService');
 const { performSetup, showConfigStatus, loadConfig, setAIModel, askAIModel } = require('../config/configService');
 const { parseAppleHealthXML } = require('../health/healthService');
 const { analyzeStepsByPlanetSign, analyzeStressByPlanetAspects, analyzePlanetAspectsForSleep } = require('../health/healthAnalysis');
@@ -117,6 +99,7 @@ program
   .option('--stress', 'Analysiert Stressmuster mit Mondaspekten basierend auf HRV')
   .option('--setup', 'Konfiguriert Standort und Geburtsdaten für personalisierte Berechnungen')
   .option('--ki <model>', 'Setzt ein bestimmtes KI-Modell (z.B. "google/gemma-3n-e4b")')
+  .option('--system <prompt>', 'Setzt einen benutzerdefinierten System-Prompt für alle KI-Anfragen')
   .option('--rx', 'Zeigt alle rückläufigen oder stationären Planeten an')
   .option('--kritisch', 'Zeigt alle Planeten auf kritischen Grad an')
   .option('--status', 'Zeigt die gespeicherten Konfigurationsdaten an')
@@ -125,6 +108,7 @@ program
   .option('--t <days>', 'Zeitraumbeschränkung (z.B. 7d, 30d, 90d, 14d)')
   .option('--p <prompt>', 'Stellt eine Frage an das KI-Modell (z.B. "Welche Berufe passen zu dieser Position?")')
   .option('--el', 'Zeigt die Elementverteilung der Planeten in einem horizontalen Chart an')
+  .option('--af', 'Zeigt aktive Aspektfiguren wie T-Quadrate, Große Trigone, etc. an')
   .option('--v <count>', 'Zeigt vergangene Aspekte zwischen zwei Planeten an (Format: --v <count> planet1 aspectType planet2)')
   .option('--z <count>', 'Zeigt zukünftige Aspekte zwischen zwei Planeten an (Format: --z <count> planet1 aspectType planet2)')
   .description('Zeigt astrologische Daten für einen Planeten an')
@@ -320,12 +304,131 @@ program
       return;
     }
 
+    // Aspektfiguren anzeigen, falls --af Option angegeben (ohne Planet erforderlich)
+    if (options.af) {
+      // Geburtsdaten verwenden, falls --ich Option angegeben
+      let customDate = null;
+      let useBirthData = false;
+      
+      if (shouldUseBirthData(options)) {
+        const birthData = getBirthDataFromConfig();
+        if (birthData) {
+          customDate = birthData;
+          useBirthData = true;
+          console.log(`Verwende Geburtsdaten: ${birthData.day}.${birthData.month}.${birthData.year} ${birthData.hour}:${birthData.minute.toString().padStart(2, '0')}`);
+          if (birthData.location) {
+            console.log(`Geburtsort: ${birthData.location.name}, ${birthData.location.country}`);
+          }
+        } else {
+          console.log('Keine Geburtsdaten in der Konfiguration gefunden. Verwende aktuelle Daten.');
+        }
+      }
+      // Benutzerdefiniertes Datum verwenden, falls angegeben (überschreibt --ich Option)
+      else if (options.d) {
+        // Versuche, das Datum als DD.MM.YYYY oder DD.MM.YYYY HH:MM zu parsen
+        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; // Standard: 12 Uhr
+          const minute = match[5] ? parseInt(match[5], 10) : 0; // Standard: 0 Minuten
+          
+          // Überprüfe, ob das Datum gültig ist
+          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(`Verwende benutzerdefiniertes Datum: ${day}.${month}.${year} ${hour}:${minute.toString().padStart(2, '0')}`);
+          } else {
+            console.error('Ungültiges Datum:', options.d);
+            console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM" (mit Anführungszeichen für Datum mit Uhrzeit)');
+            process.exit(1);
+          }
+        } else {
+          console.error('Ungültiges Datum:', options.d);
+          console.error('💡 Bitte verwende das Format: DD.MM.YYYY oder "DD.MM.YYYY HH:MM" (mit Anführungszeichen für Datum mit Uhrzeit)');
+          process.exit(1);
+        }
+      }
+      
+      // Wenn kein benutzerdefiniertes Datum angegeben ist, verwende aktuelles Datum
+      if (!customDate) {
+        const currentTime = getCurrentTimeInTimezone();
+        customDate = {
+          day: currentTime.day,
+          month: currentTime.month,
+          year: currentTime.year,
+          hour: currentTime.hour,
+          minute: currentTime.minute
+        };
+      }
+      
+      // Analysiere und zeige die Aspektfiguren
+      const houseSystem = options.hs ? options.hs.toLowerCase() : null;
+      
+      // Berechne Häuser für die Anzeige, falls Haus-System angegeben
+      let housesForDisplay = null;
+      if (houseSystem) {
+        try {
+          const julianDay = getJulianDay(customDate, useBirthData);
+          const useBirthLocation = useBirthData;
+          
+          if (houseSystem === 'koch') {
+            housesForDisplay = await calculateHouses(julianDay, 'K', useBirthLocation);
+          } else if (houseSystem === 'wholesign') {
+            housesForDisplay = await calculateHouses(julianDay, 'W', useBirthLocation);
+          } else if (houseSystem === 'gauquelin') {
+            housesForDisplay = await calculateHouses(julianDay, 'G', useBirthLocation);
+          }
+        } catch (error) {
+          console.error('Fehler bei der Hausberechnung für Aspektfiguren:', error);
+        }
+      }
+      
+      showAspectFigures(customDate, useBirthData, houseSystem, housesForDisplay);
+      
+      // Frage an das KI-Modell senden, falls --p Option angegeben
+      if (options.p) {
+        // Erstelle ein Datenobjekt für die KI mit den Aspektfiguren
+        const aspectFiguresData = detectAspectFigures(customDate, houseSystem, useBirthData, housesForDisplay);
+        
+        const aiData = {
+          planet: 'alle',
+          sign: 'Multiple',
+          degreeInSign: 'Multiple',
+          dignity: `Aspektfiguren: ${aspectFiguresData.map(fig => `${fig.type} mit ${fig.planets.join(', ')}`).join(' | ')}`,
+          element: 'Multiple',
+          decan: 'Multiple',
+          aspectFigures: aspectFiguresData
+        };
+        
+        await askAIModel(options.p, aiData);
+      }
+      
+      return;
+    }
+
     // Konfigurationsstatus anzeigen, falls --status Option angegeben (ohne Planet erforderlich)
     if (options.status) {
       showConfigStatus();
       return;
     }
 
+    // System-Prompt setzen, falls --system Option angegeben (ohne Planet erforderlich)
+    if (options.system) {
+      const { setSystemPrompt } = require('../config/configService');
+      setSystemPrompt(options.system);
+      return;
+    }
+
     // KI-Modell setzen, falls --ki Option angegeben (ohne Planet erforderlich)
     if (options.ki) {
       setAIModel(options.ki);

package/src/config/configService.js

@@ -88,6 +88,35 @@ function setAIModel(modelName) {
   return false;
 }
 
+// Funktion zum Setzen eines benutzerdefinierten System-Prompts
+function setSystemPrompt(prompt) {
+  const config = loadConfig() || {
+    currentLocation: null,
+    birthData: null,
+    setupDate: new Date().toISOString()
+  };
+
+  // Erstelle aiConfiguration, falls nicht vorhanden
+  if (!config.aiConfiguration) {
+    config.aiConfiguration = {
+      provider: 'lm-studio',
+      model: null,
+      endpoint: 'http://localhost:1234/api/v1/chat',
+      apiKey: null
+    };
+  }
+
+  // Setze den benutzerdefinierten System-Prompt
+  config.aiConfiguration.systemPrompt = prompt;
+
+  if (saveConfig(config)) {
+    console.log(`System-Prompt erfolgreich gesetzt: "${prompt}"`);
+    console.log('Dieser Prompt wird für alle zukünftigen KI-Anfragen verwendet.');
+    return true;
+  }
+  return false;
+}
+
 // Funktion zum Anzeigen der gespeicherten Konfiguration
 function showConfigStatus() {
   const config = loadConfig();
@@ -132,6 +161,11 @@ function showConfigStatus() {
     } else {
       console.log(`API-Schlüssel: Nicht konfiguriert`);
     }
+    if (config.aiConfiguration.systemPrompt) {
+      console.log(`System-Prompt: "${config.aiConfiguration.systemPrompt}"`);
+    } else {
+      console.log(`System-Prompt: Standard (astrologischer Berater)`);
+    }
   } else {
     console.log('Kein lokales KI-Modell konfiguriert');
   }
@@ -313,7 +347,34 @@ async function askAIModel(prompt, planetData, houseInfo = null) {
   }
 
   // Bereite die Frage mit den astrologischen Daten vor
-  let systemPrompt = `Du bist ein astrologischer Berater. Beantworte kurz basierend auf den folgenden astrologischen Daten:
+  let systemPrompt;
+  let userPrompt;
+  
+  // Verwende benutzerdefinierten System-Prompt, falls vorhanden
+  if (aiConfig.systemPrompt) {
+    systemPrompt = aiConfig.systemPrompt;
+    // Füge die astrologischen Daten als Kontext zur Nutzerfrage hinzu
+    userPrompt = `Astrologische Daten:
+Planet: ${planetData.planet}
+Zeichen: ${planetData.sign}
+Grad im Zeichen: ${planetData.degreeInSign}°
+Würde: ${planetData.dignity}
+Element: ${planetData.element}
+Dekan: ${planetData.decan}`;
+    
+    // Füge Hausinformationen hinzu, falls verfügbar
+    if (houseInfo) {
+      userPrompt += `
+Haus: ${houseInfo.house}
+Haus-System: ${houseInfo.houseSystem}`;
+    }
+    
+    userPrompt += `
+
+Frage: ${prompt}`;
+  } else {
+    // Standard-System-Prompt
+    systemPrompt = `Du bist ein astrologischer Berater. Beantworte kurz die Frage in Fliesstext basierend auf den folgenden astrologischen Daten:
 
 Planet: ${planetData.planet}
 Zeichen: ${planetData.sign}
@@ -321,22 +382,24 @@ Grad im Zeichen: ${planetData.degreeInSign}°
 Würde: ${planetData.dignity}
 Element: ${planetData.element}
 Dekan: ${planetData.decan}`;
-  
-  // Füge Hausinformationen hinzu, falls verfügbar
-  if (houseInfo) {
-    systemPrompt += `
+    
+    // Füge Hausinformationen hinzu, falls verfügbar
+    if (houseInfo) {
+      systemPrompt += `
 Haus: ${houseInfo.house}
 Haus-System: ${houseInfo.houseSystem}`;
-  }
-  
-  systemPrompt += `
+    }
+    
+    systemPrompt += `
 
 Die Frage des Nutzers lautet: ${prompt}`;
+    userPrompt = prompt; // Verwende die ursprüngliche Frage
+  }
 
   try {
     const response = await axios.post(`${baseUrl}`, {
       model: model,
-      input: prompt,
+      input: userPrompt,
       system_prompt: systemPrompt,
       temperature: 0.7,
       max_output_tokens: 500
@@ -397,5 +460,6 @@ module.exports = {
   performSetup,
   showConfigStatus,
   setAIModel,
+  setSystemPrompt,
   askAIModel
 };