mcp-grocy 1.9.0

package/build/tools/recipes/definitions.js

@@ -0,0 +1,191 @@
+import config from '../../config/environment.js';
+export const recipeToolDefinitions = [
+    {
+        name: 'get_recipes',
+        description: 'Get specific fields for all recipes from your Grocy instance. You must specify which fields to retrieve.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['id', 'name', 'description', 'base_servings', 'desired_servings', 'not_check_shoppinglist', 'type', 'picture_file_name', 'ingredients', 'instructions']
+                    },
+                    description: 'Array of field names to retrieve. For basic lookup use ["id", "name"]. For recipe planning use ["id", "name", "description", "base_servings"]. Available fields: id, name, description, base_servings, desired_servings, not_check_shoppinglist, type, picture_file_name, ingredients, instructions'
+                }
+            },
+            required: ['fields']
+        }
+    },
+    {
+        name: 'get_recipe_by_id',
+        description: 'Get a specific recipe by its ID from your Grocy instance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipeId: {
+                    type: 'number',
+                    description: 'ID of the recipe to retrieve'
+                }
+            },
+            required: ['recipeId']
+        }
+    },
+    {
+        name: 'create_recipe',
+        description: 'Create a new recipe in your Grocy instance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Name of the recipe'
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the recipe'
+                },
+                servings: {
+                    type: 'number',
+                    description: 'Number of servings (default: 1)',
+                    default: 1
+                },
+                baseServingAmount: {
+                    type: 'number',
+                    description: 'Base serving amount (default: 1)',
+                    default: 1
+                },
+                desiredServings: {
+                    type: 'number',
+                    description: 'Number of desired servings (default: 1)',
+                    default: 1
+                }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'get_recipe_fulfillment',
+        description: 'Get stock fulfillment information for a recipe. Use get_recipes first to find the recipe ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipeId: {
+                    type: 'number',
+                    description: 'ID of the recipe to check fulfillment for. Use get_recipes tool to find the correct recipe ID by name.'
+                },
+                servings: {
+                    type: 'number',
+                    description: 'Number of servings (default: 1)',
+                    default: 1
+                }
+            },
+            required: ['recipeId']
+        }
+    },
+    {
+        name: 'get_recipes_fulfillment',
+        description: 'Get fulfillment information for all recipes.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'consume_recipe',
+        description: 'Consume all ingredients needed for a recipe in your Grocy instance. Use get_recipes first to find the recipe ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipeId: {
+                    type: 'number',
+                    description: 'ID of the recipe to consume. Use get_recipes tool to find the correct recipe ID by name.'
+                },
+                servings: {
+                    type: 'number',
+                    description: 'Number of servings to consume (default: 1)',
+                    default: 1
+                }
+            },
+            required: ['recipeId']
+        }
+    },
+    {
+        name: 'add_recipe_products_to_shopping_list',
+        description: 'Add not fulfilled products of a recipe to the shopping list.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipeId: {
+                    type: 'string',
+                    description: 'ID of the recipe'
+                }
+            },
+            required: ['recipeId']
+        }
+    },
+    {
+        name: 'add_missing_products_to_shopping_list',
+        description: 'Add all missing products for a recipe to your shopping list. Use get_recipes first to find the recipe ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipeId: {
+                    type: 'number',
+                    description: 'ID of the recipe to add missing products for. Use get_recipes tool to find the correct recipe ID by name.'
+                },
+                servings: {
+                    type: 'number',
+                    description: 'Number of servings (default: 1)',
+                    default: 1
+                },
+                shoppingListId: {
+                    type: 'number',
+                    description: 'ID of the shopping list to add to (default: 1). Most users have only one shopping list with ID 1.',
+                    default: 1
+                }
+            },
+            required: ['recipeId']
+        }
+    },
+    (() => {
+        const { toolSubConfigs } = config.parseToolConfiguration();
+        const subConfigs = toolSubConfigs?.get('cooked_something');
+        const allowNoMealPlan = subConfigs?.get('allow_no_meal_plan') ?? false;
+        const allowAlreadyDone = subConfigs?.get('allow_meal_plan_entry_already_done') ?? false;
+        return {
+            name: 'cooked_something',
+            description: 'When the user cooks something this records it as done, consumes recipe ingredients, and creates labeled stock entries with custom portion sizes.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...(allowNoMealPlan ? {
+                        recipeId: {
+                            type: 'number',
+                            description: 'ID of the recipe to cook directly.'
+                        }
+                    } : {
+                        mealPlanEntryId: {
+                            type: 'number',
+                            description: `ID of the meal plan entry.${allowAlreadyDone ? '' : ' Note: This will fail if the meal plan entry is already marked as done (done=1).'}`
+                        }
+                    }),
+                    stockAmounts: {
+                        type: 'array',
+                        items: {
+                            type: 'number',
+                            minimum: 0.1
+                        },
+                        description: 'Array of serving amounts for each stock entry to create (e.g., [1, 2, 2] for 1 single serving + 2 double servings). Total will be used for ingredient consumption.'
+                    }
+                },
+                required: [
+                    ...(allowNoMealPlan ? ['recipeId'] : ['mealPlanEntryId']),
+                    'stockAmounts'
+                ]
+            }
+        };
+    })()
+];

package/build/tools/recipes/handlers.js

@@ -0,0 +1,258 @@
+import { BaseToolHandler } from '../base.js';
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import apiClient from '../../api/client.js';
+import { StockToolHandlers } from '../stock/handlers.js';
+export class RecipeToolHandlers extends BaseToolHandler {
+    stockHandlers = new StockToolHandlers();
+    getRecipes = async (args) => {
+        const { fields } = args || {};
+        if (!fields || !Array.isArray(fields) || fields.length === 0) {
+            throw new McpError(ErrorCode.InvalidParams, 'fields parameter is required and must be a non-empty array of field names');
+        }
+        try {
+            // Fetch recipes
+            const recipesResponse = await apiClient.get('/objects/recipes', { queryParams: { 'query[]': 'type=normal' } });
+            const recipes = recipesResponse.data;
+            if (!Array.isArray(recipes)) {
+                return this.createSuccessResult([]);
+            }
+            // Filter recipes to only include requested fields
+            const filteredRecipes = recipes.map((recipe) => {
+                const filtered = {};
+                fields.forEach(field => {
+                    if (recipe.hasOwnProperty(field)) {
+                        filtered[field] = recipe[field];
+                    }
+                });
+                return filtered;
+            });
+            return this.createSuccessResult(filteredRecipes);
+        }
+        catch (error) {
+            return this.createErrorResult(`Failed to get recipes: ${error.message}`);
+        }
+    };
+    getRecipeById = async (args) => {
+        const { recipeId } = args || {};
+        if (!recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required');
+        }
+        return this.handleApiCall(`/objects/recipes/${recipeId}`, 'Get recipe by ID');
+    };
+    createRecipe = async (args) => {
+        const { name, description = '', servings = 1, desiredServings = 1 } = args || {};
+        if (!name) {
+            throw new McpError(ErrorCode.InvalidParams, 'Recipe name is required');
+        }
+        const body = {
+            name,
+            description,
+            base_servings: servings,
+            desired_servings: desiredServings
+        };
+        return this.handleApiCall('/objects/recipes', 'Create recipe', {
+            method: 'POST',
+            body
+        });
+    };
+    getRecipeFulfillment = async (args) => {
+        const { recipeId, servings = 1 } = args || {};
+        if (!recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required');
+        }
+        return this.handleApiCall(`/recipes/${recipeId}/fulfillment`, 'Get recipe fulfillment', {
+            queryParams: servings !== 1 ? { servings: servings.toString() } : {}
+        });
+    };
+    getRecipesFulfillment = async () => {
+        return this.handleApiCall('/recipes/fulfillment', 'Get all recipes fulfillment');
+    };
+    consumeRecipe = async (args) => {
+        const { recipeId, servings = 1 } = args || {};
+        if (!recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required');
+        }
+        const body = {
+            recipe_id: recipeId,
+            servings
+        };
+        return this.handleApiCall(`/recipes/${recipeId}/consume`, 'Consume recipe', {
+            method: 'POST',
+            body
+        });
+    };
+    addRecipeProductsToShoppingList = async (args) => {
+        const { recipeId } = args || {};
+        if (!recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required');
+        }
+        return this.handleApiCall(`/recipes/${recipeId}/add-not-fulfilled-products-to-shoppinglist`, 'Add recipe products to shopping list', {
+            method: 'POST'
+        });
+    };
+    addMissingProductsToShoppingList = async (args) => {
+        const { recipeId, servings = 1, shoppingListId = 1 } = args || {};
+        if (!recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required');
+        }
+        const body = {
+            servings,
+            shopping_list_id: shoppingListId
+        };
+        return this.handleApiCall(`/recipes/${recipeId}/add-not-fulfilled-products-to-shoppinglist`, 'Add missing products to shopping list', {
+            method: 'POST',
+            body
+        });
+    };
+    markRecipeFromMealPlanEntryAsCooked = async (args, subConfigs) => {
+        const { mealPlanEntryId, recipeId, stockAmounts } = args || {};
+        // Sub-configuration options
+        const allowMealPlanEntryAlreadyDone = subConfigs?.get('allow_meal_plan_entry_already_done') ?? false;
+        const printLabels = subConfigs?.get('print_labels') ?? true;
+        const allowNoMealPlan = subConfigs?.get('allow_no_meal_plan') ?? false;
+        // Validate required parameters based on mode
+        if (!allowNoMealPlan && !mealPlanEntryId) {
+            throw new McpError(ErrorCode.InvalidParams, 'mealPlanEntryId is required when allow_no_meal_plan is false.');
+        }
+        if (allowNoMealPlan && !recipeId) {
+            throw new McpError(ErrorCode.InvalidParams, 'recipeId is required when allow_no_meal_plan is true.');
+        }
+        if (allowNoMealPlan && mealPlanEntryId) {
+            throw new McpError(ErrorCode.InvalidParams, 'mealPlanEntryId should not be provided when allow_no_meal_plan is true. Use recipeId instead.');
+        }
+        if (!stockAmounts || !Array.isArray(stockAmounts) || stockAmounts.length === 0) {
+            throw new McpError(ErrorCode.InvalidParams, 'stockAmounts is required and must be a non-empty array of serving amounts.');
+        }
+        // Validate all stock amounts are positive numbers
+        for (let i = 0; i < stockAmounts.length; i++) {
+            const amount = stockAmounts[i];
+            if (typeof amount !== 'number' || amount <= 0) {
+                throw new McpError(ErrorCode.InvalidParams, `stockAmounts[${i}] must be a positive number, got: ${amount}`);
+            }
+        }
+        const completedSteps = [];
+        let actualRecipeId;
+        let totalServings;
+        let mealPlanDate;
+        let mealplanShadow;
+        try {
+            if (allowNoMealPlan) {
+                // Direct recipe mode - no meal plan entry involved
+                actualRecipeId = recipeId;
+                totalServings = stockAmounts.reduce((sum, amount) => sum + amount, 0);
+                mealPlanDate = new Date().toISOString().split('T')[0];
+                mealplanShadow = `${mealPlanDate}#direct-recipe-${actualRecipeId}`;
+                completedSteps.push('Using direct recipe mode (no meal plan entry)');
+            }
+            else {
+                // Meal plan mode - traditional workflow
+                const mealPlanResponse = await apiClient.get(`/objects/meal_plan/${mealPlanEntryId}`);
+                const mealPlanEntry = mealPlanResponse.data;
+                if (!mealPlanEntry) {
+                    throw new Error(`Meal plan entry ${mealPlanEntryId} not found.`);
+                }
+                if (mealPlanEntry.done == 1 && !allowMealPlanEntryAlreadyDone) {
+                    throw new Error(`Meal plan entry ${mealPlanEntryId} is already marked as done. Cannot mark as cooked again.`);
+                }
+                actualRecipeId = mealPlanEntry.recipe_id;
+                totalServings = stockAmounts.reduce((sum, amount) => sum + amount, 0);
+                mealPlanDate = mealPlanEntry.day || new Date().toISOString().split('T')[0];
+                mealplanShadow = `${mealPlanDate}#${mealPlanEntryId}`;
+                // Mark the meal plan entry as done and update recipe_servings
+                await apiClient.put(`/objects/meal_plan/${mealPlanEntryId}`, {
+                    done: 1,
+                    recipe_servings: totalServings
+                });
+                completedSteps.push('Meal plan entry marked as done');
+            }
+            // For direct recipe mode, consume ingredients directly using the recipe ID
+            // For meal plan mode, try to find and use the shadow recipe
+            if (allowNoMealPlan) {
+                // Direct consumption using the recipe ID
+                await apiClient.post(`/recipes/${actualRecipeId}/consume`);
+                completedSteps.push('Recipe consumed directly');
+            }
+            else {
+                // Query for the mealplan shadow recipe by name
+                const shadowRecipeResponse = await apiClient.get('/objects/recipes', {
+                    queryParams: { 'query[]': `name=${mealplanShadow}` }
+                });
+                if (shadowRecipeResponse.data.length === 0) {
+                    throw new Error(`Mealplan shadow recipe '${mealplanShadow}' not found. Cannot consume ingredients.`);
+                }
+                const shadowRecipeId = shadowRecipeResponse.data[0].id;
+                // Consume ingredients using the shadow recipe ID
+                await apiClient.post(`/recipes/${shadowRecipeId}/consume`);
+                completedSteps.push('Recipe consumed via meal plan entry');
+            }
+            // Split stock entry and print labels for each portion
+            let stockEntries = { splitEntries: [], labelsPrinted: 0 };
+            const recipeResponse = await apiClient.get(`/objects/recipes/${actualRecipeId}`);
+            const recipe = recipeResponse.data;
+            if (recipe && recipe.product_id) {
+                // Get product details, quantity unit, and the most recent stock entry created by recipe consumption
+                const [productResponse, entriesResponse] = await Promise.all([
+                    apiClient.get(`/objects/products/${recipe.product_id}`),
+                    apiClient.get(`/stock/products/${recipe.product_id}/entries`, {
+                        queryParams: { order: 'row_created_timestamp:desc', limit: '1' }
+                    })
+                ]);
+                const product = productResponse.data;
+                // Get quantity unit info
+                let quantityUnit = null;
+                if (product.qu_id_stock) {
+                    try {
+                        const quantityUnitResponse = await apiClient.get(`/objects/quantity_units/${product.qu_id_stock}`);
+                        quantityUnit = quantityUnitResponse.data;
+                    }
+                    catch (error) {
+                        console.warn('Failed to fetch quantity unit:', error);
+                    }
+                }
+                // Helper function to get correct unit form
+                const getUnitForm = (amount) => {
+                    if (!quantityUnit)
+                        return '';
+                    // Handle edge cases
+                    if (!quantityUnit.name)
+                        return '';
+                    if (amount === 1)
+                        return quantityUnit.name;
+                    // Use plural form if available, otherwise fallback to singular
+                    return quantityUnit.name_plural || quantityUnit.name;
+                };
+                if (entriesResponse.data.length > 0) {
+                    const originalEntry = entriesResponse.data[0];
+                    // Use the generic stock splitting helper method
+                    stockEntries.splitEntries = await this.stockHandlers.splitStockEntry(originalEntry, stockAmounts, getUnitForm);
+                    // Print labels for all entries (if enabled)
+                    if (printLabels) {
+                        for (const entry of stockEntries.splitEntries) {
+                            try {
+                                await apiClient.get(`/stock/entry/${entry.stockId}/printlabel`);
+                                stockEntries.labelsPrinted++;
+                            }
+                            catch (error) {
+                                console.error(`Failed to print label for stock entry ${entry.stockId}:`, error);
+                            }
+                        }
+                    }
+                }
+            }
+            return this.createSuccessResult({
+                message: `Recipe ${actualRecipeId} cooked (${totalServings} servings consumed, ${stockEntries.splitEntries.length} stock entries created, ${stockEntries.labelsPrinted} labels printed)`,
+                stockEntries,
+            });
+        }
+        catch (error) {
+            return this.createErrorResult(`Failed to mark meal plan entry as cooked.`, {
+                completedSteps,
+                reason: error.message,
+                help: completedSteps.length > 0
+                    ? `Completed steps: ${completedSteps.join(', ')}. Check the error above and retry if needed.`
+                    : 'No steps completed. Verify the meal plan entry ID exists and is not already marked as done.'
+            });
+        }
+    };
+}
+export const recipeHandlers = new RecipeToolHandlers();

package/build/tools/recipes/index.js

@@ -0,0 +1,18 @@
+import { recipeToolDefinitions } from './definitions.js';
+import { recipeHandlers } from './handlers.js';
+export const recipeModule = {
+    definitions: recipeToolDefinitions,
+    handlers: {
+        get_recipes: recipeHandlers.getRecipes,
+        get_recipe_by_id: recipeHandlers.getRecipeById,
+        create_recipe: recipeHandlers.createRecipe,
+        get_recipe_fulfillment: recipeHandlers.getRecipeFulfillment,
+        get_recipes_fulfillment: recipeHandlers.getRecipesFulfillment,
+        consume_recipe: recipeHandlers.consumeRecipe,
+        add_recipe_products_to_shopping_list: recipeHandlers.addRecipeProductsToShoppingList,
+        add_missing_products_to_shopping_list: recipeHandlers.addMissingProductsToShoppingList,
+        cooked_something: recipeHandlers.markRecipeFromMealPlanEntryAsCooked
+    }
+};
+export * from './definitions.js';
+export * from './handlers.js';

package/build/tools/shopping/index.js

@@ -0,0 +1,107 @@
+import { BaseToolHandler } from '../base.js';
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+export const shoppingToolDefinitions = [
+    {
+        name: 'get_shopping_list',
+        description: 'Get your current shopping list items.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'add_shopping_list_item',
+        description: 'Add an item to your shopping list. Use get_products first to find the product ID you want to add.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                productId: {
+                    type: 'number',
+                    description: 'ID of the product to add. Use get_products tool to find the correct product ID by searching for the product name in the results.'
+                },
+                amount: {
+                    type: 'number',
+                    description: 'Amount to add to shopping list in the product\'s stock unit (e.g., 2 pieces, 1.5 kg, 750 ml). Ensure you know the product\'s unit before specifying amount. Default: 1',
+                    default: 1
+                },
+                shoppingListId: {
+                    type: 'number',
+                    description: 'ID of the shopping list to add to (default: 1). Most users have only one shopping list with ID 1.',
+                    default: 1
+                },
+                note: {
+                    type: 'string',
+                    description: 'Optional note for the shopping list item'
+                }
+            },
+            required: ['productId']
+        }
+    },
+    {
+        name: 'remove_shopping_list_item',
+        description: 'Remove an item from your shopping list. Use get_shopping_list first to find the shopping list item ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                shoppingListItemId: {
+                    type: 'number',
+                    description: 'ID of the shopping list item to remove. Use get_shopping_list tool to find the correct shopping list item ID by looking at the "id" field in the results.'
+                }
+            },
+            required: ['shoppingListItemId']
+        }
+    },
+    {
+        name: 'get_shopping_locations',
+        description: 'Get all shopping locations (stores) from your Grocy instance. Use this to find store IDs and names when working with tools that require storeId parameters.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    }
+];
+class ShoppingToolHandlers extends BaseToolHandler {
+    getShoppingList = async (args) => {
+        return this.handleApiCall('/objects/shopping_list', 'Get shopping list items');
+    };
+    addShoppingListItem = async (args) => {
+        const { productId, amount = 1, shoppingListId = 1, note = '' } = args || {};
+        if (!productId) {
+            throw new McpError(ErrorCode.InvalidParams, 'productId is required');
+        }
+        const body = {
+            product_id: productId,
+            amount,
+            shopping_list_id: shoppingListId,
+            note
+        };
+        return this.handleApiCall('/objects/shopping_list', 'Add shopping list item', {
+            method: 'POST',
+            body
+        });
+    };
+    removeShoppingListItem = async (args) => {
+        const { shoppingListItemId } = args || {};
+        if (!shoppingListItemId) {
+            throw new McpError(ErrorCode.InvalidParams, 'shoppingListItemId is required');
+        }
+        return this.handleApiCall(`/objects/shopping_list/${shoppingListItemId}`, 'Remove shopping list item', {
+            method: 'DELETE'
+        });
+    };
+    getShoppingLocations = async (args) => {
+        return this.handleApiCall('/objects/shopping_locations', 'Get all shopping locations');
+    };
+}
+const shoppingHandlers = new ShoppingToolHandlers();
+export const shoppingModule = {
+    definitions: shoppingToolDefinitions,
+    handlers: {
+        get_shopping_list: shoppingHandlers.getShoppingList,
+        add_shopping_list_item: shoppingHandlers.addShoppingListItem,
+        remove_shopping_list_item: shoppingHandlers.removeShoppingListItem,
+        get_shopping_locations: shoppingHandlers.getShoppingLocations
+    }
+};