mcp-grocy 2.0.0 → 2.0.2

package/build/config/index.js

@@ -177,9 +177,14 @@ export class ConfigManager {
     parseToolConfiguration() {
         const enabledTools = new Set();
         const toolSubConfigs = new Map();
+        const toolAckTokens = new Map();
         for (const [toolName, toolConfig] of Object.entries(this.config.yaml.tools)) {
             if (toolConfig.enabled) {
                 enabledTools.add(toolName);
+                // Store ack_token separately if configured
+                if (toolConfig.ack_token && typeof toolConfig.ack_token === 'string') {
+                    toolAckTokens.set(toolName, toolConfig.ack_token);
+                }
                 // Extract sub-configs (everything except standard fields)
                 const subConfigs = new Map();
                 for (const [key, value] of Object.entries(toolConfig)) {
@@ -192,7 +197,7 @@ export class ConfigManager {
                 }
             }
         }
-        return { enabledTools, toolSubConfigs };
+        return { enabledTools, toolSubConfigs, toolAckTokens };
     }
 }
 // Export singleton instance

package/build/server/mcp-server.js

@@ -17,6 +17,7 @@ export class GrocyMcpServer {
     server;
     enabledTools = new Set();
     toolSubConfigs = new Map();
+    toolAckTokens = new Map();
     resourceHandler;
     toolRegistry;
     constructor(server, toolRegistry, resourceHandler) {
@@ -49,8 +50,9 @@ export class GrocyMcpServer {
         return new GrocyMcpServer(server, toolRegistry, resourceHandler);
     }
     parseToolConfiguration() {
-        const { enabledTools, toolSubConfigs } = config.parseToolConfiguration();
+        const { enabledTools, toolSubConfigs, toolAckTokens } = config.parseToolConfiguration();
         this.toolSubConfigs = toolSubConfigs;
+        this.toolAckTokens = toolAckTokens;
         // Validate tool names
         const validToolNames = new Set(this.toolRegistry.getToolNames());
         if (enabledTools.size > 0) {
@@ -99,11 +101,11 @@ export class GrocyMcpServer {
             try {
                 const subConfigs = this.toolSubConfigs.get(toolName);
                 const result = await handler(args, subConfigs);
-                // Automatically add ack_token to successful responses
-                if (!result.isError && subConfigs) {
-                    const ackToken = subConfigs.get('ack_token');
-                    if (ackToken && typeof ackToken === 'string') {
-                        result.content.push({
+                // Automatically add ack_token to successful responses (at the beginning)
+                if (!result.isError) {
+                    const ackToken = this.toolAckTokens.get(toolName);
+                    if (ackToken) {
+                        result.content.unshift({
                             type: 'text',
                             text: `Acknowledgment token: ${ackToken}`
                         });

package/build/tools/module-loader.js

@@ -134,13 +134,18 @@ export async function createToolRegistry() {
     const { toolModules } = await ModuleLoader.loadAllModules();
     const definitions = [];
     const handlers = {};
+    const validators = {};
     for (const module of toolModules) {
         definitions.push(...module.definitions);
         Object.assign(handlers, module.handlers);
+        if (module.validators) {
+            Object.assign(validators, module.validators);
+        }
     }
     return {
         getDefinitions: () => definitions,
         getHandler: (name) => handlers[name],
+        getValidator: (name) => validators[name],
         getToolNames: () => definitions.map(def => def.name)
     };
 }

package/build/tools/recipes/handlers.js

@@ -6,6 +6,25 @@ import { BaseToolHandler } from '../base.js';
 import { InventoryToolHandlers } from '../inventory/handlers.js';
 export class RecipeToolHandlers extends BaseToolHandler {
     inventoryHandlers = new InventoryToolHandlers();
+    /**
+     * Helper method to get meal plan for multiple days
+     */
+    async getMealPlanForDays(dates) {
+        const allResults = [];
+        for (const date of dates) {
+            const dayString = date.toISOString().split('T')[0];
+            const dayResult = await this.apiCall(`/objects/meal_plan`, 'GET', undefined, {
+                queryParams: {
+                    'query[]': `day=${dayString}`,
+                    order: 'day'
+                }
+            });
+            if (Array.isArray(dayResult)) {
+                allResults.push(...dayResult);
+            }
+        }
+        return allResults;
+    }
     /**
      * Get recipes with specified fields
      */
@@ -134,35 +153,78 @@ export class RecipeToolHandlers extends BaseToolHandler {
     getMealPlan = async (args) => {
         return this.executeToolHandler(async () => {
             const { date, weekly } = args || {};
-            // Build query parameters for meal plan with context
-            const params = new URLSearchParams({
-                force_today: '1',
-                order: 'day',
-                limit: weekly ? '14' : '3',
-                offset: weekly ? '-7' : '-1'
-            });
-            if (date) {
-                const targetDate = new Date(date);
-                if (isNaN(targetDate.getTime())) {
-                    throw new Error('Invalid date format. Use YYYY-MM-DD.');
-                }
-                if (weekly) {
-                    // For weekly view, get the start of the week (Monday)
-                    const dayOfWeek = targetDate.getDay();
-                    const mondayOffset = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
-                    const startOfWeek = new Date(targetDate);
-                    startOfWeek.setDate(targetDate.getDate() + mondayOffset);
-                    params.set('dates[0]', startOfWeek.toISOString().split('T')[0]);
-                }
-                else {
-                    // Get the day before for context
-                    const dayBefore = new Date(targetDate);
-                    dayBefore.setDate(targetDate.getDate() - 1);
-                    params.set('dates[0]', dayBefore.toISOString().split('T')[0]);
+            // Date parameter is mandatory
+            this.validateRequired({ date }, ['date']);
+            const targetDate = new Date(date);
+            if (isNaN(targetDate.getTime())) {
+                throw new Error('Invalid date format. Use YYYY-MM-DD.');
+            }
+            const datesToQuery = [];
+            if (weekly) {
+                // For weekly view, get the start of the week (Monday)
+                const dayOfWeek = targetDate.getDay();
+                const mondayOffset = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
+                const startDate = new Date(targetDate);
+                startDate.setDate(targetDate.getDate() + mondayOffset);
+                // Get all 7 days of the week with ±1 day buffer for timezone issues
+                for (let i = -1; i <= 7; i++) {
+                    const day = new Date(startDate);
+                    day.setDate(startDate.getDate() + i);
+                    datesToQuery.push(day);
                 }
             }
-            const result = await this.apiCall(`/objects/meal_plan`, 'GET', undefined, { queryParams: Object.fromEntries(params) });
-            return this.createSuccess(result, 'Meal plan retrieved successfully');
+            else {
+                // Get the specific date with ±1 day buffer for timezone issues
+                const dayBefore = new Date(targetDate);
+                dayBefore.setDate(targetDate.getDate() - 1);
+                const dayAfter = new Date(targetDate);
+                dayAfter.setDate(targetDate.getDate() + 1);
+                datesToQuery.push(dayBefore, targetDate, dayAfter);
+            }
+            const result = await this.getMealPlanForDays(datesToQuery);
+            if (result.length === 0) {
+                return this.createSuccess({
+                    message: weekly ? 'No meals planned for the requested week' : 'No meals planned for the requested date',
+                    meal_plan_by_date: {}
+                }, 'Meal plan retrieved successfully');
+            }
+            // Extract unique recipe IDs 
+            const recipeIds = [...new Set(result.map(entry => entry.recipe_id).filter(id => id))];
+            // Fetch recipe details and all sections in parallel
+            const [recipeDetails, allSections] = await Promise.all([
+                Promise.all(recipeIds.map(recipeId => this.apiCall(`/objects/recipes/${recipeId}`))),
+                this.apiCall('/objects/meal_plan_sections')
+            ]);
+            // Simplify meal plan entries - don't merge recipe/section details
+            const simplifiedMealPlanByDate = {};
+            result.forEach(entry => {
+                const entryDate = entry.day;
+                if (!simplifiedMealPlanByDate[entryDate]) {
+                    simplifiedMealPlanByDate[entryDate] = [];
+                }
+                simplifiedMealPlanByDate[entryDate].push({
+                    id: entry.id,
+                    day: entry.day,
+                    section_id: entry.section_id,
+                    recipe_id: entry.recipe_id,
+                    recipe_servings: entry.recipe_servings,
+                    note: entry.note,
+                    done: entry.done
+                });
+            });
+            return this.createSuccess({
+                meal_plan_by_date: simplifiedMealPlanByDate,
+                recipes: recipeDetails.map((recipe) => ({
+                    id: recipe.id,
+                    name: recipe.name,
+                    product_id: recipe.product_id,
+                })),
+                sections: Array.isArray(allSections) ? allSections.map((section) => ({
+                    id: section.id,
+                    name: section.name,
+                    time_info: section.time_info
+                })) : []
+            }, 'Meal plan retrieved successfully');
         });
     };
     /**

package/build/tools/recipes/index.js

@@ -1,5 +1,6 @@
 import { recipeToolDefinitions } from './definitions.js';
 import { RecipeToolHandlers } from './handlers.js';
+import { validateCompleteSubConfigs } from './validations.js';
 // Use simplified handlers
 const handlers = new RecipeToolHandlers();
 export const recipeModule = {
@@ -24,6 +25,9 @@ export const recipeModule = {
         // Shopping Integration
         recipes_shopping_add_all_products: handlers.addAllProductsToShopping,
         recipes_shopping_add_missing_products: handlers.addMissingProductsToShopping
+    },
+    validators: {
+        recipes_cooking_complete: validateCompleteSubConfigs
     }
 };
 export * from './definitions.js';

package/build/tools/validation-helpers.js

@@ -1,77 +1,3 @@
-/**
- * Common validation helpers for all tools
- */
-/**
- * Auto-discover and load validator functions for tools
- */
-export class ValidatorRegistry {
-    static validatorCache = new Map();
-    /**
-     * Get validator for a tool by automatically discovering and loading it
-     * Convention: tools/[module]/validations.ts should export validate[ToolName]SubConfigs
-     */
-    static async getValidator(toolName) {
-        if (this.validatorCache.has(toolName)) {
-            return this.validatorCache.get(toolName);
-        }
-        try {
-            // Convert tool_name to ToolName (camelCase with first letter uppercase)
-            const validatorFunctionName = this.getValidatorFunctionName(toolName);
-            // Try to dynamically import the validator from the appropriate module
-            const modulePath = this.getModulePath(toolName);
-            const validationsModule = await import(modulePath);
-            const validator = validationsModule[validatorFunctionName];
-            if (validator && typeof validator === 'function') {
-                this.validatorCache.set(toolName, validator);
-                return validator;
-            }
-        }
-        catch (error) {
-            // Validator doesn't exist or failed to load - that's fine, not all tools need validators
-        }
-        return undefined;
-    }
-    /**
-     * Convert tool_name to expected validator function name
-     * Example: complete -> validateCompleteSubConfigs
-     */
-    static getValidatorFunctionName(toolName) {
-        const camelCase = toolName.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-        const pascalCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
-        return `validate${pascalCase}SubConfigs`;
-    }
-    /**
-     * Determine which module a tool belongs to based on its name
-     */
-    static getModulePath(toolName) {
-        // Map tool names to their modules
-        const moduleMap = {
-            // Recipe tools
-            'get_recipes': './recipes/validations.js',
-            'get_recipe_by_id': './recipes/validations.js',
-            'create_recipe': './recipes/validations.js',
-            'get_recipe_fulfillment': './recipes/validations.js',
-            'get_recipes_fulfillment': './recipes/validations.js',
-            'consume_recipe': './recipes/validations.js',
-            'add_recipe_products_to_shopping_list': './recipes/validations.js',
-            'add_missing_products_to_shopping_list': './recipes/validations.js',
-            'complete': './recipes/validations.js',
-            // Stock tools
-            'get_all_stock': './stock/validations.js',
-            'get_stock_volatile': './stock/validations.js',
-            'get_stock_by_location': './stock/validations.js',
-            'inventory_product': './stock/validations.js',
-            'purchase_product': './stock/validations.js',
-            'consume_product': './stock/validations.js',
-            'transfer_product': './stock/validations.js',
-            'open_product': './stock/validations.js',
-            'lookup_product': './stock/validations.js',
-            'print_stock_entry_label': './stock/validations.js',
-            // Add more modules as needed...
-        };
-        return moduleMap[toolName] || `./unknown/validations.js`;
-    }
-}
 /**
  * Common validation utility functions
  */

package/build/version.js

@@ -1,4 +1,4 @@
 // Auto-generated file - DO NOT MODIFY
-export const VERSION = '2.0.0';
+export const VERSION = '2.0.2';
 export const PACKAGE_NAME = 'mcp-grocy';
 export const SERVER_NAME = 'grocy-api';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-grocy",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Model Context Protocol (MCP) server for Grocy integration",
   "license": "MIT",
   "type": "module",
@@ -85,5 +85,8 @@
   "homepage": "https://github.com/miguelangel-nubla/mcp-grocy#readme",
   "engines": {
     "node": ">=18.0.0"
+  },
+  "config": {
+    "supportedGrocyVersion": "4.5.0"
   }
 }