@lyrra/mcp-server 1.0.0

package/src/tools/connections.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const connectionsTools = {
+  connection_list: {
+    description: `Lister toutes les connexions (edges) d'un parcours EduFlow. Chaque connexion relie un bloc source à un bloc cible.
+Règles de connexion :
+- Le bloc "start" ne peut avoir QUE des connexions sortantes
+- Le bloc "end" ne peut avoir QUE des connexions entrantes
+- Un bloc "split" doit avoir au moins 2 connexions sortantes
+- Un bloc "merge" doit avoir au moins 2 connexions entrantes
+- Un bloc "quiz" peut avoir des connexions conditionnelles (branchement selon la réponse)`,
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      return {
+        edges: flow.edges || [],
+        blocks: (flow.blocks || []).map((b: any) => ({ id: b.id, type: b.type, title: b.title })),
+      };
+    },
+  },
+
+  connection_add: {
+    description: 'Ajouter une connexion entre deux blocs. Le parcours est un graphe orienté : source → target.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      source: z.string().describe('ID du bloc source (d\'où part la connexion)'),
+      target: z.string().describe('ID du bloc cible (où arrive la connexion)'),
+      label: z.string().optional().describe('Label affiché sur la connexion (ex: "Bonne réponse", "Mauvaise réponse")'),
+      animated: z.boolean().optional().describe('Animer la connexion visuellement'),
+    }),
+    handler: async ({ flowId, source, target, label, animated }: any) => {
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      const edges = flow.edges || [];
+      const newEdge = {
+        id: `e-${source}-${target}`,
+        source,
+        target,
+        label: label || '',
+        animated: animated || false,
+      };
+      // Check for duplicate
+      const exists = edges.some((e: any) => e.source === source && e.target === target);
+      if (exists) {
+        return { success: false, error: 'Cette connexion existe déjà' };
+      }
+      edges.push(newEdge);
+      await client.put(`/flows/${flowId}`, { edges }, 'eduflow');
+      return { success: true, edge: newEdge, totalEdges: edges.length };
+    },
+  },
+
+  connection_remove: {
+    description: 'Supprimer une connexion entre deux blocs.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      edgeId: z.string().optional().describe('ID de la connexion à supprimer'),
+      source: z.string().optional().describe('Alternative : ID du bloc source'),
+      target: z.string().optional().describe('Alternative : ID du bloc cible'),
+    }),
+    handler: async ({ flowId, edgeId, source, target }: any) => {
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      let edges = flow.edges || [];
+      if (edgeId) {
+        edges = edges.filter((e: any) => e.id !== edgeId);
+      } else if (source && target) {
+        edges = edges.filter((e: any) => !(e.source === source && e.target === target));
+      } else {
+        return { success: false, error: 'Fournir edgeId OU source+target' };
+      }
+      await client.put(`/flows/${flowId}`, { edges }, 'eduflow');
+      return { success: true, remainingEdges: edges.length };
+    },
+  },
+};

package/src/tools/eduflow.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const eduflowTools = {
+  eduflow_list: {
+    description: 'Lister tous les parcours EduFlow de l\'utilisateur. Retourne id, titre, statut, nombre de blocs, dates.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/flows', 'eduflow');
+    },
+  },
+
+  eduflow_get: {
+    description: 'Récupérer les détails complets d\'un parcours EduFlow : blocs, connexions (edges), objectifs, paramètres de gamification, présentation, etc.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours EduFlow'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}`, 'eduflow');
+    },
+  },
+
+  eduflow_create: {
+    description: 'Créer un nouveau parcours EduFlow. Un bloc "start" et un bloc "end" sont automatiquement créés.',
+    inputSchema: z.object({
+      title: z.string().describe('Titre du parcours'),
+      description: z.string().optional().describe('Description du parcours'),
+      language: z.enum(['fr', 'en', 'es', 'it', 'de']).optional().describe('Langue du parcours (défaut: fr)'),
+    }),
+    handler: async (args: { title: string; description?: string; language?: string }) => {
+      return client.post('/flows', args, 'eduflow');
+    },
+  },
+
+  eduflow_update: {
+    description: 'Mettre à jour les propriétés d\'un parcours EduFlow (titre, description, edges, gamification, objectifs, présentation, etc.).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      title: z.string().optional().describe('Nouveau titre'),
+      description: z.string().optional().describe('Nouvelle description'),
+      edges: z.array(z.object({
+        id: z.string(),
+        source: z.string().describe('ID du bloc source'),
+        target: z.string().describe('ID du bloc cible'),
+        label: z.string().optional().describe('Label de la connexion'),
+        animated: z.boolean().optional(),
+      })).optional().describe('Connexions entre blocs (remplace toutes les connexions existantes)'),
+      objectives: z.any().optional().describe('Objectifs pédagogiques {globalObjective, steps[]}'),
+      gamification: z.any().optional().describe('Configuration gamification {badges, missions, leaderboard, certifications}'),
+      presentationEnabled: z.boolean().optional().describe('Activer/désactiver la page de présentation'),
+      presentationData: z.any().optional().describe('Données de la page de présentation'),
+      chatbotEnabled: z.boolean().optional().describe('Activer/désactiver le chatbot IA'),
+      facialVerificationEnabled: z.boolean().optional().describe('Activer/désactiver la vérification faciale'),
+      deadline: z.string().optional().describe('Date limite ISO 8601'),
+      language: z.enum(['fr', 'en', 'es', 'it', 'de']).optional().describe('Langue du parcours'),
+    }),
+    handler: async ({ flowId, ...data }: any) => {
+      return client.put(`/flows/${flowId}`, data, 'eduflow');
+    },
+  },
+
+  eduflow_delete: {
+    description: 'Supprimer définitivement un parcours EduFlow et tous ses blocs, connexions, participants.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours à supprimer'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.delete(`/flows/${flowId}`, 'eduflow');
+    },
+  },
+
+  eduflow_duplicate: {
+    description: 'Dupliquer un parcours EduFlow existant avec tous ses blocs et connexions.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours à dupliquer'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.post(`/flows/${flowId}/duplicate`, {}, 'eduflow');
+    },
+  },
+
+  eduflow_change_status: {
+    description: 'Changer le statut d\'un parcours : draft (brouillon), published (publié, accessible aux étudiants), archived (archivé).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      status: z.enum(['draft', 'published', 'archived']).describe('Nouveau statut'),
+    }),
+    handler: async ({ flowId, status }: { flowId: string; status: string }) => {
+      return client.patch(`/flows/${flowId}/status`, { status }, 'eduflow');
+    },
+  },
+
+  eduflow_export: {
+    description: 'Exporter un parcours EduFlow au format JSON (contient blocs, connexions, paramètres).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours à exporter'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/export`, 'eduflow');
+    },
+  },
+
+  eduflow_get_public: {
+    description: 'Récupérer les informations publiques d\'un parcours (page de présentation, objectifs). Ne nécessite pas d\'authentification.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/public`, 'eduflow');
+    },
+  },
+};

package/src/tools/participants.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const participantsTools = {
+  participant_list: {
+    description: 'Lister tous les participants/étudiants inscrits à un parcours EduFlow avec leur progression.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/flows/${flowId}/students`, 'eduflow');
+    },
+  },
+
+  participant_add: {
+    description: 'Ajouter un ou plusieurs participants à un parcours EduFlow. Chaque participant reçoit un lien unique.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      participants: z.array(z.object({
+        email: z.string().email().describe('Email du participant'),
+        firstName: z.string().optional().describe('Prénom'),
+        lastName: z.string().optional().describe('Nom'),
+      })).describe('Liste des participants à ajouter'),
+    }),
+    handler: async ({ flowId, participants }: any) => {
+      return client.post(`/flows/${flowId}/students`, { students: participants }, 'eduflow');
+    },
+  },
+
+  participant_remove: {
+    description: 'Retirer un participant d\'un parcours EduFlow.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      studentId: z.string().uuid().describe('ID de l\'inscription étudiant'),
+    }),
+    handler: async ({ flowId, studentId }: { flowId: string; studentId: string }) => {
+      return client.delete(`/flows/${flowId}/students/${studentId}`, 'eduflow');
+    },
+  },
+
+  participant_get_progress: {
+    description: 'Récupérer la progression détaillée d\'un participant : blocs complétés, scores, temps passé par bloc.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      studentToken: z.string().describe('Token unique du participant'),
+    }),
+    handler: async ({ flowId, studentToken }: { flowId: string; studentToken: string }) => {
+      return client.get(`/eduflow/progress/stats/${flowId}/${studentToken}`);
+    },
+  },
+
+  participant_get_overview: {
+    description: 'Vue d\'ensemble d\'un participant global : tous les parcours suivis, certifications, progression globale.',
+    inputSchema: z.object({
+      participantId: z.string().uuid().describe('ID global du participant'),
+    }),
+    handler: async ({ participantId }: { participantId: string }) => {
+      return client.get(`/participants/${participantId}/overview`, 'eduflow');
+    },
+  },
+
+  participant_get_flow_stats: {
+    description: 'Récupérer les statistiques de tous les participants d\'un parcours (taux de complétion, scores moyens, temps moyen).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      return client.get(`/eduflow/progress/stats/flow/${flowId}`);
+    },
+  },
+};

package/src/tools/presentation.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const presentationTools = {
+  presentation_get: {
+    description: 'Récupérer la page de présentation d\'un parcours EduFlow (description, objectifs, image de couverture, structure affichée).',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+    }),
+    handler: async ({ flowId }: { flowId: string }) => {
+      const flow = await client.get(`/flows/${flowId}`, 'eduflow');
+      return {
+        presentationEnabled: flow.presentationEnabled,
+        presentationData: flow.presentationData,
+        objectives: flow.objectives,
+        title: flow.title,
+        description: flow.description,
+      };
+    },
+  },
+
+  presentation_update: {
+    description: `Mettre à jour la page de présentation d'un parcours. La présentation est la page publique visible par les futurs participants.
+Structure de presentationData : { heroTitle, heroSubtitle, heroImage, sections[{ type, title, content }], ctaText, ctaUrl }`,
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      presentationData: z.object({
+        heroTitle: z.string().optional().describe('Titre principal de la page'),
+        heroSubtitle: z.string().optional().describe('Sous-titre'),
+        heroImage: z.string().optional().describe('URL de l\'image de couverture'),
+        sections: z.array(z.object({
+          type: z.string().describe('Type de section (text, objectives, structure, testimonials)'),
+          title: z.string().describe('Titre de la section'),
+          content: z.any().describe('Contenu de la section'),
+        })).optional().describe('Sections de la page'),
+        ctaText: z.string().optional().describe('Texte du bouton d\'action'),
+        ctaUrl: z.string().optional().describe('URL du bouton d\'action'),
+      }).describe('Données de la page de présentation'),
+    }),
+    handler: async ({ flowId, presentationData }: any) => {
+      return client.put(`/flows/${flowId}`, { presentationData }, 'eduflow');
+    },
+  },
+
+  presentation_toggle: {
+    description: 'Activer ou désactiver la page de présentation publique d\'un parcours.',
+    inputSchema: z.object({
+      flowId: z.string().uuid().describe('ID du parcours'),
+      enabled: z.boolean().describe('true pour activer, false pour désactiver'),
+    }),
+    handler: async ({ flowId, enabled }: { flowId: string; enabled: boolean }) => {
+      return client.put(`/flows/${flowId}`, { presentationEnabled: enabled }, 'eduflow');
+    },
+  },
+};

package/src/tools/projects.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const projectsTools = {
+  project_list: {
+    description: 'Lister tous les projets audio de l\'utilisateur (PDF convertis en audio).',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/projects');
+    },
+  },
+
+  project_get: {
+    description: 'Détails d\'un projet audio : titre, chapitres, voix, durée, statut, fichiers générés.',
+    inputSchema: z.object({
+      projectId: z.string().uuid().describe('ID du projet'),
+    }),
+    handler: async ({ projectId }: { projectId: string }) => {
+      return client.get(`/projects/${projectId}`);
+    },
+  },
+
+  project_create: {
+    description: 'Créer un nouveau projet audio.',
+    inputSchema: z.object({
+      title: z.string().describe('Titre du projet'),
+      description: z.string().optional().describe('Description'),
+    }),
+    handler: async (data: any) => {
+      return client.post('/projects', data);
+    },
+  },
+
+  project_update: {
+    description: 'Mettre à jour un projet audio (titre, description, paramètres de voix).',
+    inputSchema: z.object({
+      projectId: z.string().uuid().describe('ID du projet'),
+      title: z.string().optional().describe('Nouveau titre'),
+      description: z.string().optional().describe('Nouvelle description'),
+    }),
+    handler: async ({ projectId, ...data }: any) => {
+      return client.put(`/projects/${projectId}`, data);
+    },
+  },
+
+  project_delete: {
+    description: 'Supprimer un projet audio et tous ses fichiers associés.',
+    inputSchema: z.object({
+      projectId: z.string().uuid().describe('ID du projet à supprimer'),
+    }),
+    handler: async ({ projectId }: { projectId: string }) => {
+      return client.delete(`/projects/${projectId}`);
+    },
+  },
+};

package/src/tools/resources.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const resourcesTools = {
+  resource_list: {
+    description: 'Lister les ressources de l\'utilisateur (images, documents, sons, vidéos) avec pagination.',
+    inputSchema: z.object({
+      type: z.enum(['images', 'documents', 'sounds', 'videos']).describe('Type de ressource'),
+    }),
+    handler: async ({ type }: { type: string }) => {
+      return client.get(`/user-resources/${type}`);
+    },
+  },
+
+  resource_delete: {
+    description: 'Supprimer une ressource uploadée.',
+    inputSchema: z.object({
+      type: z.enum(['images', 'documents', 'sounds', 'videos']).describe('Type de ressource'),
+      resourceId: z.string().uuid().describe('ID de la ressource'),
+    }),
+    handler: async ({ type, resourceId }: { type: string; resourceId: string }) => {
+      return client.delete(`/user-resources/${type}/${resourceId}`);
+    },
+  },
+
+  resource_list_categories: {
+    description: 'Lister les catégories disponibles pour un type de ressource.',
+    inputSchema: z.object({
+      type: z.enum(['images', 'documents', 'sounds', 'videos']).describe('Type de ressource'),
+    }),
+    handler: async ({ type }: { type: string }) => {
+      return client.get(`/categories/${type}`);
+    },
+  },
+};

package/src/tools/store.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+
+export const storeTools = {
+  store_list_audiobooks: {
+    description: 'Lister les audiobooks disponibles dans le store LYRRA. Supporte la pagination, recherche et filtres.',
+    inputSchema: z.object({
+      page: z.number().optional().describe('Page (défaut: 1)'),
+      limit: z.number().optional().describe('Nombre par page (défaut: 20)'),
+      search: z.string().optional().describe('Recherche par titre/auteur'),
+      category: z.string().optional().describe('Filtrer par catégorie'),
+      featured: z.boolean().optional().describe('Uniquement les audiobooks mis en avant'),
+    }),
+    handler: async ({ page, limit, search, category, featured }: any) => {
+      const params = new URLSearchParams();
+      if (page) params.set('page', String(page));
+      if (limit) params.set('limit', String(limit));
+      if (search) params.set('search', search);
+      if (category) params.set('category', category);
+      if (featured) params.set('featured', 'true');
+      const query = params.toString() ? `?${params}` : '';
+      return client.post(`/store/public/audiobooks${query}`, {});
+    },
+  },
+
+  store_get_audiobook: {
+    description: 'Détails complets d\'un audiobook : chapitres, auteur, avis, prix en crédits, statistiques.',
+    inputSchema: z.object({
+      audiobookId: z.string().describe('ID de l\'audiobook'),
+    }),
+    handler: async ({ audiobookId }: { audiobookId: string }) => {
+      return client.get(`/store/public/audiobooks/${audiobookId}`);
+    },
+  },
+
+  store_list_authors: {
+    description: 'Lister les auteurs mis en avant sur le store.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/store/public/authors/featured');
+    },
+  },
+
+  store_my_library: {
+    description: 'Récupérer ma bibliothèque d\'audiobooks achetés.',
+    inputSchema: z.object({}),
+    handler: async () => {
+      return client.get('/store/my-library');
+    },
+  },
+
+  store_search: {
+    description: 'Rechercher des audiobooks dans le store par mot-clé.',
+    inputSchema: z.object({
+      query: z.string().describe('Terme de recherche'),
+    }),
+    handler: async ({ query }: { query: string }) => {
+      return client.post('/store/public/audiobooks', { search: query });
+    },
+  },
+};

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}