hevy-mcp-server 1.0.0

package/dist/resources.js

@@ -0,0 +1,265 @@
+/**
+ * MCP Resources for Hevy API data
+ * Provides read-only access to workout and fitness data as resources
+ */
+// Resource definitions for MCP
+export const resourceDefinitions = [
+    {
+        uri: 'hevy://workouts',
+        name: 'All Workouts',
+        description: 'Complete list of all workouts in the Hevy account',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://routines',
+        name: 'All Routines',
+        description: 'Complete list of all workout routines',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://exercise-templates',
+        name: 'Exercise Templates',
+        description: 'Complete list of available exercise templates',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://routine-folders',
+        name: 'Routine Folders',
+        description: 'List of routine organization folders',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://account-summary',
+        name: 'Account Summary',
+        description: 'High-level summary of account data and statistics',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://recent-workouts',
+        name: 'Recent Workouts',
+        description: 'Last 10 workouts with basic details',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'hevy://exercise-list',
+        name: 'Exercise List',
+        description: 'Simplified list of exercise names and IDs for reference',
+        mimeType: 'text/plain',
+    },
+];
+// Resource implementations
+export const resources = {
+    'hevy://workouts': async (client) => {
+        const workouts = await client.getAllWorkouts();
+        return {
+            contents: [
+                {
+                    uri: 'hevy://workouts',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        total_workouts: workouts.length,
+                        workouts: workouts.map(workout => ({
+                            id: workout.id,
+                            title: workout.title,
+                            description: workout.description,
+                            start_time: workout.start_time,
+                            end_time: workout.end_time,
+                            duration_minutes: workout.end_time ?
+                                Math.round((new Date(workout.end_time).getTime() - new Date(workout.start_time).getTime()) / 60000) :
+                                null,
+                            exercise_count: workout.exercises.length,
+                            total_sets: workout.exercises.reduce((sum, ex) => sum + ex.sets.length, 0),
+                            exercises: workout.exercises.map(exercise => ({
+                                title: exercise.title,
+                                exercise_template_id: exercise.exercise_template_id,
+                                sets_count: exercise.sets.length,
+                                notes: exercise.notes,
+                            })),
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://routines': async (client) => {
+        const routines = await client.getAllRoutines();
+        return {
+            contents: [
+                {
+                    uri: 'hevy://routines',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        total_routines: routines.length,
+                        routines: routines.map(routine => ({
+                            id: routine.id,
+                            title: routine.title,
+                            folder_id: routine.folder_id,
+                            created_at: routine.created_at,
+                            updated_at: routine.updated_at,
+                            exercise_count: routine.exercises.length,
+                            total_sets: routine.exercises.reduce((sum, ex) => sum + ex.sets.length, 0),
+                            exercises: routine.exercises.map(exercise => ({
+                                title: exercise.title,
+                                exercise_template_id: exercise.exercise_template_id,
+                                sets_count: exercise.sets.length,
+                                rest_seconds: exercise.rest_seconds,
+                                notes: exercise.notes,
+                            })),
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://exercise-templates': async (client) => {
+        const templates = await client.getAllExerciseTemplates();
+        return {
+            contents: [
+                {
+                    uri: 'hevy://exercise-templates',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        total_templates: templates.length,
+                        muscle_groups: [...new Set(templates.map(t => t.primary_muscle_group))].sort(),
+                        exercise_templates: templates.map(template => ({
+                            id: template.id,
+                            title: template.title,
+                            type: template.type,
+                            primary_muscle_group: template.primary_muscle_group,
+                            secondary_muscle_groups: template.secondary_muscle_groups,
+                            is_custom: template.is_custom,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://routine-folders': async (client) => {
+        const folders = await client.getAllRoutineFolders();
+        return {
+            contents: [
+                {
+                    uri: 'hevy://routine-folders',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        total_folders: folders.length,
+                        routine_folders: folders.map(folder => ({
+                            id: folder.id,
+                            title: folder.title,
+                            index: folder.index,
+                            created_at: folder.created_at,
+                            updated_at: folder.updated_at,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://account-summary': async (client) => {
+        const [workoutCount, workouts, routines, templates, folders] = await Promise.all([
+            client.getWorkoutCount(),
+            client.getAllWorkouts(),
+            client.getAllRoutines(),
+            client.getAllExerciseTemplates(),
+            client.getAllRoutineFolders(),
+        ]);
+        // Calculate some basic statistics
+        const recentWorkouts = workouts
+            .sort((a, b) => new Date(b.start_time).getTime() - new Date(a.start_time).getTime())
+            .slice(0, 10);
+        const totalSets = workouts.reduce((sum, workout) => sum + workout.exercises.reduce((exSum, ex) => exSum + ex.sets.length, 0), 0);
+        const exerciseFrequency = {};
+        workouts.forEach(workout => workout.exercises.forEach(exercise => exerciseFrequency[exercise.exercise_template_id] = (exerciseFrequency[exercise.exercise_template_id] || 0) + 1));
+        const mostUsedExercises = Object.entries(exerciseFrequency)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 10)
+            .map(([exerciseId, count]) => {
+            const template = templates.find(t => t.id === exerciseId);
+            return {
+                exercise_template_id: exerciseId,
+                title: template?.title || 'Unknown Exercise',
+                usage_count: count,
+            };
+        });
+        return {
+            contents: [
+                {
+                    uri: 'hevy://account-summary',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        account_stats: {
+                            total_workouts: workoutCount.workout_count,
+                            total_routines: routines.length,
+                            total_exercise_templates: templates.length,
+                            custom_exercises: templates.filter(t => t.is_custom).length,
+                            routine_folders: folders.length,
+                            total_sets_completed: totalSets,
+                        },
+                        recent_activity: {
+                            last_workout: recentWorkouts[0] ? {
+                                id: recentWorkouts[0].id,
+                                title: recentWorkouts[0].title,
+                                date: recentWorkouts[0].start_time,
+                                exercise_count: recentWorkouts[0].exercises.length,
+                            } : null,
+                            workouts_last_30_days: workouts.filter(w => {
+                                const workoutDate = new Date(w.start_time);
+                                const thirtyDaysAgo = new Date();
+                                thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+                                return workoutDate >= thirtyDaysAgo;
+                            }).length,
+                        },
+                        most_used_exercises: mostUsedExercises,
+                        muscle_group_distribution: templates.reduce((acc, template) => {
+                            acc[template.primary_muscle_group] = (acc[template.primary_muscle_group] || 0) + 1;
+                            return acc;
+                        }, {}),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://recent-workouts': async (client) => {
+        const allWorkouts = await client.getAllWorkouts();
+        const recentWorkouts = allWorkouts
+            .sort((a, b) => new Date(b.start_time).getTime() - new Date(a.start_time).getTime())
+            .slice(0, 10);
+        return {
+            contents: [
+                {
+                    uri: 'hevy://recent-workouts',
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        recent_workouts: recentWorkouts.map(workout => ({
+                            id: workout.id,
+                            title: workout.title,
+                            date: workout.start_time,
+                            duration_minutes: workout.end_time ?
+                                Math.round((new Date(workout.end_time).getTime() - new Date(workout.start_time).getTime()) / 60000) :
+                                null,
+                            exercise_count: workout.exercises.length,
+                            total_sets: workout.exercises.reduce((sum, ex) => sum + ex.sets.length, 0),
+                            primary_exercises: workout.exercises.slice(0, 3).map(ex => ex.title),
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+    'hevy://exercise-list': async (client) => {
+        const templates = await client.getAllExerciseTemplates();
+        const exerciseList = templates
+            .sort((a, b) => a.title.localeCompare(b.title))
+            .map(template => `${template.id} - ${template.title} (${template.primary_muscle_group})`)
+            .join('\n');
+        return {
+            contents: [
+                {
+                    uri: 'hevy://exercise-list',
+                    mimeType: 'text/plain',
+                    text: `Hevy Exercise Templates (${templates.length} total)\n\n${exerciseList}`,
+                },
+            ],
+        };
+    },
+};

package/dist/tools.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP Tools for Hevy API interactions
+ * Provides tools for managing workouts, routines, and exercise data
+ */
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HevyAPIClient } from './hevy-api.js';
+export declare const toolDefinitions: Tool[];
+export declare const tools: Record<string, (client: HevyAPIClient, args: any) => Promise<any>>;