thryve-mcp-server 0.0.1

package/src/category-mappings.ts

@@ -0,0 +1,181 @@
+/**
+ * Category mappings for LLM-friendly health data access
+ * Maps high-level categories to Thryve data type IDs
+ */
+
+import { ALL_DATA_TYPES } from "./data-types-generated.js";
+
+export type HealthCategory =
+  | "Activity"
+  | "Heart Rate"
+  | "Sleep"
+  | "Workouts"
+  | "Stress & HRV"
+  | "Respiratory"
+  | "Blood Glucose"
+  | "Body Composition"
+  | "Womens Health"
+  | "Nutrition"
+  | "Cardiovascular"
+  | "Wellness"
+  | "Audio & Hearing"
+  | "Microbiome"
+  | "Location"
+  | "Movement Analysis";
+
+interface CategoryMapping {
+  thryveCategories: string[];
+  description: string;
+  dataTypeIds: number[];
+}
+
+/**
+ * Build category mappings dynamically from data types
+ */
+function buildCategoryMappings(): Record<HealthCategory, CategoryMapping> {
+  const mappings: Record<string, CategoryMapping> = {
+    "Activity": {
+      thryveCategories: ["Activity"],
+      description: "Steps, distance, floors climbed, elevation, calories burned, and general activity metrics",
+      dataTypeIds: [],
+    },
+    "Heart Rate": {
+      thryveCategories: ["Heart Rate"],
+      description: "Heart rate measurements including resting, average, min, max, and variability",
+      dataTypeIds: [],
+    },
+    "Sleep": {
+      thryveCategories: ["Sleep"],
+      description: "Sleep duration, stages, quality, and sleep-related metrics",
+      dataTypeIds: [],
+    },
+    "Workouts": {
+      thryveCategories: ["Workouts"],
+      description: "Exercise sessions, workout types, duration, and performance metrics",
+      dataTypeIds: [],
+    },
+    "Stress & HRV": {
+      thryveCategories: ["Stress & HRV"],
+      description: "Stress levels, heart rate variability, and recovery metrics",
+      dataTypeIds: [],
+    },
+    "Respiratory": {
+      thryveCategories: ["Respiratory & Breathing"],
+      description: "Breathing rate, SpO2, respiratory patterns, and lung function",
+      dataTypeIds: [],
+    },
+    "Blood Glucose": {
+      thryveCategories: ["Blood Glucose"],
+      description: "Blood glucose levels and continuous glucose monitoring (CGM) data",
+      dataTypeIds: [],
+    },
+    "Body Composition": {
+      thryveCategories: ["Body Composition & Measurements"],
+      description: "Weight, BMI, body fat percentage, muscle mass, and body measurements",
+      dataTypeIds: [],
+    },
+    "Womens Health": {
+      thryveCategories: ["Women's Health"],
+      description: "Menstrual cycle tracking, ovulation, symptoms, and reproductive health",
+      dataTypeIds: [],
+    },
+    "Nutrition": {
+      thryveCategories: ["Detailed Nutrition"],
+      description: "Nutritional intake including calories, macros, micros, hydration, and meal data",
+      dataTypeIds: [],
+    },
+    "Cardiovascular": {
+      thryveCategories: ["Cardiovascular Health", "Advanced Cardiac Analysis"],
+      description: "Blood pressure, VO2 max, cardiac analysis, and cardiovascular health metrics",
+      dataTypeIds: [],
+    },
+    "Wellness": {
+      thryveCategories: ["Self-Reported Wellness"],
+      description: "General wellness, mood, energy levels, and self-reported health data",
+      dataTypeIds: [],
+    },
+    "Audio & Hearing": {
+      thryveCategories: ["Audio & Hearing Health"],
+      description: "Hearing health, audio exposure, and environmental sound levels",
+      dataTypeIds: [],
+    },
+    "Microbiome": {
+      thryveCategories: ["Microbiome & Gut Health"],
+      description: "Gut health, microbiome composition, and digestive metrics",
+      dataTypeIds: [],
+    },
+    "Location": {
+      thryveCategories: ["Location & GPS"],
+      description: "GPS coordinates, routes, and location tracking data",
+      dataTypeIds: [],
+    },
+    "Movement Analysis": {
+      thryveCategories: ["Movement Analysis"],
+      description: "Movement patterns, gait analysis, and biomechanics",
+      dataTypeIds: [],
+    },
+  };
+
+  // Build data type ID lists by matching categories
+  for (const dataType of ALL_DATA_TYPES) {
+    for (const [category, mapping] of Object.entries(mappings)) {
+      // Check if this data type's category matches any of the mapping's Thryve categories
+      const matches = mapping.thryveCategories.some((thryveCategory) => {
+        // Handle compound categories like "Activity,Workouts"
+        const dataTypeCategories = dataType.category.split(",").map((c) => c.trim());
+        return dataTypeCategories.includes(thryveCategory);
+      });
+
+      if (matches) {
+        mapping.dataTypeIds.push(dataType.id);
+      }
+    }
+  }
+
+  return mappings as Record<HealthCategory, CategoryMapping>;
+}
+
+// Build mappings once at module load time
+export const CATEGORY_MAPPINGS = buildCategoryMappings();
+
+/**
+ * Get all data type IDs for given categories
+ */
+export function getDataTypeIdsForCategories(categories: HealthCategory[]): number[] {
+  const allIds = new Set<number>();
+
+  for (const category of categories) {
+    const mapping = CATEGORY_MAPPINGS[category];
+    if (mapping) {
+      mapping.dataTypeIds.forEach((id) => allIds.add(id));
+    }
+  }
+
+  return Array.from(allIds);
+}
+
+/**
+ * Get category information for display
+ */
+export function getCategoryInfo(category: HealthCategory): CategoryMapping | undefined {
+  return CATEGORY_MAPPINGS[category];
+}
+
+/**
+ * Get all available categories
+ */
+export function getAllCategories(): HealthCategory[] {
+  return Object.keys(CATEGORY_MAPPINGS) as HealthCategory[];
+}
+
+/**
+ * Get category statistics
+ */
+export function getCategoryStats() {
+  return Object.entries(CATEGORY_MAPPINGS).map(([category, mapping]) => ({
+    category,
+    description: mapping.description,
+    dataTypeCount: mapping.dataTypeIds.length,
+    thryveCategories: mapping.thryveCategories,
+  }));
+}

package/src/data-enrichment.ts

@@ -0,0 +1,125 @@
+/**
+ * Shared data enrichment utilities for health data
+ * Used by getDailyData, getEpochData, and getHealthDataByCategory
+ */
+
+import type { HealthDataRecord } from "./types.js";
+import { getDataTypeById } from "./data-types-generated.js";
+import { generateRecordId } from "./helpers.js";
+
+/**
+ * Flatten Thryve API response structure into flat array of records
+ */
+export function flattenThryveResponse(data: any): HealthDataRecord[] {
+  const records: HealthDataRecord[] = [];
+
+  if (!Array.isArray(data)) {
+    return records;
+  }
+
+  for (const item of data) {
+    if (item.dataSources && Array.isArray(item.dataSources)) {
+      for (const dataSource of item.dataSources) {
+        if (dataSource.data && Array.isArray(dataSource.data)) {
+          for (const record of dataSource.data) {
+            records.push({
+              ...record,
+              dataSource: dataSource.dataSource,
+              dataSourceName: dataSource.dataSourceName,
+              _recordId: generateRecordId({ ...record, dataSource: dataSource.dataSource }),
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return records;
+}
+
+/**
+ * Enrich records with data type metadata (name, category, unit)
+ */
+export function enrichWithDataTypes(records: HealthDataRecord[]): void {
+  for (const record of records) {
+    const typeId =
+      record.dailyDynamicValueType ||
+      record.dynamicValueType ||
+      record.dynamicEpochValueType;
+
+    if (typeId) {
+      const dataType = getDataTypeById(typeId);
+      if (dataType) {
+        // Set appropriate type name based on the type ID field
+        if (record.dailyDynamicValueType) {
+          record.dailyDynamicValueTypeName = dataType.name;
+        }
+        if (record.dynamicValueType || record.dynamicEpochValueType) {
+          record.dynamicValueTypeName = dataType.name;
+          record.dynamicEpochValueTypeName = dataType.name;
+        }
+
+        record.category = dataType.category;
+        record.unit = dataType.unit;
+        record.dataType = typeId;
+      }
+    }
+  }
+}
+
+/**
+ * Rebuild Thryve API response structure from flattened records
+ * Groups records by dataSource
+ */
+export function rebuildThryveResponse(records: HealthDataRecord[]): any[] {
+  if (records.length === 0) {
+    return [];
+  }
+
+  // Group records by data source
+  const groupedBySource = new Map<number, HealthDataRecord[]>();
+
+  for (const record of records) {
+    const sourceId = record.dataSource || 0;
+    if (!groupedBySource.has(sourceId)) {
+      groupedBySource.set(sourceId, []);
+    }
+    groupedBySource.get(sourceId)!.push(record);
+  }
+
+  // Rebuild structure
+  const result: any[] = [];
+
+  for (const [dataSource, sourceRecords] of groupedBySource) {
+    // Extract first record to get authToken (if present)
+    const firstRecord = sourceRecords[0];
+    const authToken = (firstRecord as any).authenticationToken;
+
+    const dataSourceObj: any = {
+      dataSource,
+      data: sourceRecords.map((record) => {
+        // Remove internal fields
+        const { dataSource: _ds, dataSourceName: _dsName, _recordId, ...cleanRecord } = record;
+        return cleanRecord;
+      }),
+    };
+
+    // Add dataSourceName if available
+    if (sourceRecords[0].dataSourceName) {
+      dataSourceObj.dataSourceName = sourceRecords[0].dataSourceName;
+    }
+
+    const responseItem: any = {
+      dataSources: [dataSourceObj],
+    };
+
+    // Add authToken if present
+    if (authToken) {
+      responseItem.authenticationToken = authToken;
+    }
+
+    result.push(responseItem);
+  }
+
+  return result;
+}