klio 1.1.7

package/src/health/healthAnalysis.js

@@ -0,0 +1,410 @@
+const { getAstrologicalData, calculatePlanetAspects } = require('../astrology/astrologyService');
+const { extractStepData, extractHRVData, extractSleepData, extractSleepGoal } = require('./healthService');
+
+// Funktion zur Analyse von Schritten nach Planeten-Zeichen
+async function analyzeStepsByPlanetSign(planetName, healthData, timeLimitDays = null) {
+  let stepRecords = extractStepData(healthData);
+  
+  if (stepRecords.length === 0) {
+    console.log('Keine Schrittzahldaten zum Analysieren gefunden.');
+    return;
+  }
+
+  // Filtere nach Zeitraumbeschränkung, falls angegeben
+  if (timeLimitDays) {
+    const timeLimitMatch = timeLimitDays.match(/^(\d+)d$/);
+    if (timeLimitMatch) {
+      const days = parseInt(timeLimitMatch[1]);
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - days);
+      
+      const originalCount = stepRecords.length;
+      stepRecords = stepRecords.filter(record => record.date >= cutoffDate);
+      
+      if (stepRecords.length === 0) {
+        const originalRecords = extractStepData(healthData); // Hole Originaldaten für ältesten Eintrag
+        const oldestDate = originalRecords.length > 0 ? new Date(Math.min(...originalRecords.map(r => r.date.getTime()))).toLocaleDateString() : 'Keine Daten';
+        console.log(`⚠️  Keine Schrittaufzeichnungen in den letzten ${days} Tagen gefunden.`);
+        console.log(`   Verfügbare Daten: ${originalCount} Aufzeichnungen (älteste: ${oldestDate})`);
+        console.log(`   Tipp: Versuchen Sie einen längeren Zeitraum (z.B. --t 30d oder --t 90d)`);
+        return;
+      }
+      
+      console.log(`Analysiere ${stepRecords.length} Schrittaufzeichnungen (letzte ${days} Tage)...`);
+    } else {
+      console.log(`⚠️  Ungültiges Zeitlimit-Format: ${timeLimitDays}. Verwende alle Daten.`);
+      console.log(`Analysiere ${stepRecords.length} Schrittaufzeichnungen...`);
+    }
+  } else {
+    console.log(`Analysiere ${stepRecords.length} Schrittaufzeichnungen...`);
+  }
+
+  // Datenqualitätsprüfung
+  const totalSteps = stepRecords.reduce((sum, r) => sum + r.steps, 0);
+  const avgSteps = totalSteps / stepRecords.length;
+  const lowStepRecords = stepRecords.filter(r => r.steps < 1000).length;
+  const lowStepPercentage = (lowStepRecords / stepRecords.length * 100).toFixed(1);
+
+  console.log(`Durchschnittliche Schritte pro Tag: ${avgSteps.toFixed(0)}`);
+  console.log(`Tage mit < 1000 Schritten: ${lowStepRecords} (${lowStepPercentage}%)`);
+
+  // Gruppiere Schritte nach Planeten-Zeichen
+  const stepsByPlanetSign = {};
+  const planetSignStats = {};
+  
+  for (const record of stepRecords) {
+    const dateComponents = {
+      year: record.date.getFullYear(),
+      month: record.date.getMonth() + 1,
+      day: record.date.getDate(),
+      hour: record.date.getHours(),
+      minute: record.date.getMinutes()
+    };
+
+    // Berechne Planetenposition für dieses Datum
+    const planetData = getAstrologicalData(planetName, dateComponents);
+    const planetSign = planetData.sign;
+
+    // Gruppiere nach Planeten-Zeichen
+    if (!stepsByPlanetSign[planetSign]) {
+      stepsByPlanetSign[planetSign] = [];
+    }
+    stepsByPlanetSign[planetSign].push(record.steps);
+    
+    // Statistik pro Planeten-Zeichen
+    if (!planetSignStats[planetSign]) {
+      planetSignStats[planetSign] = {
+        count: 0,
+        totalSteps: 0,
+        minSteps: Infinity,
+        maxSteps: 0,
+        lowStepDays: 0  // Tage mit < 1000 Schritten
+      };
+    }
+    
+    planetSignStats[planetSign].count++;
+    planetSignStats[planetSign].totalSteps += record.steps;
+    planetSignStats[planetSign].minSteps = Math.min(planetSignStats[planetSign].minSteps, record.steps);
+    planetSignStats[planetSign].maxSteps = Math.max(planetSignStats[planetSign].maxSteps, record.steps);
+    
+    if (record.steps < 1000) {
+      planetSignStats[planetSign].lowStepDays++;
+    }
+  }
+
+  // Berechne Durchschnittswerte
+  console.log(`\nSchrittstatistik nach ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}zeichen:`);
+  console.log('Zeichen | Durchschnitt | Gesamt | Tage | Rang | Aktuell');
+  console.log('-------|-------------|--------|-----|-----|--------');
+
+  const sortedSigns = Object.entries(planetSignStats)
+    .sort((a, b) => b[1].totalSteps / b[1].count - a[1].totalSteps / a[1].count); // Absteigend sortieren
+
+  // Berechne aktuelles Planeten-Zeichen für die Spalte
+  const currentPlanetData = getAstrologicalData(planetName);
+  
+  for (let i = 0; i < sortedSigns.length; i++) {
+    const [sign, stats] = sortedSigns[i];
+    const avgSteps = (stats.totalSteps / stats.count).toFixed(0);
+    const totalSteps = stats.totalSteps.toFixed(0);
+    const rank = i + 1; // Rang (1 = meisten Schritte)
+    const isCurrent = sign === currentPlanetData.sign ? '✓' : '';
+    
+    console.log(`${sign.padEnd(10)} | ${avgSteps.padStart(11)} | ${totalSteps.padStart(6)} | ${stats.count.toString().padStart(3)} | ${rank.toString().padStart(3)} | ${isCurrent}`);
+  }
+
+  // Zeige Analyseergebnis
+  console.log(`\n${planetName.charAt(0).toUpperCase() + planetName.slice(1)}zeichen mit den meisten Schritten: ${sortedSigns[0][0]} (∅ ${(sortedSigns[0][1].totalSteps / sortedSigns[0][1].count).toFixed(0)} Schritte, Rang 1)`);
+  console.log(`${planetName.charAt(0).toUpperCase() + planetName.slice(1)}zeichen mit den wenigsten Schritten: ${sortedSigns[sortedSigns.length - 1][0]} (∅ ${(sortedSigns[sortedSigns.length - 1][1].totalSteps / sortedSigns[sortedSigns.length - 1][1].count).toFixed(0)} Schritte, Rang ${sortedSigns.length})`)
+}
+
+// Funktion zur Analyse von Stress basierend auf HRV und Planeten-Zeichen
+async function analyzeStressByPlanetAspects(planetName, healthData, timeLimitDays = null) {
+  let hrvRecords = extractHRVData(healthData);
+  
+  if (hrvRecords.length === 0) {
+    console.log('Keine HRV-Daten zum Analysieren gefunden.');
+    console.log('Hinweis: HRV (Heart Rate Variability) Daten sind für Stressanalyse erforderlich.');
+    return;
+  }
+
+  // Filtere nach Zeitraumbeschränkung, falls angegeben
+  if (timeLimitDays) {
+    const timeLimitMatch = timeLimitDays.match(/^(\d+)d$/);
+    if (timeLimitMatch) {
+      const days = parseInt(timeLimitMatch[1]);
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - days);
+      
+      const originalCount = hrvRecords.length;
+      hrvRecords = hrvRecords.filter(record => record.date >= cutoffDate);
+      
+      if (hrvRecords.length === 0) {
+        const originalRecords = extractHRVData(healthData);
+        const oldestDate = originalRecords.length > 0 ? new Date(Math.min(...originalRecords.map(r => r.date.getTime()))).toLocaleDateString() : 'Keine Daten';
+        console.log(`⚠️  Keine HRV-Aufzeichnungen in den letzten ${days} Tagen gefunden.`);
+        console.log(`   Verfügbare Daten: ${originalCount} Aufzeichnungen (älteste: ${oldestDate})`);
+        console.log(`   Tipp: Versuchen Sie einen längeren Zeitraum (z.B. --t 30d oder --t 90d)`);
+        return;
+      }
+      
+      console.log(`Analysiere ${hrvRecords.length} HRV-Aufzeichnungen (letzte ${days} Tage)...`);
+    } else {
+      console.log(`⚠️  Ungültiges Zeitlimit-Format: ${timeLimitDays}. Verwende alle Daten.`);
+      console.log(`Analysiere ${hrvRecords.length} HRV-Aufzeichnungen...`);
+    }
+  } else {
+    console.log(`Analysiere ${hrvRecords.length} HRV-Aufzeichnungen...`);
+  }
+
+  // Berechne Stresslevel basierend auf HRV (niedrige HRV = hoher Stress)
+  // Wir berechnen einen individuellen Basiswert aus dem Durchschnitt der Daten
+  const avgHrvOverall = hrvRecords.reduce((sum, r) => sum + r.hrv, 0) / hrvRecords.length;
+  const maxHrvOverall = Math.max(...hrvRecords.map(r => r.hrv));
+  
+  // Stresslevel = 100% * (1 - (HRV - minHRV) / (maxHRV - minHRV))
+  // Aber das würde den "relativen" Charakter vielleicht zu sehr strecken.
+  // Wir bleiben bei der Relation zum Maximum, aber berechnen den Stress 
+  // relativ zum Bereich [minHRV, maxHRV]
+  const minHrvOverall = Math.min(...hrvRecords.map(r => r.hrv));
+  const hrvRange = maxHrvOverall - minHrvOverall;
+  
+  const stressRecords = hrvRecords.map(record => {
+    // Wenn alle Werte gleich sind, ist hrvRange 0
+    let stressLevel = 0;
+    if (hrvRange > 0) {
+      stressLevel = 100 * (1 - (record.hrv - minHrvOverall) / hrvRange);
+    }
+    return {
+      date: record.date,
+      hrv: record.hrv,
+      stressLevel: stressLevel,
+      count: record.count
+    };
+  });
+
+  // Gruppiere nach Planeten-Zeichen und berechne durchschnittlichen Stress
+  const stressByPlanetSign = {};
+  const planetSignStats = {};
+  
+  for (const record of stressRecords) {
+    const dateComponents = {
+      year: record.date.getFullYear(),
+      month: record.date.getMonth() + 1,
+      day: record.date.getDate(),
+      hour: record.date.getHours(),
+      minute: record.date.getMinutes()
+    };
+
+    // Berechne Planetenposition für dieses Datum
+    const planetData = getAstrologicalData(planetName, dateComponents);
+    const planetSign = planetData.sign;
+
+    // Gruppiere nach Planeten-Zeichen
+    if (!stressByPlanetSign[planetSign]) {
+      stressByPlanetSign[planetSign] = [];
+    }
+    stressByPlanetSign[planetSign].push(record.stressLevel);
+    
+    // Statistik pro Planeten-Zeichen
+    if (!planetSignStats[planetSign]) {
+      planetSignStats[planetSign] = {
+        count: 0,
+        totalStress: 0,
+        minStress: Infinity,
+        maxStress: 0,
+        avgHRV: 0,
+        hrvValues: []
+      };
+    }
+    
+    planetSignStats[planetSign].count++;
+    planetSignStats[planetSign].totalStress += record.stressLevel;
+    planetSignStats[planetSign].minStress = Math.min(planetSignStats[planetSign].minStress, record.stressLevel);
+    planetSignStats[planetSign].maxStress = Math.max(planetSignStats[planetSign].maxStress, record.stressLevel);
+    planetSignStats[planetSign].hrvValues.push(record.hrv);
+  }
+
+  // Berechne Durchschnittswerte
+  console.log(`\nStressstatistik nach ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}zeichen:`);
+  console.log('Zeichen | Ø Stress | Ø HRV | Tage | Rang | Aktuell');
+  console.log('-------|----------|-------|-----|-----|--------');
+
+  const sortedSigns = Object.entries(planetSignStats)
+    .sort((a, b) => (b[1].totalStress / b[1].count) - (a[1].totalStress / a[1].count)); // Absteigend nach Stress
+
+  // Berechne aktuelles Planeten-Zeichen für die Spalte
+  const currentPlanetData = getAstrologicalData(planetName);
+
+  for (let i = 0; i < sortedSigns.length; i++) {
+    const [sign, stats] = sortedSigns[i];
+    const avgStress = (stats.totalStress / stats.count).toFixed(1);
+    const avgHRV = (stats.hrvValues.reduce((sum, val) => sum + val, 0) / stats.hrvValues.length).toFixed(1);
+    const rank = i + 1; // Rang (1 = höchster Stress)
+    const isCurrent = sign === currentPlanetData.sign ? '✓' : '';
+    
+    console.log(`${sign.padEnd(10)} | ${avgStress.padStart(8)}% | ${avgHRV.padStart(5)}ms | ${stats.count.toString().padStart(3)} | ${rank.toString().padStart(3)} | ${isCurrent}`);
+  }
+
+  if (planetSignStats[currentPlanetData.sign]) {
+    const currentAvgStress = (planetSignStats[currentPlanetData.sign].totalStress / planetSignStats[currentPlanetData.sign].count).toFixed(1);
+    const currentAvgHRV = (planetSignStats[currentPlanetData.sign].hrvValues.reduce((sum, val) => sum + val, 0) / planetSignStats[currentPlanetData.sign].hrvValues.length).toFixed(1);
+    // Zeige Empfehlung basierend auf aktuellem Stresslevel
+    if (currentAvgStress > 70) {
+      console.log('\nAktuell könnte eine Phase mit erhöhtem Stress sein.');
+    } else if (currentAvgStress > 50) {
+      console.log('\nAktuell könnte eine Phase mit moderatem Stress sein.');
+    } else {
+      console.log('\nAktuell könnte eine Phase mit niedrigem Stress sein.');
+    }
+  } else {
+    console.log(`   Keine Stressdaten für das aktuelle ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}zeichen verfügbar.`);
+  }
+}
+
+// Funktion zur Analyse von Planetenaspekten bei Schlafmangel
+async function analyzePlanetAspectsForSleep(planetName, healthData, sleepGoal = 8) {
+  const sleepRecords = extractSleepData(healthData);
+  
+  if (sleepRecords.length === 0) {
+    console.log('Keine Schlafdaten zum Analysieren gefunden.');
+    return;
+  }
+
+  console.log(`Schlafziel: ${sleepGoal} Stunden`);
+
+  // Filtere ungültige Datensätze (0 Stunden Schlaf) heraus
+  const validSleepRecords = sleepRecords.filter(record => record.duration > 0.1); // Mindestens 6 Minuten
+
+  // Filtere Nächte mit Schlafmangel (weniger als Ziel)
+  const insufficientSleepNights = validSleepRecords.filter(record => 
+    record.duration < sleepGoal
+  );
+
+  console.log(`\nNächte mit Schlafmangel (${insufficientSleepNights.length} von ${validSleepRecords.length}):`);
+  
+  // Zeige detaillierte Schlafphasen-Statistik
+  console.log('\nSchlafphasen-Statistik (alle Nächte):');
+  const phaseStats = {
+    'AsleepCore': 0,
+    'AsleepDeep': 0,
+    'AsleepREM': 0,
+    'Awake': 0
+  };
+  
+  let totalSleepTime = 0;
+  let totalAwakeTime = 0;
+  
+  for (const record of validSleepRecords) {
+    if (record.phases) {
+      for (const phase of record.phases) {
+        const phaseType = phase.type.replace('HKCategoryValueSleepAnalysis', '');
+        phaseStats[phaseType] += phase.duration;
+        
+        if (phaseType === 'Awake') {
+          totalAwakeTime += phase.duration;
+        } else {
+          totalSleepTime += phase.duration;
+        }
+      }
+    }
+  }
+  
+  console.log('Durchschnittliche Schlafphasenverteilung:');
+  console.log('Tiefschlaf (Core):', phaseStats.AsleepCore.toFixed(2), 'Stunden');
+  console.log('Traumschlaf (REM):', phaseStats.AsleepREM.toFixed(2), 'Stunden');
+  console.log('Festschlaf (Deep):', phaseStats.AsleepDeep.toFixed(2), 'Stunden');
+  console.log('Wachphasen:', phaseStats.Awake.toFixed(2), 'Stunden');
+  console.log('Gesamte Schlafzeit:', totalSleepTime.toFixed(2), 'Stunden');
+  // Wenn keine Nächte mit Schlafmangel gefunden wurden
+  if (insufficientSleepNights.length === 0) {
+    if (validSleepRecords.length === 0) {
+      console.log('Keine gültigen Schlafdaten gefunden (alle Einträge hatten ≤ 0.1h Schlaf).');
+      return;
+    }
+    
+    console.log('Glückwunsch! Keine Nächte mit Schlafmangel gefunden.');
+    console.log('\nGesamt-Schlafstatistik:');
+    console.log('Durchschnittliche Schlafdauer:', (validSleepRecords.reduce((sum, record) => sum + record.duration, 0) / validSleepRecords.length).toFixed(2), 'Stunden');
+    console.log('Längste Schlafperiode:', Math.max(...validSleepRecords.map(r => r.duration)).toFixed(2), 'Stunden');
+    console.log('Kürzeste Schlafperiode:', Math.min(...validSleepRecords.map(r => r.duration)).toFixed(2), 'Stunden');
+    
+    // Analysiere trotzdem einige Planetenaspekte für allgemeine Muster
+    console.log(`\nAllgemeine ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}aspekt-Analyse (alle Nächte):`);
+    const generalAspectStats = {};
+    
+    for (const night of sleepRecords.slice(0, Math.min(10, sleepRecords.length))) {
+      const midSleepTime = new Date(night.startDate.getTime() + 
+                                    (night.endDate.getTime() - night.startDate.getTime()) / 2);
+      const planetAspects = calculatePlanetAspects(planetName, midSleepTime);
+
+      for (const aspect of planetAspects) {
+        const aspectKey = `${aspect.type} mit ${aspect.planet}`;
+        generalAspectStats[aspectKey] = (generalAspectStats[aspectKey] || 0) + 1;
+      }
+    }
+
+    if (Object.keys(generalAspectStats).length > 0) {
+      console.log(`Häufige ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}aspekte in den analysierten Nächten:`);
+      const sortedGeneralAspects = Object.entries(generalAspectStats)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+
+      for (const [aspect, count] of sortedGeneralAspects) {
+        console.log(`  - ${aspect}: ${count}x`);
+      }
+    }
+    
+    return;
+  }
+
+  // Analysiere Planetenaspekte für jede Nacht mit Schlafmangel
+  const aspectStats = {};
+  
+  for (const night of insufficientSleepNights) {
+    const midSleepTime = new Date(night.startDate.getTime() + 
+                                  (night.endDate.getTime() - night.startDate.getTime()) / 2);
+    const planetAspects = calculatePlanetAspects(planetName, midSleepTime);
+
+    // Zähle Aspekte
+    for (const aspect of planetAspects) {
+      const aspectKey = `${aspect.type} mit ${aspect.planet}`;
+      aspectStats[aspectKey] = (aspectStats[aspectKey] || 0) + 1;
+    }
+  }
+
+  // Zeige Statistik an (Top 10 Planetenaspekte)
+  console.log(`\nHäufigste ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}aspekte bei Schlafmangel (Top 10):`);
+  console.log('Aspekt | Häufigkeit | Prozent | Heute aktiv');
+  console.log('-------|-----------|--------|------------');
+
+  const totalNights = insufficientSleepNights.length;
+  const sortedAspects = Object.entries(aspectStats)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10); // Begrenzung auf Top 10
+
+  // Berechne aktuelle Planetenaspekte für den Vergleich
+  const currentPlanetAspects = calculatePlanetAspects(planetName, new Date());
+  const currentAspectSet = new Set(currentPlanetAspects.map(a => `${a.type} mit ${a.planet}`));
+
+  for (const [aspect, count] of sortedAspects) {
+    const percentage = totalNights > 0 ? ((count / totalNights) * 100).toFixed(1) : 0;
+    const isActiveToday = currentAspectSet.has(aspect) ? '✓' : '✗';
+    console.log(`${aspect.padEnd(25)} |    ${count.toString().padStart(2)}     |  ${percentage}%    |    ${isActiveToday}`);
+  }
+
+  if (sortedAspects.length === 0) {
+    console.log(`Keine ${planetName.charAt(0).toUpperCase() + planetName.slice(1)}aspekte in Nächten mit Schlafmangel gefunden.`);
+  }
+
+  // Zeige Hinweis über verfügbare Beispielnächte, aber zeige keine Details
+  if (insufficientSleepNights.length > 0) {
+    console.log(`\n${insufficientSleepNights.length} Nächte mit Schlafmangel gefunden.`);
+  }
+}
+
+module.exports = {
+  analyzeStepsByPlanetSign,
+  analyzeStressByPlanetAspects,
+  analyzePlanetAspectsForSleep
+};

package/src/health/healthService.js

@@ -0,0 +1,202 @@
+const fs = require('fs');
+const { XMLParser } = require('fast-xml-parser');
+
+// Funktion zum Parsen von Apple Health XML Export
+function parseAppleHealthXML(filePath) {
+  try {
+    const xmlData = fs.readFileSync(filePath, 'utf8');
+    const parser = new XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: '@_',
+      parseAttributeValue: true,
+      parseNodeValue: true
+    });
+    
+    const result = parser.parse(xmlData);
+    return result;
+  } catch (error) {
+    console.error('Fehler beim Parsen der Apple Health XML-Datei:', error.message);
+    return null;
+  }
+}
+
+// Funktion zum Extrahieren von Schrittzahldaten aus Apple Health Export
+function extractStepData(healthData) {
+  if (!healthData || !healthData.HealthData || !healthData.HealthData.Record) {
+    console.log('Keine Schrittzahldaten in der Apple Health Export-Datei gefunden.');
+    return [];
+  }
+
+  const records = Array.isArray(healthData.HealthData.Record) 
+    ? healthData.HealthData.Record 
+    : [healthData.HealthData.Record];
+
+  // Filtere Schrittzahldaten (HKQuantityTypeIdentifierStepCount)
+  const stepRecords = records.filter(record => 
+    record['@_type'] === 'HKQuantityTypeIdentifierStepCount'
+  );
+
+  // Konsolidiere kurze Aufzeichnungen zu täglichen Summen
+  const dailySteps = {};
+  
+  for (const record of stepRecords) {
+    const date = new Date(record['@_startDate']);
+    const dayKey = date.toISOString().split('T')[0]; // YYYY-MM-DD
+    
+    if (!dailySteps[dayKey]) {
+      dailySteps[dayKey] = 0;
+    }
+    
+    dailySteps[dayKey] += parseInt(record['@_value']);
+  }
+
+  // Konvertiere zu Array von täglichen Schrittzahldaten
+  return Object.entries(dailySteps).map(([dateStr, steps]) => ({
+    date: new Date(dateStr),
+    steps: steps
+  }));
+}
+
+// Funktion zum Extrahieren von HRV-Daten aus Apple Health Export
+function extractHRVData(healthData) {
+  if (!healthData || !healthData.HealthData || !healthData.HealthData.Record) {
+    console.log('Keine HRV-Daten in der Apple Health Export-Datei gefunden.');
+    return [];
+  }
+
+  const records = Array.isArray(healthData.HealthData.Record) 
+    ? healthData.HealthData.Record 
+    : [healthData.HealthData.Record];
+
+  // Filtere HRV-Daten (HKQuantityTypeIdentifierHeartRateVariabilitySDNN)
+  const hrvRecords = records.filter(record => 
+    record['@_type'] === 'HKQuantityTypeIdentifierHeartRateVariabilitySDNN'
+  );
+
+  // Konsolidiere zu täglichen Durchschnittswerten
+  const dailyHRV = {};
+  
+  for (const record of hrvRecords) {
+    const date = new Date(record['@_startDate']);
+    const dayKey = date.toISOString().split('T')[0]; // YYYY-MM-DD
+    
+    if (!dailyHRV[dayKey]) {
+      dailyHRV[dayKey] = [];
+    }
+    
+    dailyHRV[dayKey].push(parseFloat(record['@_value']));
+  }
+
+  // Berechne tägliche Durchschnittswerte
+  return Object.entries(dailyHRV).map(([dateStr, values]) => ({
+    date: new Date(dateStr),
+    hrv: values.reduce((sum, val) => sum + val, 0) / values.length,
+    count: values.length
+  }));
+}
+
+// Funktion zum Extrahieren von Schlafdaten aus Apple Health Export
+function extractSleepData(healthData) {
+  if (!healthData || !healthData.HealthData || !healthData.HealthData.Record) {
+    console.log('Keine Schlafdaten in der Apple Health Export-Datei gefunden.');
+    return [];
+  }
+
+  const records = Array.isArray(healthData.HealthData.Record) 
+    ? healthData.HealthData.Record 
+    : [healthData.HealthData.Record];
+
+  // Filtere Schlafdaten (HKCategoryTypeIdentifierSleepAnalysis)
+  const sleepRecords = records.filter(record => 
+    record['@_type'] === 'HKCategoryTypeIdentifierSleepAnalysis' &&
+    record['@_value'] !== 'HKCategoryValueSleepAnalysisInBed'
+  );
+
+  // Konsolidiere Schlafphasen zu Schlafperioden
+  const sleepPeriods = [];
+  let currentPeriod = null;
+
+  // Sortiere Records nach Startdatum
+  sleepRecords.sort((a, b) => new Date(a['@_startDate']) - new Date(b['@_startDate']));
+
+  for (const record of sleepRecords) {
+    const startDate = new Date(record['@_startDate']);
+    const endDate = new Date(record['@_endDate']);
+    const value = record['@_value'];
+
+    // Ignoriere kurze Awake-Phasen (kürzer als 5 Minuten)
+    if (value === 'HKCategoryValueSleepAnalysisAwake' && (endDate - startDate) < 300000) {
+      continue;
+    }
+
+    // Beginne neue Schlafperiode oder erweitere bestehende
+    if (!currentPeriod || startDate > new Date(currentPeriod.endDate.getTime() + 30 * 60000)) {
+      // Neue Schlafperiode (mehr als 30 Minuten Pause = neue Periode)
+      if (currentPeriod) {
+        sleepPeriods.push(currentPeriod);
+      }
+      currentPeriod = {
+        startDate: startDate,
+        endDate: endDate,
+        totalSleepDuration: 0,
+        phases: []
+      };
+    }
+
+    // Füge Phase hinzu und berechne Schlafzeit
+    currentPeriod.endDate = endDate;
+    const duration = (endDate - startDate) / (1000 * 60 * 60); // in Stunden
+    
+    // Nur Schlafphasen zählen (nicht Awake)
+    if (value !== 'HKCategoryValueSleepAnalysisAwake') {
+      currentPeriod.totalSleepDuration += duration;
+    }
+    
+    currentPeriod.phases.push({
+      type: value,
+      startDate: startDate,
+      endDate: endDate,
+      duration: duration
+    });
+  }
+
+  // Füge die letzte Periode hinzu
+  if (currentPeriod) {
+    sleepPeriods.push(currentPeriod);
+  }
+
+  return sleepPeriods.map(period => ({
+    startDate: period.startDate,
+    endDate: period.endDate,
+    value: 'HKCategoryValueSleepAnalysisAsleep', // Konsolidierter Schlaf
+    duration: period.totalSleepDuration,
+    phases: period.phases
+  }));
+}
+
+// Funktion zum Extrahieren von Schlafzieldaten
+function extractSleepGoal(healthData) {
+  if (!healthData || !healthData.HealthData || !healthData.HealthData.Record) {
+    return 8; // Standard-Schlafziel von 8 Stunden
+  }
+
+  const records = Array.isArray(healthData.HealthData.Record) 
+    ? healthData.HealthData.Record 
+    : [healthData.HealthData.Record];
+
+  // Suche nach Schlafziel-Einträgen
+  const sleepGoalRecord = records.find(record => 
+    record['@_type'] === 'HKCategoryTypeIdentifierSleepAnalysis' &&
+    record['@_value'] === 'HKCategoryValueSleepAnalysisInBed'
+  );
+
+  return sleepGoalRecord ? 8 : 8; // Standardmäßig 8 Stunden
+}
+
+module.exports = {
+  parseAppleHealthXML,
+  extractStepData,
+  extractHRVData,
+  extractSleepData,
+  extractSleepGoal
+};

package/src/main.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Main entry point for the application
+require('./cli/cli');

package/src/utils/fileUtils.js

@@ -0,0 +1,46 @@
+const fs = require('fs');
+const path = require('path');
+
+// Funktion zum Auslesen des Erstellungsdatums einer Datei
+function getFileCreationDate(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    // Verwende das Erstellungsdatum (birthtime) oder das Änderungsdatum als Fallback
+    return stats.birthtime || stats.mtime;
+  } catch (error) {
+    console.error(`Fehler beim Lesen der Datei ${filePath}:`, error.message);
+    return null;
+  }
+}
+
+// Funktion zum Parsen von Datum in Jahr, Monat, Tag, Stunde, Minute
+function parseDateToComponents(date) {
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1, // Monate sind 0-basiert in JavaScript
+    day: date.getDate(),
+    hour: date.getHours(),
+    minute: date.getMinutes()
+  };
+}
+
+// Funktion zum Lesen aller Dateien in einem Ordner
+function readFilesInFolder(folderPath) {
+  try {
+    return fs.readdirSync(folderPath)
+      .filter(file => {
+        const fullPath = path.join(folderPath, file);
+        return fs.statSync(fullPath).isFile();
+      })
+      .map(file => path.join(folderPath, file));
+  } catch (error) {
+    console.error(`Fehler beim Lesen des Ordners ${folderPath}:`, error.message);
+    return [];
+  }
+}
+
+module.exports = {
+  getFileCreationDate,
+  parseDateToComponents,
+  readFilesInFolder
+};