mcp-grocy 2.5.0 → 2.7.0

package/build/tools/recipes/handlers.js

@@ -1,477 +0,0 @@
-/**
- * Simplified recipe tool handlers
- * Demonstrates the new simplified pattern
- */
-import { BaseToolHandler } from '../base.js';
-import { InventoryToolHandlers } from '../inventory/handlers.js';
-import { ValidationError } from '../../utils/errors.js';
-const RECIPES_COOKING_COMPLETE_TOOL = 'recipes_cooking_complete';
-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
-     */
-    getRecipes = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { fields } = args || {};
-            // Validate required parameters
-            this.validateRequired({ fields }, ['fields']);
-            const fieldList = this.parseArrayParam(fields, 'fields');
-            // Fetch recipes
-            const recipes = await this.apiCall('/objects/recipes', 'GET', undefined, {
-                queryParams: { 'query[]': 'type=normal' },
-            });
-            if (!Array.isArray(recipes)) {
-                return this.createSuccess([]);
-            }
-            // Filter to requested fields
-            const filteredRecipes = this.filterFields(recipes, fieldList);
-            return this.createSuccess(filteredRecipes);
-        });
-    };
-    /**
-     * Get recipe by ID
-     */
-    getRecipeById = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const recipe = await this.apiCall(`/objects/recipes/${id}`);
-            return this.createSuccess(recipe);
-        });
-    };
-    /**
-     * Get recipe fulfillment information
-     */
-    getRecipeFulfillment = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const fulfillment = await this.apiCall(`/recipes/${id}/fulfillment`);
-            return this.createSuccess(fulfillment);
-        });
-    };
-    /**
-     * Add recipe to meal plan
-     */
-    addRecipeToMealPlan = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId, day, mealType } = args || {};
-            this.validateRequired({ recipeId, day }, ['recipeId', 'day']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const mealPlanData = {
-                day,
-                type: mealType || 'lunch',
-                recipe_id: id,
-            };
-            const result = await this.apiCall('/objects/meal_plan', 'POST', mealPlanData);
-            return this.createSuccess(result, 'Recipe added to meal plan successfully');
-        });
-    };
-    /**
-     * Cook recipe - consume ingredients from stock
-     */
-    cookRecipe = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId, servings } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const servingCount = this.parseNumberParam(servings, 'servings', false) || 1;
-            // Get recipe details first
-            const recipe = await this.apiCall(`/objects/recipes/${id}`);
-            // Cook the recipe
-            const cookData = {
-                recipe_id: id,
-                servings: servingCount,
-            };
-            const result = await this.apiCall('/recipes/cook', 'POST', cookData);
-            return this.createSuccess({
-                recipe: recipe.name,
-                servings: servingCount,
-                result,
-            }, `Recipe "${recipe.name}" cooked successfully`);
-        });
-    };
-    /**
-     * Get recipe nutrition information
-     */
-    getRecipeNutrition = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const nutrition = await this.apiCall(`/recipes/${id}/nutrition`);
-            return this.createSuccess(nutrition);
-        });
-    };
-    /**
-     * Search recipes by name or ingredients
-     */
-    searchRecipes = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { query, fields } = args || {};
-            this.validateRequired({ query }, ['query']);
-            const fieldList = this.parseArrayParam(fields || ['id', 'name'], 'fields');
-            // Get all recipes and filter locally
-            // Note: This could be optimized with server-side search if Grocy supports it
-            const recipes = await this.apiCall('/objects/recipes', 'GET', undefined, {
-                queryParams: { 'query[]': 'type=normal' },
-            });
-            if (!Array.isArray(recipes)) {
-                return this.createSuccess([]);
-            }
-            const searchTerm = query.toLowerCase();
-            const filtered = recipes.filter((recipe) => recipe.name?.toLowerCase().includes(searchTerm) ||
-                recipe.description?.toLowerCase().includes(searchTerm));
-            const result = this.filterFields(filtered, fieldList);
-            return this.createSuccess(result);
-        });
-    };
-    // ==================== MEAL PLANNING METHODS ====================
-    /**
-     * Get meal plan data with context
-     */
-    getMealPlan = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { date, weekly } = args || {};
-            // Date parameter is mandatory
-            this.validateRequired({ date }, ['date']);
-            const targetDate = new Date(date);
-            if (isNaN(targetDate.getTime())) {
-                throw new ValidationError('Invalid date format. Use YYYY-MM-DD.', 'getMealPlan');
-            }
-            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);
-                }
-            }
-            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');
-        });
-    };
-    /**
-     * Get meal plan sections
-     */
-    getMealPlanSections = async () => {
-        return this.executeToolHandler(async () => {
-            const result = await this.apiCall('/objects/meal_plan_sections');
-            return this.createSuccess(result, 'Meal plan sections retrieved successfully');
-        });
-    };
-    /**
-     * Delete recipe from meal plan
-     */
-    deleteRecipeFromMealPlan = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { mealPlanEntryId } = args || {};
-            this.validateRequired({ mealPlanEntryId }, ['mealPlanEntryId']);
-            const result = await this.apiCall(`/objects/meal_plan/${mealPlanEntryId}`, 'DELETE');
-            return this.createSuccess(result, 'Recipe deleted from meal plan successfully');
-        });
-    };
-    // ==================== RECIPE CREATION ====================
-    /**
-     * Create a new recipe
-     */
-    printRecipeLabel = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const result = await this.apiCall(`/recipes/${recipeId}/printlabel`);
-            return this.createSuccess(result, 'Recipe label printed successfully');
-        });
-    };
-    createRecipe = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { name, description, baseServings, instructions } = args || {};
-            this.validateRequired({ name }, ['name']);
-            const recipeData = {
-                name,
-                description: description || '',
-                base_servings: baseServings || 1,
-                type: 'normal',
-                instructions: instructions || '',
-            };
-            const result = await this.apiCall('/objects/recipes', 'POST', recipeData);
-            return this.createSuccess(result, `Recipe "${name}" created successfully`);
-        });
-    };
-    // ==================== RECIPE FULFILLMENT ====================
-    /**
-     * Get fulfillment status for all recipes
-     */
-    getAllRecipeFulfillment = async () => {
-        return this.executeToolHandler(async () => {
-            const fulfillment = await this.apiCall('/recipes/fulfillment');
-            return this.createSuccess(fulfillment);
-        });
-    };
-    // ==================== RECIPE CONSUMPTION ====================
-    /**
-     * Consume/cook a recipe (simple version)
-     */
-    consumeRecipe = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId, servings } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const servingCount = this.parseNumberParam(servings, 'servings', false) || 1;
-            const consumeData = {
-                recipe_id: id,
-                servings: servingCount,
-            };
-            const result = await this.apiCall('/recipes/consume', 'POST', consumeData);
-            return this.createSuccess(result, `Recipe consumed (${servingCount} servings)`);
-        });
-    };
-    // ==================== RECIPE SHOPPING INTEGRATION ====================
-    /**
-     * Add all products from a recipe to shopping list
-     */
-    addAllProductsToShopping = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const result = await this.apiCall(`/recipes/${id}/add-all-ingredients-to-shopping-list`, 'POST');
-            return this.createSuccess(result, 'All recipe products added to shopping list');
-        });
-    };
-    /**
-     * Add missing products from a recipe to shopping list
-     */
-    addMissingProductsToShopping = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { recipeId } = args || {};
-            this.validateRequired({ recipeId }, ['recipeId']);
-            const id = this.parseNumberParam(recipeId, 'recipeId');
-            const result = await this.apiCall(`/recipes/${id}/add-not-fulfilled-products-to-shopping-list`, 'POST');
-            return this.createSuccess(result, 'Missing recipe products added to shopping list');
-        });
-    };
-    // ==================== COOKING METHODS ====================
-    /**
-     * Mark recipe from meal plan entry as cooked - modernized version
-     */
-    cookedSomething = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { mealPlanEntryId, recipeId, stockAmounts } = args || {};
-            // Get configuration from unified config
-            const { config } = await import('../../config/index.js');
-            const { toolSubConfigs } = config.parseToolConfiguration();
-            const subConfigs = toolSubConfigs?.get(RECIPES_COOKING_COMPLETE_TOOL);
-            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 parameters based on configuration
-            if (!allowNoMealPlan && !mealPlanEntryId) {
-                throw new ValidationError('mealPlanEntryId is required when allow_no_meal_plan is false.', 'recipes_cooking_complete');
-            }
-            if (allowNoMealPlan && !recipeId) {
-                throw new ValidationError('recipeId is required when allow_no_meal_plan is true.', 'recipes_cooking_complete');
-            }
-            if (allowNoMealPlan && mealPlanEntryId) {
-                throw new ValidationError('mealPlanEntryId should not be provided when allow_no_meal_plan is true. Use recipeId instead.', 'recipes_cooking_complete');
-            }
-            this.validateRequired({ stockAmounts }, ['stockAmounts']);
-            if (!Array.isArray(stockAmounts) || stockAmounts.length === 0) {
-                throw new ValidationError('stockAmounts must be a non-empty array of serving amounts.', 'recipes_cooking_complete');
-            }
-            // 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 ValidationError(`stockAmounts[${i}] must be a positive number, got: ${amount}`, 'recipes_cooking_complete');
-                }
-            }
-            const completedSteps = [];
-            let actualRecipeId;
-            let totalServings;
-            let mealPlanDate;
-            let mealplanShadow;
-            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 mealPlanEntry = await this.apiCall(`/objects/meal_plan/${mealPlanEntryId}`);
-                if (!mealPlanEntry) {
-                    throw new ValidationError(`Meal plan entry ${mealPlanEntryId} not found.`, 'recipes_cooking_complete');
-                }
-                if (mealPlanEntry.done == 1 && !allowMealPlanEntryAlreadyDone) {
-                    throw new ValidationError(`Meal plan entry ${mealPlanEntryId} is already marked as done. Cannot mark as cooked again.`, 'recipes_cooking_complete');
-                }
-                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 this.apiCall(`/objects/meal_plan/${mealPlanEntryId}`, 'PUT', {
-                    done: 1,
-                    recipe_servings: totalServings,
-                });
-                completedSteps.push('Meal plan entry marked as done');
-            }
-            // Consume recipe ingredients
-            if (allowNoMealPlan) {
-                // Direct consumption using the recipe ID
-                await this.apiCall(`/recipes/${actualRecipeId}/consume`, 'POST');
-                completedSteps.push('Recipe consumed directly');
-            }
-            else {
-                // Query for the mealplan shadow recipe by name
-                const shadowRecipes = await this.apiCall('/objects/recipes', 'GET', undefined, {
-                    queryParams: { 'query[]': `name=${mealplanShadow}` },
-                });
-                if (!Array.isArray(shadowRecipes) || shadowRecipes.length === 0) {
-                    throw new ValidationError(`Mealplan shadow recipe '${mealplanShadow}' not found. Cannot consume ingredients.`, 'recipes_cooking_complete');
-                }
-                const shadowRecipeId = shadowRecipes[0].id;
-                // Consume ingredients using the shadow recipe ID
-                await this.apiCall(`/recipes/${shadowRecipeId}/consume`, 'POST');
-                completedSteps.push('Recipe consumed via meal plan entry');
-            }
-            // Handle stock entry splitting and label printing
-            const stockEntries = { splitEntries: [], labelsPrinted: 0 };
-            const recipe = await this.apiCall(`/objects/recipes/${actualRecipeId}`);
-            if (recipe && recipe.product_id) {
-                // Get product details and most recent stock entry
-                const [product, entries] = await Promise.all([
-                    this.apiCall(`/objects/products/${recipe.product_id}`),
-                    this.apiCall(`/stock/products/${recipe.product_id}/entries`, 'GET', undefined, {
-                        queryParams: { order: 'row_created_timestamp:desc', limit: '1' },
-                    }),
-                ]);
-                // Get quantity unit info
-                let quantityUnit = null;
-                if (product.qu_id_stock) {
-                    try {
-                        quantityUnit = await this.apiCall(`/objects/quantity_units/${product.qu_id_stock}`);
-                    }
-                    catch (error) {
-                        console.warn('Failed to fetch quantity unit:', error);
-                    }
-                }
-                // Helper function to get correct unit form
-                const getUnitForm = (amount) => {
-                    if (!quantityUnit || !quantityUnit.name)
-                        return '';
-                    if (amount === 1)
-                        return quantityUnit.name;
-                    return quantityUnit.name_plural || quantityUnit.name;
-                };
-                if (Array.isArray(entries) && entries.length > 0) {
-                    const originalEntry = entries[0];
-                    // Use the real stock splitting functionality
-                    stockEntries.splitEntries = await this.inventoryHandlers.splitStockEntry(originalEntry, stockAmounts, getUnitForm);
-                    // Print labels for all entries (if enabled)
-                    if (printLabels) {
-                        for (const entry of stockEntries.splitEntries) {
-                            try {
-                                await this.apiCall(`/stock/entry/${originalEntry.id}/printlabel`);
-                                stockEntries.labelsPrinted++;
-                            }
-                            catch (error) {
-                                console.error(`Failed to print label for stock entry ${entry.stockId}:`, error);
-                            }
-                        }
-                    }
-                }
-            }
-            return this.createSuccess({
-                message: `Recipe ${actualRecipeId} cooked (${totalServings} servings consumed, ${stockEntries.splitEntries.length} stock entries created, ${stockEntries.labelsPrinted} labels printed)`,
-                stockEntries,
-                completedSteps,
-            });
-        });
-    };
-}

package/build/tools/recipes/index.js

@@ -1,33 +0,0 @@
-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 = {
-    definitions: recipeToolDefinitions,
-    handlers: {
-        // Recipe Management
-        recipes_management_get: handlers.getRecipes,
-        recipes_management_get_by_id: handlers.getRecipeById,
-        recipes_management_create: handlers.createRecipe,
-        recipes_management_print_label: handlers.printRecipeLabel,
-        // Recipe Fulfillment
-        recipes_fulfillment_get: handlers.getRecipeFulfillment,
-        recipes_fulfillment_get_all: handlers.getAllRecipeFulfillment,
-        // Meal Planning
-        recipes_mealplan_get: handlers.getMealPlan,
-        recipes_mealplan_get_sections: handlers.getMealPlanSections,
-        recipes_mealplan_add_recipe: handlers.addRecipeToMealPlan,
-        recipes_mealplan_delete_entry: handlers.deleteRecipeFromMealPlan,
-        // Recipe Cooking
-        recipes_cooking_consume: handlers.consumeRecipe,
-        recipes_cooking_complete: handlers.cookedSomething,
-        // 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/recipes/validations.js

@@ -1,29 +0,0 @@
-/**
- * Recipe tools sub-configuration validation functions
- */
-import { ValidationHelpers } from '../validation-helpers.js';
-import { ValidationError } from '../../utils/errors.js';
-/**
- * Validation function for complete tool sub-configurations
- */
-export const validateCompleteSubConfigs = (subConfigs) => {
-    const allowMealPlanEntryAlreadyDone = subConfigs.get('allow_meal_plan_entry_already_done');
-    const allowNoMealPlan = subConfigs.get('allow_no_meal_plan');
-    const printLabels = subConfigs.get('print_labels');
-    // Validate types
-    ValidationHelpers.validateBoolean(allowMealPlanEntryAlreadyDone, 'allow_meal_plan_entry_already_done');
-    ValidationHelpers.validateBoolean(allowNoMealPlan, 'allow_no_meal_plan');
-    ValidationHelpers.validateBoolean(printLabels, 'print_labels');
-    // Business logic validation
-    if (allowNoMealPlan && allowMealPlanEntryAlreadyDone) {
-        throw new ValidationError('allow_no_meal_plan and allow_meal_plan_entry_already_done cannot both be true - they are mutually exclusive modes', 'complete sub-config');
-    }
-    // Check for unknown options
-    const knownOptions = new Set([
-        'allow_meal_plan_entry_already_done',
-        'allow_no_meal_plan',
-        'print_labels',
-        'ack_token',
-    ]);
-    ValidationHelpers.validateKnownOptions(subConfigs, knownOptions, 'complete');
-};

package/build/tools/shopping/definitions.js

@@ -1,73 +0,0 @@
-export const shoppingToolDefinitions = [
-    {
-        name: 'shopping_list_get',
-        description: '[SHOPPING/LIST] Get your current shopping list items.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: 'shopping_list_add_item',
-        description: '[SHOPPING/LIST] Add an item to your shopping list. Use inventory_products_get 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 inventory_products_get 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: 'shopping_list_remove_item',
-        description: '[SHOPPING/LIST] Remove an item from your shopping list. Use shopping_list_get 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 shopping_list_get tool to find the correct shopping list item ID by looking at the "id" field in the results.',
-                },
-            },
-            required: ['shoppingListItemId'],
-        },
-    },
-    {
-        name: 'shopping_locations_get',
-        description: '[SHOPPING/LOCATIONS] Get **retail store / shop** locations where you buy groceries (Grocy shopping locations). NOT pantry or home storage—use system_locations_get for storage location IDs (locationId). Use shopping_locations_get for storeId when adding shopping-list items or store-specific workflows.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: 'shopping_list_print_thermal',
-        description: '[SHOPPING/PRINTING] Print the shopping list with a thermal printer. This creates a physical shopping list for store visits.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-];

package/build/tools/shopping/handlers.js

@@ -1,43 +0,0 @@
-import { BaseToolHandler } from '../base.js';
-export class ShoppingToolHandlers extends BaseToolHandler {
-    getShoppingList = async () => {
-        return this.executeToolHandler(async () => {
-            const result = await this.apiCall('/objects/shopping_list');
-            return this.createSuccess(result, 'Shopping list retrieved successfully');
-        });
-    };
-    addShoppingListItem = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { productId, amount = 1, shoppingListId = 1, note = '' } = args || {};
-            this.validateRequired({ productId }, ['productId']);
-            const body = {
-                product_id: productId,
-                amount,
-                shopping_list_id: shoppingListId,
-                note,
-            };
-            const result = await this.apiCall('/objects/shopping_list', 'POST', body);
-            return this.createSuccess(result, 'Shopping list item added successfully');
-        });
-    };
-    removeShoppingListItem = async (args) => {
-        return this.executeToolHandler(async () => {
-            const { shoppingListItemId } = args || {};
-            this.validateRequired({ shoppingListItemId }, ['shoppingListItemId']);
-            const result = await this.apiCall(`/objects/shopping_list/${shoppingListItemId}`, 'DELETE');
-            return this.createSuccess(result, 'Shopping list item removed successfully');
-        });
-    };
-    getShoppingLocations = async () => {
-        return this.executeToolHandler(async () => {
-            const result = await this.apiCall('/objects/shopping_locations');
-            return this.createSuccess(result, 'Shopping locations retrieved successfully');
-        });
-    };
-    printShoppingListThermal = async () => {
-        return this.executeToolHandler(async () => {
-            const result = await this.apiCall('/print/shoppinglist/thermal');
-            return this.createSuccess(result, 'Shopping list sent to thermal printer successfully');
-        });
-    };
-}

package/build/tools/shopping/index.js

@@ -1,14 +0,0 @@
-import { shoppingToolDefinitions } from './definitions.js';
-import { ShoppingToolHandlers } from './handlers.js';
-const handlers = new ShoppingToolHandlers();
-export const shoppingModule = {
-    definitions: shoppingToolDefinitions,
-    handlers: {
-        shopping_list_get: handlers.getShoppingList,
-        shopping_list_add_item: handlers.addShoppingListItem,
-        shopping_list_remove_item: handlers.removeShoppingListItem,
-        shopping_locations_get: handlers.getShoppingLocations,
-        shopping_list_print_thermal: handlers.printShoppingListThermal,
-    },
-};
-export * from './definitions.js';