Healix AI Platform

import { HealixAI } from '@healix/ai-sdk';

const ai = new HealixAI({
  apiKey: 'YOUR_API_KEY'
});

async function analyzeSleepPatterns() {
  // Sample sleep data for the past 30 days
  const sleepData = [
    { date: '2023-03-01', duration: 7.5, quality: 0.85, deepSleepPercentage: 0.25, remSleepPercentage: 0.20 },
    { date: '2023-03-02', duration: 6.8, quality: 0.75, deepSleepPercentage: 0.22, remSleepPercentage: 0.18 },
    // ... more data points
  ];

  // Analyze sleep patterns
  const response = await ai.analyze({
    data: {
      sleepData: sleepData
    },
    options: {
      analysisType: 'focused',
      timeframe: '30d',
      focusAreas: ['sleep']
    }
  });

  // Extract insights and recommendations
  const sleepInsights = response.insights.filter(insight => insight.category === 'sleep');
  const sleepRecommendations = response.recommendations.filter(rec => rec.category === 'sleep');

  // Display results
  console.log('Sleep Pattern Analysis Results:');
  console.log('\nInsights:');
  sleepInsights.forEach(insight => {
    console.log(`- ${insight.description} (Confidence: ${insight.confidence})`);
  });

  console.log('\nRecommendations:');
  sleepRecommendations.forEach(rec => {
    console.log(`- ${rec.description}`);
    console.log(`  Rationale: ${rec.rationale}`);
  });

  // Generate a sleep quality trend visualization
  const sleepQualityTrend = await ai.visualize({
    data: sleepData,
    visualizationType: 'trend',
    metric: 'quality',
    title: 'Sleep Quality Trend',
    timeframe: '30d'
  });

  return {
    insights: sleepInsights,
    recommendations: sleepRecommendations,
    visualization: sleepQualityTrend
  };
}

// Call the function
analyzeSleepPatterns()
  .then(results => console.log('Analysis complete!'))
  .catch(error => console.error('Error analyzing sleep patterns:', error));

import { HealixAI } from '@healix/ai-sdk';

const ai = new HealixAI({
  apiKey: 'YOUR_API_KEY'
});

async function assessDiabetesRisk(patientId) {
  // Fetch patient data from your system
  const patientData = await fetchPatientData(patientId);
  
  // Prepare the prediction request
  const response = await ai.predict({
    patientData: {
      demographics: {
        age: patientData.age,
        sex: patientData.sex,
        height: patientData.height,
        weight: patientData.weight
      },
      medicalHistory: {
        conditions: patientData.conditions,
        medications: patientData.medications,
        allergies: patientData.allergies,
        familyHistory: patientData.familyHistory
      },
      vitalTrends: patientData.vitals,
      labResults: patientData.labResults
    },
    predictionType: 'riskAssessment',
    targetCondition: 'type2Diabetes',
    timeHorizon: '5y',
    options: {
      includeExplanations: true,
      confidenceIntervals: true
    }
  });
  
  // Process the results
  const riskScore = response.prediction.riskScore;
  const riskCategory = response.prediction.riskCategory;
  const confidenceInterval = response.prediction.confidenceInterval;
  
  console.log(`Diabetes Risk Assessment for Patient ${patientId}:`);
  console.log(`Risk Score: ${riskScore} (Category: ${riskCategory})`);
  console.log(`Confidence Interval: ${confidenceInterval.lower} - ${confidenceInterval.upper}`);
  
  console.log('\nContributing Factors:');
  response.contributingFactors.forEach(factor => {
    console.log(`- ${factor.factor}: ${factor.value} (${factor.impact} impact, ${factor.direction} risk)`);
  });
  
  console.log('\nRecommendations:');
  response.recommendations.forEach(rec => {
    console.log(`- ${rec.description}`);
    console.log(`  Expected Impact: ${rec.expectedImpact}`);
  });
  
  // Generate a risk visualization
  const riskVisualization = await ai.visualize({
    data: response,
    visualizationType: 'riskAssessment',
    title: 'Type 2 Diabetes Risk Factors',
    patientId: patientId
  });
  
  return {
    riskAssessment: response,
    visualization: riskVisualization
  };
}

// Mock function to fetch patient data
async function fetchPatientData(patientId) {
  // In a real application, this would fetch data from your database
  return {
    age: 45,
    sex: 'male',
    height: 175,
    weight: 90,
    conditions: ['hypertension', 'hyperlipidemia'],
    medications: ['lisinopril', 'atorvastatin'],
    allergies: ['penicillin'],
    familyHistory: ['diabetes', 'coronary artery disease'],
    vitals: [
      { 
        date: '2023-02-15', 
        heartRate: 72, 
        bloodPressure: { systolic: 138, diastolic: 88 } 
      },
      // More vitals data...
    ],
    labResults: [
      { 
        date: '2023-02-15', 
        test: 'fastingGlucose', 
        value: 110, 
        unit: 'mg/dL', 
        referenceRange: { low: 70, high: 99 } 
      },
      { 
        date: '2023-02-15', 
        test: 'hba1c', 
        value: 5.9, 
        unit: '%', 
        referenceRange: { low: 4.0, high: 5.6 } 
      },
      // More lab results...
    ]
  };
}

// Call the function with a patient ID
assessDiabetesRisk('patient_12345')
  .then(results => console.log('Assessment complete!'))
  .catch(error => console.error('Error assessing diabetes risk:', error));

// HealthCoachApp.jsx
import React, { useState, useEffect } from 'react';
import { HealixAI } from '@healix/ai-sdk';
import { HealthDataChart } from './components/HealthDataChart';
import { RecommendationCard } from './components/RecommendationCard';
import { ProgressTracker } from './components/ProgressTracker';
import { GoalSetting } from './components/GoalSetting';

// Initialize the Healix AI client
const ai = new HealixAI({
  apiKey: process.env.REACT_APP_HEALIX_API_KEY
});

function HealthCoachApp({ userId }) {
  const [loading, setLoading] = useState(true);
  const [userData, setUserData] = useState(null);
  const [insights, setInsights] = useState([]);
  const [recommendations, setRecommendations] = useState([]);
  const [goals, setGoals] = useState([]);
  const [error, setError] = useState(null);

  // Fetch user data and generate insights
  useEffect(() => {
    async function fetchUserDataAndInsights() {
      try {
        setLoading(true);
        
        // Fetch user data from your backend
        const userData = await fetchUserData(userId);
        setUserData(userData);
        
        // Generate insights using Healix AI
        const analysisResponse = await ai.analyze({
          data: {
            sleepData: userData.sleepData,
            activityData: userData.activityData,
            nutritionData: userData.nutritionData,
            vitalData: userData.vitalData
          },
          options: {
            analysisType: 'comprehensive',
            timeframe: '30d'
          }
        });
        
        setInsights(analysisResponse.insights);
        setRecommendations(analysisResponse.recommendations);
        
        // Fetch user goals
        const userGoals = await fetchUserGoals(userId);
        setGoals(userGoals);
        
      } catch (err) {
        console.error('Error fetching data:', err);
        setError('Failed to load your health data. Please try again later.');
      } finally {
        setLoading(false);
      }
    }
    
    fetchUserDataAndInsights();
  }, [userId]);

  // Handle setting a new goal
  const handleSetGoal = async (goalData) => {
    try {
      // Use AI to validate and refine the goal
      const refinedGoal = await ai.refineGoal({
        userId,
        proposedGoal: goalData,
        userData: {
          currentMetrics: userData.latestMetrics,
          healthHistory: userData.healthHistory
        }
      });
      
      // Save the goal to your backend
      await saveUserGoal(userId, refinedGoal);
      
      // Update local state
      setGoals(prevGoals => [...prevGoals, refinedGoal]);
      
      return { success: true, goal: refinedGoal };
    } catch (err) {
      console.error('Error setting goal:', err);
      return { success: false, error: err.message };
    }
  };

  // Generate a personalized workout plan
  const generateWorkoutPlan = async () => {
    try {
      const workoutPlan = await ai.generatePlan({
        userId,
        planType: 'workout',
        userData: {
          fitnessLevel: userData.fitnessLevel,
          preferences: userData.preferences,
          restrictions: userData.restrictions
        },
        goals: goals.filter(g => g.category === 'fitness')
      });
      
      return workoutPlan;
    } catch (err) {
      console.error('Error generating workout plan:', err);
      return null;
    }
  };

  if (loading) {
    return <div className="loading-spinner">Loading your health data...</div>;
  }

  if (error) {
    return <div className="error-message">{error}</div>;
  }

  return (
    <div className="health-coach-app">
      <header className="app-header">
        <h1>Your Health Coach</h1>
        <p>Personalized insights and recommendations based on your health data</p>
      </header>
      
      <section className="health-overview">
        <h2>Health Overview</h2>
        <div className="metrics-grid">
          {userData.latestMetrics.map(metric => (
            <div key={metric.id} className="metric-card">
              <h3>{metric.name}</h3>
              <div className="metric-value">{metric.value} {metric.unit}</div>
              <div className="metric-trend">
                {metric.trend === 'up' ? '↑' : metric.trend === 'down' ? '↓' : '→'}
                {metric.trendValue}% in the last 7 days
              </div>
            </div>
          ))}
        </div>
      </section>
      
      <section className="data-visualization">
        <h2>Your Health Trends</h2>
        <div className="charts-container">
          <HealthDataChart 
            data={userData.sleepData} 
            type="sleep" 
            timeframe="30d" 
          />
          <HealthDataChart 
            data={userData.activityData} 
            type="activity" 
            timeframe="30d" 
          />
        </div>
      </section>
      
      <section className="ai-insights">
        <h2>AI-Powered Insights</h2>
        <div className="insights-list">
          {insights.map(insight => (
            <div key={insight.id} className="insight-card">
              <div className="insight-category">{insight.category}</div>
              <p className="insight-description">{insight.description}</p>
              <div className="insight-confidence">
                Confidence: {(insight.confidence * 100).toFixed(0)}%
              </div>
            </div>
          ))}
        </div>
      </section>
      
      <section className="recommendations">
        <h2>Personalized Recommendations</h2>
        <div className="recommendations-list">
          {recommendations.map(rec => (
            <RecommendationCard 
              key={rec.id}
              recommendation={rec}
              onAccept={() => markRecommendationAsAccepted(rec.id)}
              onDismiss={() => markRecommendationAsDismissed(rec.id)}
            />
          ))}
        </div>
      </section>
      
      <section className="goal-tracking">
        <h2>Your Health Goals</h2>
        <GoalSetting onSetGoal={handleSetGoal} />
        <ProgressTracker goals={goals} />
      </section>
      
      <section className="action-buttons">
        <button 
          className="primary-button"
          onClick={generateWorkoutPlan}
        >
          Generate Workout Plan
        </button>
        <button className="secondary-button">
          Schedule Health Coaching Session
        </button>
      </section>
    </div>
  );
}

// Mock functions for data fetching - replace with your actual API calls
async function fetchUserData(userId) {
  // In a real app, this would call your backend API
  return {
    sleepData: [],
    activityData: [],
    nutritionData: [],
    vitalData: [],
    latestMetrics: [
      { id: 1, name: 'Sleep Score', value: 85, unit: '/100', trend: 'up', trendValue: 5 },
      { id: 2, name: 'Resting Heart Rate', value: 62, unit: 'bpm', trend: 'down', trendValue: 3 },
      { id: 3, name: 'Daily Steps', value: 8750, unit: '', trend: 'up', trendValue: 12 },
      { id: 4, name: 'Active Minutes', value: 42, unit: 'min', trend: 'up', trendValue: 8 }
    ],
    fitnessLevel: 'intermediate',
    preferences: ['running', 'yoga', 'cycling'],
    restrictions: ['knee pain'],
    healthHistory: {}
  };
}

async function fetchUserGoals(userId) {
  // In a real app, this would call your backend API
  return [
    { id: 1, category: 'fitness', description: 'Run a 5K in under 30 minutes', deadline: '2023-06-30', progress: 0.65 },
    { id: 2, category: 'sleep', description: 'Average 7.5 hours of sleep per night', deadline: '2023-04-30', progress: 0.8 }
  ];
}

async function saveUserGoal(userId, goal) {
  // In a real app, this would call your backend API
  console.log('Saving goal for user', userId, goal);
  return { success: true };
}

async function markRecommendationAsAccepted(recId) {
  // In a real app, this would call your backend API
  console.log('Marking recommendation as accepted', recId);
  return { success: true };
}

async function markRecommendationAsDismissed(recId) {
  // In a real app, this would call your backend API
  console.log('Marking recommendation as dismissed', recId);
  return { success: true };
}

export default HealthCoachApp;