@bojanrajkovic/mcp-paprika 1.0.0

package/dist/paprika/types.d.ts

@@ -0,0 +1,324 @@
+import { z } from "zod";
+import type { SetRequired } from "type-fest";
+export declare const RecipeUidSchema: z.ZodBranded<z.ZodString, "RecipeUid">;
+export declare const CategoryUidSchema: z.ZodBranded<z.ZodString, "CategoryUid">;
+export type RecipeUid = z.infer<typeof RecipeUidSchema>;
+export type CategoryUid = z.infer<typeof CategoryUidSchema>;
+export declare const RecipeEntrySchema: z.ZodObject<{
+    uid: z.ZodBranded<z.ZodString, "RecipeUid">;
+    hash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uid: string & z.BRAND<"RecipeUid">;
+    hash: string;
+}, {
+    uid: string;
+    hash: string;
+}>;
+export type RecipeEntry = z.infer<typeof RecipeEntrySchema>;
+export declare const RecipeStoredSchema: z.ZodObject<{
+    uid: z.ZodBranded<z.ZodString, "RecipeUid">;
+    hash: z.ZodString;
+    name: z.ZodString;
+    categories: z.ZodArray<z.ZodBranded<z.ZodString, "CategoryUid">, "many">;
+    ingredients: z.ZodString;
+    directions: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    notes: z.ZodNullable<z.ZodString>;
+    prepTime: z.ZodNullable<z.ZodString>;
+    cookTime: z.ZodNullable<z.ZodString>;
+    totalTime: z.ZodNullable<z.ZodString>;
+    servings: z.ZodNullable<z.ZodString>;
+    difficulty: z.ZodNullable<z.ZodString>;
+    rating: z.ZodNumber;
+    created: z.ZodString;
+    imageUrl: z.ZodNullable<z.ZodString>;
+    photo: z.ZodNullable<z.ZodString>;
+    photoHash: z.ZodNullable<z.ZodString>;
+    photoLarge: z.ZodNullable<z.ZodString>;
+    photoUrl: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodString>;
+    sourceUrl: z.ZodNullable<z.ZodString>;
+    onFavorites: z.ZodBoolean;
+    inTrash: z.ZodBoolean;
+    isPinned: z.ZodBoolean;
+    onGroceryList: z.ZodBoolean;
+    scale: z.ZodNullable<z.ZodString>;
+    nutritionalInfo: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    uid: string & z.BRAND<"RecipeUid">;
+    hash: string;
+    name: string;
+    categories: (string & z.BRAND<"CategoryUid">)[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    prepTime: string | null;
+    cookTime: string | null;
+    totalTime: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    imageUrl: string | null;
+    photo: string | null;
+    photoHash: string | null;
+    photoLarge: string | null;
+    photoUrl: string | null;
+    source: string | null;
+    sourceUrl: string | null;
+    onFavorites: boolean;
+    inTrash: boolean;
+    isPinned: boolean;
+    onGroceryList: boolean;
+    scale: string | null;
+    nutritionalInfo: string | null;
+}, {
+    uid: string;
+    hash: string;
+    name: string;
+    categories: string[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    prepTime: string | null;
+    cookTime: string | null;
+    totalTime: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    imageUrl: string | null;
+    photo: string | null;
+    photoHash: string | null;
+    photoLarge: string | null;
+    photoUrl: string | null;
+    source: string | null;
+    sourceUrl: string | null;
+    onFavorites: boolean;
+    inTrash: boolean;
+    isPinned: boolean;
+    onGroceryList: boolean;
+    scale: string | null;
+    nutritionalInfo: string | null;
+}>;
+export type Recipe = z.infer<typeof RecipeStoredSchema>;
+export declare const RecipeSchema: z.ZodEffects<z.ZodObject<{
+    uid: z.ZodBranded<z.ZodString, "RecipeUid">;
+    hash: z.ZodString;
+    name: z.ZodString;
+    categories: z.ZodArray<z.ZodBranded<z.ZodString, "CategoryUid">, "many">;
+    ingredients: z.ZodString;
+    directions: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    notes: z.ZodNullable<z.ZodString>;
+    prep_time: z.ZodNullable<z.ZodString>;
+    cook_time: z.ZodNullable<z.ZodString>;
+    total_time: z.ZodNullable<z.ZodString>;
+    servings: z.ZodNullable<z.ZodString>;
+    difficulty: z.ZodNullable<z.ZodString>;
+    rating: z.ZodNumber;
+    created: z.ZodString;
+    image_url: z.ZodNullable<z.ZodString>;
+    photo: z.ZodNullable<z.ZodString>;
+    photo_hash: z.ZodNullable<z.ZodString>;
+    photo_large: z.ZodNullable<z.ZodString>;
+    photo_url: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodString>;
+    source_url: z.ZodNullable<z.ZodString>;
+    on_favorites: z.ZodBoolean;
+    in_trash: z.ZodBoolean;
+    is_pinned: z.ZodBoolean;
+    on_grocery_list: z.ZodBoolean;
+    scale: z.ZodNullable<z.ZodString>;
+    nutritional_info: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    uid: string & z.BRAND<"RecipeUid">;
+    hash: string;
+    name: string;
+    categories: (string & z.BRAND<"CategoryUid">)[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    photo: string | null;
+    source: string | null;
+    scale: string | null;
+    prep_time: string | null;
+    cook_time: string | null;
+    total_time: string | null;
+    image_url: string | null;
+    photo_hash: string | null;
+    photo_large: string | null;
+    photo_url: string | null;
+    source_url: string | null;
+    on_favorites: boolean;
+    in_trash: boolean;
+    is_pinned: boolean;
+    on_grocery_list: boolean;
+    nutritional_info: string | null;
+}, {
+    uid: string;
+    hash: string;
+    name: string;
+    categories: string[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    photo: string | null;
+    source: string | null;
+    scale: string | null;
+    prep_time: string | null;
+    cook_time: string | null;
+    total_time: string | null;
+    image_url: string | null;
+    photo_hash: string | null;
+    photo_large: string | null;
+    photo_url: string | null;
+    source_url: string | null;
+    on_favorites: boolean;
+    in_trash: boolean;
+    is_pinned: boolean;
+    on_grocery_list: boolean;
+    nutritional_info: string | null;
+}>, {
+    uid: string & z.BRAND<"RecipeUid">;
+    hash: string;
+    name: string;
+    categories: (string & z.BRAND<"CategoryUid">)[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    prepTime: string | null;
+    cookTime: string | null;
+    totalTime: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    imageUrl: string | null;
+    photo: string | null;
+    photoHash: string | null;
+    photoLarge: string | null;
+    photoUrl: string | null;
+    source: string | null;
+    sourceUrl: string | null;
+    onFavorites: boolean;
+    inTrash: boolean;
+    isPinned: boolean;
+    onGroceryList: boolean;
+    scale: string | null;
+    nutritionalInfo: string | null;
+}, {
+    uid: string;
+    hash: string;
+    name: string;
+    categories: string[];
+    ingredients: string;
+    directions: string;
+    description: string | null;
+    notes: string | null;
+    servings: string | null;
+    difficulty: string | null;
+    rating: number;
+    created: string;
+    photo: string | null;
+    source: string | null;
+    scale: string | null;
+    prep_time: string | null;
+    cook_time: string | null;
+    total_time: string | null;
+    image_url: string | null;
+    photo_hash: string | null;
+    photo_large: string | null;
+    photo_url: string | null;
+    source_url: string | null;
+    on_favorites: boolean;
+    in_trash: boolean;
+    is_pinned: boolean;
+    on_grocery_list: boolean;
+    nutritional_info: string | null;
+}>;
+export declare const CategoryStoredSchema: z.ZodObject<{
+    uid: z.ZodBranded<z.ZodString, "CategoryUid">;
+    name: z.ZodString;
+    orderFlag: z.ZodNumber;
+    parentUid: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    uid: string & z.BRAND<"CategoryUid">;
+    name: string;
+    orderFlag: number;
+    parentUid: string | null;
+}, {
+    uid: string;
+    name: string;
+    orderFlag: number;
+    parentUid: string | null;
+}>;
+export type Category = z.infer<typeof CategoryStoredSchema>;
+export declare const CategorySchema: z.ZodEffects<z.ZodObject<{
+    uid: z.ZodBranded<z.ZodString, "CategoryUid">;
+    name: z.ZodString;
+    order_flag: z.ZodNumber;
+    parent_uid: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    uid: string & z.BRAND<"CategoryUid">;
+    name: string;
+    order_flag: number;
+    parent_uid: string | null;
+}, {
+    uid: string;
+    name: string;
+    order_flag: number;
+    parent_uid: string | null;
+}>, {
+    uid: string & z.BRAND<"CategoryUid">;
+    name: string;
+    orderFlag: number;
+    parentUid: string | null;
+}, {
+    uid: string;
+    name: string;
+    order_flag: number;
+    parent_uid: string | null;
+}>;
+export declare const AuthResponseSchema: z.ZodObject<{
+    result: z.ZodObject<{
+        token: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+    }, {
+        token: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    result: {
+        token: string;
+    };
+}, {
+    result: {
+        token: string;
+    };
+}>;
+export type AuthResponse = z.output<typeof AuthResponseSchema>;
+export type RecipeInput = SetRequired<Partial<Omit<Recipe, "uid" | "hash" | "created">>, "name" | "ingredients" | "directions">;
+export type SyncResult = {
+    readonly added: ReadonlyArray<Recipe>;
+    readonly updated: ReadonlyArray<Recipe>;
+    readonly removedUids: ReadonlyArray<string>;
+};
+export type DiffResult = {
+    readonly added: ReadonlyArray<string>;
+    readonly changed: ReadonlyArray<string>;
+    readonly removed: ReadonlyArray<string>;
+};

package/dist/paprika/types.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+// Branded UID schemas using z.string().brand()
+export const RecipeUidSchema = z.string().brand("RecipeUid");
+export const CategoryUidSchema = z.string().brand("CategoryUid");
+// Entry schemas for sync list endpoints
+export const RecipeEntrySchema = z.object({
+    uid: RecipeUidSchema,
+    hash: z.string(),
+});
+// StoredSchema — validates camelCase JSON read back from disk. No transform.
+export const RecipeStoredSchema = z.object({
+    uid: RecipeUidSchema,
+    hash: z.string(),
+    name: z.string(),
+    categories: z.array(CategoryUidSchema),
+    ingredients: z.string(),
+    directions: z.string(),
+    description: z.string().nullable(),
+    notes: z.string().nullable(),
+    prepTime: z.string().nullable(),
+    cookTime: z.string().nullable(),
+    totalTime: z.string().nullable(),
+    servings: z.string().nullable(),
+    difficulty: z.string().nullable(),
+    rating: z.number().int(),
+    created: z.string(),
+    imageUrl: z.string().nullable(),
+    photo: z.string().nullable(),
+    photoHash: z.string().nullable(),
+    photoLarge: z.string().nullable(),
+    photoUrl: z.string().nullable(),
+    source: z.string().nullable(),
+    sourceUrl: z.string().nullable(),
+    onFavorites: z.boolean(),
+    inTrash: z.boolean(),
+    isPinned: z.boolean(),
+    onGroceryList: z.boolean(),
+    scale: z.string().nullable(),
+    nutritionalInfo: z.string().nullable(),
+});
+// RecipeSchema — accepts snake_case wire format, transforms to camelCase Recipe.
+// The `: Recipe` annotation on the transform return ensures the compiler enforces
+// that RecipeSchema's output is always structurally identical to RecipeStoredSchema.
+export const RecipeSchema = z
+    .object({
+    uid: RecipeUidSchema,
+    hash: z.string(),
+    name: z.string(),
+    categories: z.array(CategoryUidSchema),
+    ingredients: z.string(),
+    directions: z.string(),
+    description: z.string().nullable(),
+    notes: z.string().nullable(),
+    prep_time: z.string().nullable(),
+    cook_time: z.string().nullable(),
+    total_time: z.string().nullable(),
+    servings: z.string().nullable(),
+    difficulty: z.string().nullable(),
+    rating: z.number().int(),
+    created: z.string(),
+    image_url: z.string().nullable(),
+    photo: z.string().nullable(),
+    photo_hash: z.string().nullable(),
+    photo_large: z.string().nullable(),
+    photo_url: z.string().nullable(),
+    source: z.string().nullable(),
+    source_url: z.string().nullable(),
+    on_favorites: z.boolean(),
+    in_trash: z.boolean(),
+    is_pinned: z.boolean(),
+    on_grocery_list: z.boolean(),
+    scale: z.string().nullable(),
+    nutritional_info: z.string().nullable(),
+})
+    .transform(({ image_url, prep_time, cook_time, total_time, photo_hash, photo_large, photo_url, source_url, on_favorites, in_trash, is_pinned, on_grocery_list, nutritional_info, ...rest }) => ({
+    ...rest,
+    imageUrl: image_url,
+    prepTime: prep_time,
+    cookTime: cook_time,
+    totalTime: total_time,
+    photoHash: photo_hash,
+    photoLarge: photo_large,
+    photoUrl: photo_url,
+    sourceUrl: source_url,
+    onFavorites: on_favorites,
+    inTrash: in_trash,
+    isPinned: is_pinned,
+    onGroceryList: on_grocery_list,
+    nutritionalInfo: nutritional_info,
+}));
+// StoredSchema — validates camelCase JSON read back from disk. No transform.
+export const CategoryStoredSchema = z.object({
+    uid: CategoryUidSchema,
+    name: z.string(),
+    orderFlag: z.number().int(),
+    parentUid: z.string().nullable(),
+});
+// CategorySchema — accepts snake_case wire format, transforms to camelCase Category.
+export const CategorySchema = z
+    .object({
+    uid: CategoryUidSchema,
+    name: z.string(),
+    order_flag: z.number().int(),
+    parent_uid: z.string().nullable(),
+})
+    .transform(({ order_flag, parent_uid, ...rest }) => ({
+    ...rest,
+    orderFlag: order_flag,
+    parentUid: parent_uid,
+}));
+// AuthResponseSchema - nested object, no transform needed
+export const AuthResponseSchema = z.object({
+    result: z.object({
+        token: z.string(),
+    }),
+});

package/dist/resources/recipes.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerRecipeResources(server: McpServer, ctx: ServerContext): void;

package/dist/resources/recipes.js

@@ -0,0 +1,34 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { recipeToMarkdown } from "../tools/helpers.js";
+export function registerRecipeResources(server, ctx) {
+    const template = new ResourceTemplate("paprika://recipe/{uid}", {
+        list: async () => {
+            const recipes = ctx.store.getAll();
+            return {
+                resources: recipes.map((recipe) => ({
+                    uri: `paprika://recipe/${recipe.uid}`,
+                    name: recipe.name,
+                    mimeType: "text/markdown",
+                })),
+            };
+        },
+    });
+    server.registerResource("recipes", template, { description: "Paprika recipes accessible by UID" }, async (uri, variables) => {
+        const uid = variables["uid"];
+        const recipe = ctx.store.get(uid);
+        if (!recipe) {
+            throw new Error(`Recipe not found: ${uid}`);
+        }
+        const categoryNames = ctx.store.resolveCategories(recipe.categories);
+        const content = `**UID:** \`${uid}\`\n\n${recipeToMarkdown(recipe, categoryNames)}`;
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "text/markdown",
+                    text: content,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/categories.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerCategoryTools(server: McpServer, ctx: ServerContext): void;

package/dist/tools/categories.js

@@ -0,0 +1,38 @@
+import { coldStartGuard, textResult } from "./helpers.js";
+export function registerCategoryTools(server, ctx) {
+    server.registerTool("list_categories", {
+        description: "List all recipe categories with the number of recipes in each. Categories are sorted alphabetically.",
+        inputSchema: {},
+    }, async (_args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const categories = ctx.store.getAllCategories();
+            if (categories.length === 0) {
+                return textResult("No categories found in your recipe library.");
+            }
+            const recipes = ctx.store.getAll();
+            // Initialize every category with count 0 so categories with no recipes
+            // still appear in the output (AC4.3).
+            const countMap = new Map();
+            for (const category of categories) {
+                countMap.set(category.uid, 0);
+            }
+            // Increment count for each non-trashed recipe's categories.
+            // getAll() already excludes trashed recipes.
+            for (const recipe of recipes) {
+                for (const uid of recipe.categories) {
+                    const current = countMap.get(uid) ?? 0;
+                    countMap.set(uid, current + 1);
+                }
+            }
+            const sorted = categories.toSorted((a, b) => a.name.localeCompare(b.name));
+            return textResult(formatCategoryList(sorted, countMap));
+        }, (guard) => guard);
+    });
+}
+function formatCategoryList(categories, countMap) {
+    const lines = categories.map((c) => {
+        const count = countMap.get(c.uid) ?? 0;
+        return `- **${c.name}** (${String(count)} ${count === 1 ? "recipe" : "recipes"})`;
+    });
+    return `## Recipe Categories\n\n${lines.join("\n")}`;
+}

package/dist/tools/create.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerCreateTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/create.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { RecipeUidSchema } from "../paprika/types.js";
+import { coldStartGuard, commitRecipe, recipeToMarkdown, resolveCategoryNames, textResult } from "./helpers.js";
+export function registerCreateTool(server, ctx) {
+    server.registerTool("create_recipe", {
+        description: "Create a new recipe in the Paprika account.",
+        inputSchema: {
+            name: z.string().describe("Recipe name"),
+            ingredients: z.string().describe("Ingredients list"),
+            directions: z.string().describe("Cooking directions"),
+            description: z.string().optional().describe("Brief description"),
+            notes: z.string().optional().describe("Additional notes"),
+            servings: z.string().optional().describe("Number of servings"),
+            prepTime: z.string().optional().describe("Prep time (e.g. '15 min')"),
+            cookTime: z.string().optional().describe("Cook time (e.g. '30 min')"),
+            totalTime: z.string().optional().describe("Total time (e.g. '45 min')"),
+            categories: z.array(z.string()).optional().describe("Category display names (case-insensitive)"),
+            source: z.string().optional().describe("Source name"),
+            sourceUrl: z.string().optional().describe("Source URL"),
+            difficulty: z.string().optional().describe("Difficulty level"),
+            rating: z.number().int().min(0).max(5).optional().describe("Rating 0–5 (default: 0)"),
+            nutritionalInfo: z.string().optional().describe("Nutritional information"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            // Resolve category names → UIDs (AC2.4, AC2.7)
+            const { uids: categories, unknown: unknownCategories } = args.categories && args.categories.length > 0
+                ? resolveCategoryNames(ctx.store.getAllCategories(), args.categories)
+                : { uids: [], unknown: [] };
+            const warnings = unknownCategories.map((name) => `Warning: category "${name}" not found and was skipped.`);
+            // Build the full Recipe object — all 28 fields required by the type
+            // hash: "" — Paprika API returns the real hash in the saveRecipe response
+            const uid = RecipeUidSchema.parse(crypto.randomUUID());
+            const newRecipe = {
+                uid,
+                hash: "",
+                name: args.name,
+                categories,
+                ingredients: args.ingredients,
+                directions: args.directions,
+                description: args.description ?? null, // AC2.3: omitted → null
+                notes: args.notes ?? null,
+                prepTime: args.prepTime ?? null,
+                cookTime: args.cookTime ?? null,
+                totalTime: args.totalTime ?? null,
+                servings: args.servings ?? null,
+                difficulty: args.difficulty ?? null,
+                rating: args.rating ?? 0, // AC2.3: omitted → 0 (Paprika's default)
+                created: new Date().toISOString(),
+                imageUrl: "",
+                photo: null,
+                photoHash: null,
+                photoLarge: null,
+                photoUrl: null,
+                source: args.source ?? null,
+                sourceUrl: args.sourceUrl ?? null,
+                onFavorites: false,
+                inTrash: false,
+                isPinned: false,
+                onGroceryList: false,
+                scale: null,
+                nutritionalInfo: args.nutritionalInfo ?? null,
+            };
+            let saved;
+            try {
+                saved = await ctx.client.saveRecipe(newRecipe); // AC2.5
+                await commitRecipe(ctx, saved); // AC2.5, AC2.6
+            }
+            catch (error) {
+                // AC2.8: store/cache not updated — commitRecipe not reached
+                return textResult(`Failed to create recipe: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const categoryNames = ctx.store.resolveCategories(saved.categories);
+            const markdown = recipeToMarkdown(saved, categoryNames);
+            const prefix = warnings.length > 0 ? warnings.join("\n") + "\n\n" : "";
+            return textResult(prefix + markdown);
+        }, (guard) => guard);
+    });
+}

package/dist/tools/delete.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerDeleteTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/delete.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { RecipeUidSchema } from "../paprika/types.js";
+import { coldStartGuard, commitRecipe, textResult } from "./helpers.js";
+export function registerDeleteTool(server, ctx) {
+    server.registerTool("delete_recipe", {
+        description: "Soft-delete a recipe by UID, moving it to the Paprika trash. " +
+            "This operation is reversible — trashed recipes can be recovered in the Paprika app. " +
+            "Requires an exact UID; fuzzy title matching is not supported to prevent accidental deletion.",
+        inputSchema: {
+            uid: z.string().describe("Recipe UID to delete"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const uid = RecipeUidSchema.parse(args.uid);
+            const recipe = ctx.store.get(uid);
+            if (!recipe) {
+                return textResult(`No recipe found with UID "${args.uid}".`);
+            }
+            if (recipe.inTrash) {
+                return textResult(`Recipe "${recipe.name}" is already in the trash.`);
+            }
+            const trashed = { ...recipe, inTrash: true };
+            try {
+                const saved = await ctx.client.saveRecipe(trashed);
+                await commitRecipe(ctx, saved);
+            }
+            catch (error) {
+                return textResult(`Failed to delete recipe: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return textResult(`Recipe "${recipe.name}" has been moved to the trash.`);
+        }, (guard) => guard);
+    });
+}

package/dist/tools/discover.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+import type { VectorStore } from "../features/vector-store.js";
+export declare function registerDiscoverTool(server: McpServer, ctx: ServerContext, vectorStore: VectorStore): void;