@wplaunchify/ml-mcp-server 2.0.0 → 2.1.0

package/build/tools/fluent-community-learning.js

@@ -0,0 +1,488 @@
+// src/tools/fluent-community-learning.ts
+// COMM2 - Learning & Admin (36 tools)
+// Use case: "I create courses, manage lessons, and configure community settings"
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+// ==================== SCHEMA DEFINITIONS ====================
+// Courses
+const listCoursesSchema = z.object({
+    space_id: z.number().optional().describe('Filter courses by space ID'),
+    status: z.enum(['published', 'draft', 'archived']).optional().describe('Filter by status'),
+    limit: z.number().optional().default(20).describe('Number of courses to return'),
+    search: z.string().optional().describe('Search term')
+});
+const getCourseSchema = z.object({
+    id: z.number().describe('The ID of the course to retrieve')
+});
+const createCourseSchema = z.object({
+    title: z.string().describe('Course title'),
+    space_id: z.number().describe('The space ID where the course will be created'),
+    description: z.string().optional().describe('Course description'),
+    featured_image: z.string().optional().describe('Featured image URL'),
+    status: z.enum(['published', 'draft']).optional().default('draft').describe('Course status'),
+    settings: z.object({
+        enrollment_type: z.enum(['open', 'approval', 'closed']).optional(),
+        certificate_enabled: z.boolean().optional(),
+        drip_enabled: z.boolean().optional()
+    }).optional().describe('Course settings')
+});
+const updateCourseSchema = z.object({
+    id: z.number().describe('The ID of the course to update'),
+    title: z.string().optional().describe('Course title'),
+    description: z.string().optional().describe('Course description'),
+    featured_image: z.string().optional().describe('Featured image URL'),
+    status: z.enum(['published', 'draft', 'archived']).optional().describe('Course status'),
+    settings: z.object({
+        enrollment_type: z.enum(['open', 'approval', 'closed']).optional(),
+        certificate_enabled: z.boolean().optional(),
+        drip_enabled: z.boolean().optional()
+    }).optional().describe('Course settings')
+});
+const deleteCourseSchema = z.object({
+    id: z.number().describe('The ID of the course to delete')
+});
+// Lessons
+const listLessonsSchema = z.object({
+    course_id: z.number().describe('The course ID to list lessons from'),
+    limit: z.number().optional().default(50).describe('Number of lessons to return')
+});
+const getLessonSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The ID of the lesson to retrieve')
+});
+const createLessonSchema = z.object({
+    course_id: z.number().describe('The course ID where the lesson will be created'),
+    title: z.string().describe('Lesson title'),
+    content: z.string().describe('Lesson content (HTML supported)'),
+    order: z.number().optional().describe('Lesson order/position'),
+    type: z.enum(['lesson', 'quiz', 'assignment']).optional().default('lesson').describe('Lesson type'),
+    settings: z.object({
+        video_url: z.string().optional(),
+        duration: z.number().optional(),
+        downloadable: z.boolean().optional()
+    }).optional().describe('Lesson settings')
+});
+const updateLessonSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The ID of the lesson to update'),
+    title: z.string().optional().describe('Lesson title'),
+    content: z.string().optional().describe('Lesson content (HTML supported)'),
+    order: z.number().optional().describe('Lesson order/position'),
+    type: z.enum(['lesson', 'quiz', 'assignment']).optional().describe('Lesson type'),
+    settings: z.object({
+        video_url: z.string().optional(),
+        duration: z.number().optional(),
+        downloadable: z.boolean().optional()
+    }).optional().describe('Lesson settings')
+});
+const deleteLessonSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The ID of the lesson to delete')
+});
+// Course Progress
+const getCourseProgressSchema = z.object({
+    course_id: z.number().describe('The course ID to get progress for'),
+    user_id: z.number().optional().describe('User ID (defaults to current user)')
+});
+const updateCourseProgressSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    lesson_id: z.number().describe('The lesson ID to mark progress for'),
+    status: z.enum(['completed', 'in_progress']).describe('Progress status'),
+    user_id: z.number().optional().describe('User ID (defaults to current user)')
+});
+const getMyCoursesSchema = z.object({
+    status: z.enum(['enrolled', 'completed', 'in_progress']).optional().describe('Filter by enrollment status'),
+    limit: z.number().optional().default(20).describe('Number of courses to return')
+});
+// Quizzes
+const listQuizzesSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    limit: z.number().optional().default(50).describe('Number of quizzes to return')
+});
+const getQuizSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The quiz ID')
+});
+const createQuizSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    title: z.string().describe('Quiz title'),
+    questions: z.array(z.object({
+        question: z.string(),
+        answers: z.array(z.string()),
+        correct_answer: z.number()
+    })).describe('Quiz questions'),
+    passing_score: z.number().optional().describe('Passing score percentage')
+});
+const updateQuizSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The quiz ID'),
+    title: z.string().optional().describe('Quiz title'),
+    questions: z.array(z.object({
+        question: z.string(),
+        answers: z.array(z.string()),
+        correct_answer: z.number()
+    })).optional().describe('Quiz questions'),
+    passing_score: z.number().optional().describe('Passing score percentage')
+});
+const deleteQuizSchema = z.object({
+    course_id: z.number().describe('The course ID'),
+    id: z.number().describe('The quiz ID')
+});
+// Media
+const listMediaSchema = z.object({
+    limit: z.number().optional().default(50).describe('Number of media items to return')
+});
+const uploadMediaSchema = z.object({
+    file_url: z.string().describe('URL of file to upload'),
+    file_name: z.string().optional().describe('File name')
+});
+// Giphy
+const searchGiphySchema = z.object({
+    query: z.string().describe('Search query for GIFs'),
+    limit: z.number().optional().default(20).describe('Number of GIFs to return')
+});
+// Webhooks
+const listWebhooksSchema = z.object({
+    limit: z.number().optional().default(50).describe('Number of webhooks to return')
+});
+const createWebhookSchema = z.object({
+    url: z.string().describe('Webhook URL'),
+    events: z.array(z.string()).describe('Events to trigger webhook'),
+    secret: z.string().optional().describe('Webhook secret for verification')
+});
+const deleteWebhookSchema = z.object({
+    id: z.number().describe('Webhook ID')
+});
+// Leaderboard
+const getLeaderboardSchema = z.object({
+    period: z.enum(['daily', 'weekly', 'monthly', 'all_time']).optional().default('all_time').describe('Leaderboard period'),
+    limit: z.number().optional().default(50).describe('Number of users to return')
+});
+const addPointsSchema = z.object({
+    user_id: z.number().describe('User ID'),
+    points: z.number().describe('Points to add'),
+    reason: z.string().optional().describe('Reason for points')
+});
+// ==================== TOOL DEFINITIONS (36 tools) ====================
+export const fluentCommunityLearningTools = [
+    // Courses (5)
+    { name: 'fc_list_courses', description: 'List all courses in FluentCommunity', inputSchema: { type: 'object', properties: listCoursesSchema.shape } },
+    { name: 'fc_get_course', description: 'Get a specific course by ID', inputSchema: { type: 'object', properties: getCourseSchema.shape } },
+    { name: 'fc_create_course', description: 'Create a new course', inputSchema: { type: 'object', properties: createCourseSchema.shape } },
+    { name: 'fc_update_course', description: 'Update an existing course', inputSchema: { type: 'object', properties: updateCourseSchema.shape } },
+    { name: 'fc_delete_course', description: 'Delete a course', inputSchema: { type: 'object', properties: deleteCourseSchema.shape } },
+    // Lessons (5)
+    { name: 'fc_list_lessons', description: 'List all lessons in a course', inputSchema: { type: 'object', properties: listLessonsSchema.shape } },
+    { name: 'fc_get_lesson', description: 'Get a specific lesson by ID', inputSchema: { type: 'object', properties: getLessonSchema.shape } },
+    { name: 'fc_create_lesson', description: 'Create a new lesson in a course', inputSchema: { type: 'object', properties: createLessonSchema.shape } },
+    { name: 'fc_update_lesson', description: 'Update an existing lesson', inputSchema: { type: 'object', properties: updateLessonSchema.shape } },
+    { name: 'fc_delete_lesson', description: 'Delete a lesson', inputSchema: { type: 'object', properties: deleteLessonSchema.shape } },
+    // Course Progress (3)
+    { name: 'fc_get_course_progress', description: 'Get course progress for a user', inputSchema: { type: 'object', properties: getCourseProgressSchema.shape } },
+    { name: 'fc_update_course_progress', description: 'Update course progress (mark lesson completed)', inputSchema: { type: 'object', properties: updateCourseProgressSchema.shape } },
+    { name: 'fc_get_my_courses', description: 'Get all courses the current user is enrolled in', inputSchema: { type: 'object', properties: getMyCoursesSchema.shape } },
+    // Quizzes (5)
+    { name: 'fc_list_quizzes', description: 'List quizzes for a course', inputSchema: { type: 'object', properties: listQuizzesSchema.shape } },
+    { name: 'fc_get_quiz', description: 'Get a specific quiz by ID', inputSchema: { type: 'object', properties: getQuizSchema.shape } },
+    { name: 'fc_create_quiz', description: 'Create a new quiz in a course', inputSchema: { type: 'object', properties: createQuizSchema.shape } },
+    { name: 'fc_update_quiz', description: 'Update an existing quiz', inputSchema: { type: 'object', properties: updateQuizSchema.shape } },
+    { name: 'fc_delete_quiz', description: 'Delete a quiz', inputSchema: { type: 'object', properties: deleteQuizSchema.shape } },
+    // Media (2)
+    { name: 'fc_list_media', description: 'List media items', inputSchema: { type: 'object', properties: listMediaSchema.shape } },
+    { name: 'fc_upload_media', description: 'Upload media file', inputSchema: { type: 'object', properties: uploadMediaSchema.shape } },
+    // Giphy (1)
+    { name: 'fc_search_giphy', description: 'Search Giphy for GIFs', inputSchema: { type: 'object', properties: searchGiphySchema.shape } },
+    // Webhooks (3)
+    { name: 'fc_list_webhooks', description: 'List all webhooks', inputSchema: { type: 'object', properties: listWebhooksSchema.shape } },
+    { name: 'fc_create_webhook', description: 'Create a new webhook', inputSchema: { type: 'object', properties: createWebhookSchema.shape } },
+    { name: 'fc_delete_webhook', description: 'Delete a webhook', inputSchema: { type: 'object', properties: deleteWebhookSchema.shape } },
+    // Leaderboard & Points (2)
+    { name: 'fc_get_leaderboard', description: 'Get the community leaderboard', inputSchema: { type: 'object', properties: getLeaderboardSchema.shape } },
+    { name: 'fc_add_points', description: 'Add points to a user', inputSchema: { type: 'object', properties: addPointsSchema.shape } },
+];
+// Note: Admin tools (fc_cleanup_members, fc_list_terms) are in fluent-community-admin.ts
+// Note: Design tools (colors, portal, branding) are in fluent-community-design.ts  
+// Note: Layout tools are in fluent-community-layout.ts
+// These are automatically included when using fluentcommunity-learning
+// ==================== HANDLERS ====================
+export const fluentCommunityLearningHandlers = {
+    // Courses
+    fc_list_courses: async (args) => {
+        try {
+            const params = { per_page: args.limit || 20 };
+            if (args.space_id)
+                params.space_id = args.space_id;
+            if (args.status)
+                params.status = args.status;
+            if (args.search)
+                params.search = args.search;
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/courses', params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_course: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_create_course: async (args) => {
+        try {
+            const courseData = { title: args.title, space_id: args.space_id, status: args.status || 'draft' };
+            if (args.description)
+                courseData.description = args.description;
+            if (args.featured_image)
+                courseData.featured_image = args.featured_image;
+            if (args.settings)
+                courseData.settings = args.settings;
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/courses', courseData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_course: async (args) => {
+        try {
+            const { id, ...updateData } = args;
+            const response = await makeWordPressRequest('PUT', `fc-manager/v1/courses/${id}`, updateData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_delete_course: async (args) => {
+        try {
+            const response = await makeWordPressRequest('DELETE', `fc-manager/v1/courses/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Lessons
+    fc_list_lessons: async (args) => {
+        try {
+            const params = { per_page: args.limit || 50 };
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.course_id}/lessons`, params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_lesson: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.course_id}/lessons/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_create_lesson: async (args) => {
+        try {
+            const lessonData = { title: args.title, content: args.content, type: args.type || 'lesson' };
+            if (args.order)
+                lessonData.order = args.order;
+            if (args.settings)
+                lessonData.settings = args.settings;
+            const response = await makeWordPressRequest('POST', `fc-manager/v1/courses/${args.course_id}/lessons`, lessonData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_lesson: async (args) => {
+        try {
+            const { course_id, id, ...updateData } = args;
+            const response = await makeWordPressRequest('PUT', `fc-manager/v1/courses/${course_id}/lessons/${id}`, updateData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_delete_lesson: async (args) => {
+        try {
+            const response = await makeWordPressRequest('DELETE', `fc-manager/v1/courses/${args.course_id}/lessons/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Course Progress
+    fc_get_course_progress: async (args) => {
+        try {
+            const params = {};
+            if (args.user_id)
+                params.user_id = args.user_id;
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.course_id}/progress`, params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_course_progress: async (args) => {
+        try {
+            const progressData = { lesson_id: args.lesson_id, status: args.status };
+            if (args.user_id)
+                progressData.user_id = args.user_id;
+            const response = await makeWordPressRequest('POST', `fc-manager/v1/courses/${args.course_id}/progress`, progressData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_my_courses: async (args) => {
+        try {
+            const params = { per_page: args.limit || 20 };
+            if (args.status)
+                params.status = args.status;
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/courses/my-courses', params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Quizzes
+    fc_list_quizzes: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.course_id}/quizzes`, { per_page: args.limit || 50 });
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_quiz: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', `fc-manager/v1/courses/${args.course_id}/quizzes/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_create_quiz: async (args) => {
+        try {
+            const { course_id, ...quizData } = args;
+            const response = await makeWordPressRequest('POST', `fc-manager/v1/courses/${course_id}/quizzes`, quizData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_quiz: async (args) => {
+        try {
+            const { course_id, id, ...updateData } = args;
+            const response = await makeWordPressRequest('PUT', `fc-manager/v1/courses/${course_id}/quizzes/${id}`, updateData);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_delete_quiz: async (args) => {
+        try {
+            const response = await makeWordPressRequest('DELETE', `fc-manager/v1/courses/${args.course_id}/quizzes/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Media
+    fc_list_media: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/media', { per_page: args.limit || 50 });
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_upload_media: async (args) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/media', args);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Giphy
+    fc_search_giphy: async (args) => {
+        try {
+            const params = { query: args.query, limit: args.limit || 20 };
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/giphy/search', params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Webhooks
+    fc_list_webhooks: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/webhooks', { per_page: args.limit || 50 });
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_create_webhook: async (args) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/webhooks', args);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_delete_webhook: async (args) => {
+        try {
+            const response = await makeWordPressRequest('DELETE', `fc-manager/v1/webhooks/${args.id}`);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    // Leaderboard
+    fc_get_leaderboard: async (args) => {
+        try {
+            const params = { per_page: args.limit || 50 };
+            if (args.period)
+                params.period = args.period;
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/leaderboard', params);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_add_points: async (args) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/leaderboard/points', args);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+};

package/build/tools/index.js

@@ -20,6 +20,8 @@ import { fluentCartLicensingTools, fluentCartLicensingHandlers } from './fluent-
 import { fluentCartAdminTools, fluentCartAdminHandlers } from './fluent-cart-admin.js';
 import { fluentCommunityChatTools, fluentCommunityChatHandlers } from './fluent-community-chat.js';
 import { fluentCommunityAdminTools, fluentCommunityAdminHandlers } from './fluent-community-admin.js';
+import { fluentCommunityCoreTools, fluentCommunityCoreHandlers } from './fluent-community-core.js';
+import { fluentCommunityLearningTools, fluentCommunityLearningHandlers } from './fluent-community-learning.js';
 // Tool categories for selective loading
 const toolCategories = {
     wordpress: [
@@ -31,6 +33,7 @@ const toolCategories = {
         ...pluginRepositoryTools,
         ...commentTools
     ],
+    // Full FluentCommunity (91 tools) - legacy support
     fluentcommunity: [
         ...fluentCommunityTools,
         ...fluentCommunityDesignTools,
@@ -38,6 +41,18 @@ const toolCategories = {
         ...fluentCommunityChatTools,
         ...fluentCommunityAdminTools
     ],
+    // COMM1 - Community Core (55 tools) - posts, spaces, members, engagement
+    'fluentcommunity-core': [
+        ...fluentCommunityCoreTools,
+        ...fluentCommunityChatTools // Chat is part of core community
+    ],
+    // COMM2 - Learning & Admin (36 tools) - courses, lessons, settings
+    'fluentcommunity-learning': [
+        ...fluentCommunityLearningTools,
+        ...fluentCommunityDesignTools,
+        ...fluentCommunityLayoutTools,
+        ...fluentCommunityAdminTools
+    ],
     fluentcart: [
         ...fluentCartTools,
         ...fluentCartAnalyticsTools,
@@ -74,6 +89,16 @@ const handlerCategories = {
         ...fluentCommunityChatHandlers,
         ...fluentCommunityAdminHandlers
     },
+    'fluentcommunity-core': {
+        ...fluentCommunityCoreHandlers,
+        ...fluentCommunityChatHandlers
+    },
+    'fluentcommunity-learning': {
+        ...fluentCommunityLearningHandlers,
+        ...fluentCommunityDesignHandlers,
+        ...fluentCommunityLayoutHandlers,
+        ...fluentCommunityAdminHandlers
+    },
     fluentcart: {
         ...fluentCartHandlers,
         ...fluentCartAnalyticsHandlers,
@@ -93,11 +118,11 @@ const handlerCategories = {
         ...debugHandlers
     }
 };
-// Filter tools based on LOAD_ONLY environment variable
+// Filter tools based on ENABLED_TOOLS environment variable
 function getFilteredTools() {
-    const loadOnly = process.env.LOAD_ONLY?.toLowerCase();
-    if (!loadOnly) {
-        // No filter - load all tools
+    const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
+    if (!enabledTools || enabledTools === 'all') {
+        // No filter or 'all' - load all tools
         return [
             ...toolCategories.wordpress,
             ...toolCategories.fluentcommunity,
@@ -107,13 +132,28 @@ function getFilteredTools() {
             ...toolCategories.debug
         ];
     }
-    // Load specific category
-    const category = loadOnly;
-    if (toolCategories[category]) {
-        console.error(`📦 Loading only: ${loadOnly}`);
+    // Map user-friendly names to internal category names
+    const categoryMap = {
+        'wordpress': 'wordpress',
+        'fluent-community': 'fluentcommunity',
+        'fluentcommunity': 'fluentcommunity',
+        'fluentcommunity-core': 'fluentcommunity-core',
+        'fluent-community-core': 'fluentcommunity-core',
+        'fluentcommunity-learning': 'fluentcommunity-learning',
+        'fluent-community-learning': 'fluentcommunity-learning',
+        'fluent-cart': 'fluentcart',
+        'fluentcart': 'fluentcart',
+        'fluent-crm': 'fluentcrm',
+        'fluentcrm': 'fluentcrm',
+        'mlplugins': 'mlplugins',
+        'debug': 'debug'
+    };
+    const category = categoryMap[enabledTools];
+    if (category && toolCategories[category]) {
+        console.error(`📦 Loading only: ${enabledTools} (${toolCategories[category].length} tools)`);
         return toolCategories[category];
     }
-    console.error(`⚠️  Unknown LOAD_ONLY value: ${loadOnly}. Loading all tools.`);
+    console.error(`⚠️  Unknown ENABLED_TOOLS value: ${enabledTools}. Loading all tools.`);
     return [
         ...toolCategories.wordpress,
         ...toolCategories.fluentcommunity,
@@ -124,9 +164,9 @@ function getFilteredTools() {
     ];
 }
 function getFilteredHandlers() {
-    const loadOnly = process.env.LOAD_ONLY?.toLowerCase();
-    if (!loadOnly) {
-        // No filter - load all handlers
+    const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
+    if (!enabledTools || enabledTools === 'all') {
+        // No filter or 'all' - load all handlers
         return {
             ...handlerCategories.wordpress,
             ...handlerCategories.fluentcommunity,
@@ -136,9 +176,24 @@ function getFilteredHandlers() {
             ...handlerCategories.debug
         };
     }
-    // Load specific category
-    const category = loadOnly;
-    if (handlerCategories[category]) {
+    // Map user-friendly names to internal category names
+    const categoryMap = {
+        'wordpress': 'wordpress',
+        'fluent-community': 'fluentcommunity',
+        'fluentcommunity': 'fluentcommunity',
+        'fluentcommunity-core': 'fluentcommunity-core',
+        'fluent-community-core': 'fluentcommunity-core',
+        'fluentcommunity-learning': 'fluentcommunity-learning',
+        'fluent-community-learning': 'fluentcommunity-learning',
+        'fluent-cart': 'fluentcart',
+        'fluentcart': 'fluentcart',
+        'fluent-crm': 'fluentcrm',
+        'fluentcrm': 'fluentcrm',
+        'mlplugins': 'mlplugins',
+        'debug': 'debug'
+    };
+    const category = categoryMap[enabledTools];
+    if (category && handlerCategories[category]) {
         return handlerCategories[category];
     }
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wplaunchify/ml-mcp-server",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Universal MCP Server for WordPress + Fluent Suite (Community, CRM, Cart) + MinuteLaunch Plugins. Comprehensive tools for AI-powered WordPress management via Claude, Cursor, and other MCP clients.",
   "type": "module",
   "main": "./build/server.js",