@bojanrajkovic/mcp-paprika 1.3.0 → 1.4.0-beta.0

package/README.md

@@ -4,10 +4,10 @@ An [MCP](https://modelcontextprotocol.io/) server for [Paprika](https://www.papr
 
 ## Features
 
-- **14 tools** for recipe and pantry management — search, filter, CRUD, categories, pagination, pantry inventory
+- **26 tools** for recipe, pantry, and grocery management — search, filter, CRUD, categories, pagination, pantry inventory, aisles, grocery list management, grocery item management
 - **Semantic search** via `discover_recipes` — find recipes by natural language description using any OpenAI-compatible embedding provider
 - **Background sync** — keeps your local cache in sync with Paprika's cloud
-- **MCP resources** — expose recipes as `paprika://recipe/{uid}` and pantry items as `paprika://pantry/{uid}` resources
+- **MCP resources** — expose recipes as `paprika://recipe/{uid}` and grocery lists as `paprika://grocery-list/{uid}` resources
 - **Two transports** — stdio (default, for CLI clients) and Streamable HTTP (for mobile/web clients)
 - **Container image** — `Dockerfile` ships a distroless runtime ready for self-hosting
 

package/dist/auth/types.d.ts

@@ -240,13 +240,13 @@ export declare const IdentitySchema: z.ZodObject<{
     sub: z.ZodString;
     source: z.ZodEnum<["email", "sub"]>;
 }, "strip", z.ZodTypeAny, {
-    email: string | null;
+    source: "sub" | "email";
     sub: string;
-    source: "email" | "sub";
-}, {
     email: string | null;
+}, {
+    source: "sub" | "email";
     sub: string;
-    source: "email" | "sub";
+    email: string | null;
 }>;
 /**
  * RFC 8707 resource indicator — must be a fully-qualified URL or an explicit empty
@@ -264,13 +264,13 @@ export declare const OAuthTokenSchema: z.ZodObject<{
         sub: z.ZodString;
         source: z.ZodEnum<["email", "sub"]>;
     }, "strip", z.ZodTypeAny, {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
-    }, {
         email: string | null;
+    }, {
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     }>;
     resource: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
     expiresAt: z.ZodNumber;
@@ -282,9 +282,9 @@ export declare const OAuthTokenSchema: z.ZodObject<{
     scope: string;
     createdAt: number;
     identity: {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     };
     tokenHash: string;
     kind: "access" | "refresh";
@@ -296,9 +296,9 @@ export declare const OAuthTokenSchema: z.ZodObject<{
     scope: string;
     createdAt: number;
     identity: {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     };
     tokenHash: string;
     kind: "access" | "refresh";
@@ -353,13 +353,13 @@ export declare const AuthCodeStateSchema: z.ZodObject<{
         sub: z.ZodString;
         source: z.ZodEnum<["email", "sub"]>;
     }, "strip", z.ZodTypeAny, {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
-    }, {
         email: string | null;
+    }, {
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     }>;
 }, "strip", z.ZodTypeAny, {
     clientId: string;
@@ -370,9 +370,9 @@ export declare const AuthCodeStateSchema: z.ZodObject<{
     scope: string;
     createdAt: number;
     identity: {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     };
 }, {
     clientId: string;
@@ -383,9 +383,9 @@ export declare const AuthCodeStateSchema: z.ZodObject<{
     scope: string;
     createdAt: number;
     identity: {
-        email: string | null;
+        source: "sub" | "email";
         sub: string;
-        source: "email" | "sub";
+        email: string | null;
     };
 }>;
 export type AuthCodeState = z.infer<typeof AuthCodeStateSchema>;
@@ -423,13 +423,13 @@ export declare const AuthInfoExtraSchema: z.ZodObject<{
     sub: z.ZodString;
     source: z.ZodEnum<["email", "sub"]>;
 }, "strip", z.ZodTypeAny, {
-    email: string | null;
+    source: "sub" | "email";
     sub: string;
-    source: "email" | "sub";
-}, {
     email: string | null;
+}, {
+    source: "sub" | "email";
     sub: string;
-    source: "email" | "sub";
+    email: string | null;
 }>;
 export type AuthInfoExtra = z.infer<typeof AuthInfoExtraSchema>;
 export interface AuthContext {

package/dist/cache/aisle-store.d.ts

@@ -0,0 +1,9 @@
+import { EntityStore } from "../entity/index.js";
+import type { Aisle, AisleUid } from "../paprika/types.js";
+export declare class AisleStore extends EntityStore<Aisle, AisleUid> {
+    constructor(opts?: {
+        readonly pendingWriteTtlMs?: number;
+    });
+    load(items: ReadonlyArray<Aisle>): void;
+    resolveByName(name: string): Aisle | undefined;
+}

package/dist/cache/aisle-store.js

@@ -0,0 +1,17 @@
+import { EntityStore } from "../entity/index.js";
+export class AisleStore extends EntityStore {
+    constructor(opts) {
+        super(opts ?? {});
+    }
+    load(items) {
+        this.baseLoad(items);
+    }
+    resolveByName(name) {
+        const needle = name.toLowerCase();
+        for (const aisle of this._items.values()) {
+            if (aisle.name.toLowerCase() === needle)
+                return aisle;
+        }
+        return undefined;
+    }
+}

package/dist/cache/disk/root.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "pino";
 import type { OAuthToken } from "../../auth/types.js";
-import type { Category, PantryItem } from "../../paprika/types.js";
+import type { Aisle, Category, GroceryIngredient, GroceryItem, GroceryList, PantryItem } from "../../paprika/types.js";
 import { DiskCache } from "./base.js";
 import { OAuthClientDiskCache } from "./oauth-clients.js";
 import { RecipeDiskCache } from "./recipes.js";
@@ -18,8 +18,12 @@ export declare class DiskCacheRoot {
     readonly recipes: RecipeDiskCache;
     readonly categories: DiskCache<Category>;
     readonly pantry: DiskCache<PantryItem>;
+    readonly aisles: DiskCache<Aisle>;
     readonly oauthClients: OAuthClientDiskCache;
     readonly oauthTokens: DiskCache<OAuthToken>;
+    readonly groceryLists: DiskCache<GroceryList>;
+    readonly groceryItems: DiskCache<GroceryItem>;
+    readonly groceryIngredients: DiskCache<GroceryIngredient>;
     private readonly _cacheDir;
     private readonly _subcaches;
     private readonly log;

package/dist/cache/disk/root.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, rename, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { OAuthTokenSchema } from "../../auth/types.js";
-import { CategoryStoredSchema, PantryItemStoredSchema } from "../../paprika/types.js";
+import { AisleStoredSchema, CategoryStoredSchema, GroceryIngredientStoredSchema, GroceryItemStoredSchema, GroceryListStoredSchema, PantryItemStoredSchema, } from "../../paprika/types.js";
 import { isNodeError } from "../../utils/errors.js";
 import { SILENT_LOG } from "../../utils/log.js";
 import { DiskCache, writeFileAtomic } from "./base.js";
@@ -27,8 +27,12 @@ export class DiskCacheRoot {
     recipes;
     categories;
     pantry;
+    aisles;
     oauthClients;
     oauthTokens;
+    groceryLists;
+    groceryItems;
+    groceryIngredients;
     _cacheDir;
     _subcaches;
     log;
@@ -49,6 +53,12 @@ export class DiskCacheRoot {
             getKey: (i) => i.uid,
             ...logOpts,
         });
+        this.aisles = new DiskCache({
+            subdir: join(cacheDir, "aisles"),
+            parse: (raw) => AisleStoredSchema.parse(raw),
+            getKey: (a) => a.uid,
+            ...logOpts,
+        });
         this.oauthClients = new OAuthClientDiskCache({ subdir: join(cacheDir, "oauthClients"), ...logOpts });
         this.oauthTokens = new DiskCache({
             subdir: join(cacheDir, "oauthTokens"),
@@ -56,7 +66,35 @@ export class DiskCacheRoot {
             getKey: (t) => t.tokenHash,
             ...logOpts,
         });
-        this._subcaches = [this.recipes, this.categories, this.pantry, this.oauthClients, this.oauthTokens];
+        this.groceryLists = new DiskCache({
+            subdir: join(cacheDir, "grocerylists"),
+            parse: (raw) => GroceryListStoredSchema.parse(raw),
+            getKey: (l) => l.uid,
+            ...logOpts,
+        });
+        this.groceryItems = new DiskCache({
+            subdir: join(cacheDir, "groceryitems"),
+            parse: (raw) => GroceryItemStoredSchema.parse(raw),
+            getKey: (i) => i.uid,
+            ...logOpts,
+        });
+        this.groceryIngredients = new DiskCache({
+            subdir: join(cacheDir, "groceryingredients"),
+            parse: (raw) => GroceryIngredientStoredSchema.parse(raw),
+            getKey: (i) => i.uid,
+            ...logOpts,
+        });
+        this._subcaches = [
+            this.recipes,
+            this.categories,
+            this.pantry,
+            this.aisles,
+            this.oauthClients,
+            this.oauthTokens,
+            this.groceryLists,
+            this.groceryItems,
+            this.groceryIngredients,
+        ];
     }
     async init() {
         await this._maybeMigrateLegacyIndex();

package/dist/cache/grocery-ingredient-store.d.ts

@@ -0,0 +1,18 @@
+import type { GroceryIngredient } from "../paprika/types.js";
+/**
+ * In-memory store for grocery ingredients, keyed by lowercase name for
+ * case-insensitive lookup. Unlike GroceryListStore and GroceryItemStore,
+ * this is a plain class — not an EntityStore subclass — because ingredients
+ * have no pending-writes, no tombstones, and no sweepPending. Internal
+ * storage is a Map<string, GroceryIngredient> keyed by lowercase name.
+ */
+export declare class GroceryIngredientStore {
+    private readonly _items;
+    private _hasSynced;
+    get hasSynced(): boolean;
+    get size(): number;
+    load(items: ReadonlyArray<GroceryIngredient>): void;
+    set(ingredient: GroceryIngredient): void;
+    lookupByName(name: string): GroceryIngredient | undefined;
+    getAll(): Array<GroceryIngredient>;
+}

package/dist/cache/grocery-ingredient-store.js

@@ -0,0 +1,33 @@
+/**
+ * In-memory store for grocery ingredients, keyed by lowercase name for
+ * case-insensitive lookup. Unlike GroceryListStore and GroceryItemStore,
+ * this is a plain class — not an EntityStore subclass — because ingredients
+ * have no pending-writes, no tombstones, and no sweepPending. Internal
+ * storage is a Map<string, GroceryIngredient> keyed by lowercase name.
+ */
+export class GroceryIngredientStore {
+    _items = new Map();
+    _hasSynced = false;
+    get hasSynced() {
+        return this._hasSynced;
+    }
+    get size() {
+        return this._items.size;
+    }
+    load(items) {
+        this._items.clear();
+        for (const item of items) {
+            this._items.set(item.name.toLowerCase(), item);
+        }
+        this._hasSynced = true;
+    }
+    set(ingredient) {
+        this._items.set(ingredient.name.toLowerCase(), ingredient);
+    }
+    lookupByName(name) {
+        return this._items.get(name.toLowerCase());
+    }
+    getAll() {
+        return [...this._items.values()];
+    }
+}

package/dist/cache/grocery-item-store.d.ts

@@ -0,0 +1,16 @@
+import { TombstoneEntityStore } from "../entity/index.js";
+import type { GroceryItem, GroceryItemUid } from "../paprika/types.js";
+export declare class GroceryItemStore extends TombstoneEntityStore<GroceryItem, GroceryItemUid> {
+    constructor(opts?: {
+        readonly pendingWriteTtlMs?: number;
+    });
+    /**
+     * Returns all non-tombstoned items whose listUid matches the given value.
+     */
+    getByListUid(listUid: string): Array<GroceryItem>;
+    /**
+     * Returns all non-tombstoned items in the given list that have been
+     * marked as purchased.
+     */
+    getPurchasedByList(listUid: string): Array<GroceryItem>;
+}

package/dist/cache/grocery-item-store.js

@@ -0,0 +1,29 @@
+import { TombstoneEntityStore } from "../entity/index.js";
+export class GroceryItemStore extends TombstoneEntityStore {
+    constructor(opts) {
+        super(opts ?? {});
+    }
+    /**
+     * Returns all non-tombstoned items whose listUid matches the given value.
+     */
+    getByListUid(listUid) {
+        const result = [];
+        for (const item of this._items.values()) {
+            if (item.listUid === listUid)
+                result.push(item);
+        }
+        return result;
+    }
+    /**
+     * Returns all non-tombstoned items in the given list that have been
+     * marked as purchased.
+     */
+    getPurchasedByList(listUid) {
+        const result = [];
+        for (const item of this._items.values()) {
+            if (item.listUid === listUid && item.purchased)
+                result.push(item);
+        }
+        return result;
+    }
+}

package/dist/cache/grocery-list-store.d.ts

@@ -0,0 +1,16 @@
+import { TombstoneEntityStore } from "../entity/index.js";
+import type { GroceryList, GroceryListUid } from "../paprika/types.js";
+export declare class GroceryListStore extends TombstoneEntityStore<GroceryList, GroceryListUid> {
+    private _lastSyncedAt;
+    constructor(opts?: {
+        readonly pendingWriteTtlMs?: number;
+    });
+    get lastSyncedAt(): Date | null;
+    setLastSyncedAt(at?: Date): void;
+    /**
+     * Tiered case-insensitive name lookup: exact > starts-with > contains.
+     * Returns items from at most one tier. Excludes deleted items (they are
+     * removed from _items by delete() before this is called).
+     */
+    findByName(query: string): Array<GroceryList>;
+}

package/dist/cache/grocery-list-store.js

@@ -0,0 +1,38 @@
+import { TombstoneEntityStore } from "../entity/index.js";
+export class GroceryListStore extends TombstoneEntityStore {
+    _lastSyncedAt = null;
+    constructor(opts) {
+        super(opts ?? {});
+    }
+    get lastSyncedAt() {
+        return this._lastSyncedAt;
+    }
+    setLastSyncedAt(at = new Date()) {
+        this._lastSyncedAt = at;
+    }
+    /**
+     * Tiered case-insensitive name lookup: exact > starts-with > contains.
+     * Returns items from at most one tier. Excludes deleted items (they are
+     * removed from _items by delete() before this is called).
+     */
+    findByName(query) {
+        const needle = query.toLowerCase();
+        const exact = [];
+        const startsWith = [];
+        const contains = [];
+        for (const list of this._items.values()) {
+            const name = list.name.toLowerCase();
+            if (name === needle)
+                exact.push(list);
+            else if (name.startsWith(needle))
+                startsWith.push(list);
+            else if (name.includes(needle))
+                contains.push(list);
+        }
+        if (exact.length > 0)
+            return exact;
+        if (startsWith.length > 0)
+            return startsWith;
+        return contains;
+    }
+}

package/dist/cache/pantry-store.d.ts

@@ -1,18 +1,8 @@
-import { EntityStore } from "../entity/index.js";
+import { TombstoneEntityStore } from "../entity/index.js";
 import type { PantryItem, PantryItemUid } from "../paprika/types.js";
-export declare class PantryStore extends EntityStore<PantryItem, PantryItemUid> {
-    private readonly _tombstones;
+export declare class PantryStore extends TombstoneEntityStore<PantryItem, PantryItemUid> {
     constructor(opts?: {
         readonly pendingWriteTtlMs?: number;
     });
-    load(items: ReadonlyArray<PantryItem>): void;
-    set(item: PantryItem): void;
-    delete(uid: PantryItemUid): void;
-    /**
-     * Returns true if `uid` was soft-deleted via this store in the current
-     * session (since the last `load()`). Used by `delete_pantry_item` to give
-     * idempotent retried-delete callers a clear "already deleted" signal.
-     */
-    isTombstone(uid: PantryItemUid): boolean;
     findByIngredient(query: string): Array<PantryItem>;
 }

package/dist/cache/pantry-store.js

@@ -1,51 +1,8 @@
-import { EntityStore } from "../entity/index.js";
-export class PantryStore extends EntityStore {
-    // Tombstones track UIDs that were soft-deleted via this client, so
-    // `delete_pantry_item` can return a distinct "already deleted" message for
-    // retried calls (server upserts by UID and the live-items map alone can't
-    // distinguish "I deleted this" from "this never existed"). Tombstones
-    // persist across `load()` so delayed retries that span a sync cycle still
-    // get the idempotent signal — `load()` only un-tombstones UIDs that are
-    // now back in the live items list (i.e. resurrected by the server, e.g.,
-    // un-deleted via another client). The tombstone set therefore stays
-    // disjoint from `_items` after every load.
-    _tombstones = new Set();
+import { TombstoneEntityStore } from "../entity/index.js";
+export class PantryStore extends TombstoneEntityStore {
     constructor(opts) {
         super(opts ?? {});
     }
-    load(items) {
-        this.baseLoad(items);
-        // Un-tombstone any UID that came back in the snapshot (resurrection: item
-        // returned from the server supersedes the local soft-delete).
-        for (const item of items) {
-            this._tombstones.delete(item.uid);
-        }
-    }
-    set(item) {
-        super.set(item);
-        this._tombstones.delete(item.uid);
-    }
-    delete(uid) {
-        // Always tombstone, regardless of whether `uid` is currently in `_items`.
-        // The only caller is `commitPantryItem`'s delete branch (post-successful
-        // savePantryItem), but several awaits separate the save from the local
-        // commit; SyncEngine.syncOnce() can interleave a `load(...)` that wipes
-        // the UID from `_items` before commit lands. Conditioning the tombstone
-        // on `_items.has(uid)` would silently drop the idempotent retry signal
-        // in exactly that race. Spurious tombstones from other callers are
-        // acceptable: an extra "already deleted" message is harmless; a missing
-        // one isn't.
-        this._tombstones.add(uid);
-        super.delete(uid);
-    }
-    /**
-     * Returns true if `uid` was soft-deleted via this store in the current
-     * session (since the last `load()`). Used by `delete_pantry_item` to give
-     * idempotent retried-delete callers a clear "already deleted" signal.
-     */
-    isTombstone(uid) {
-        return this._tombstones.has(uid);
-    }
     findByIngredient(query) {
         const needle = query.toLowerCase();
         const exact = [];

package/dist/cache/recipe-store.d.ts

@@ -16,9 +16,12 @@ export type TimeConstraints = {
 };
 export declare class RecipeStore extends EntityStore<Recipe, RecipeUid> {
     private readonly categories;
+    private _lastSyncedAt;
     constructor(opts?: {
         readonly pendingWriteTtlMs?: number;
     });
+    get lastSyncedAt(): Date | null;
+    setLastSyncedAt(at?: Date): void;
     load(recipes: ReadonlyArray<Recipe>, categories: ReadonlyArray<Category>): void;
     getAll(): Array<Recipe>;
     get size(): number;

package/dist/cache/recipe-store.js

@@ -2,9 +2,16 @@ import { EntityStore } from "../entity/index.js";
 import { parseDuration } from "../utils/duration.js";
 export class RecipeStore extends EntityStore {
     categories = new Map();
+    _lastSyncedAt = null;
     constructor(opts) {
         super(opts ?? {});
     }
+    get lastSyncedAt() {
+        return this._lastSyncedAt;
+    }
+    setLastSyncedAt(at = new Date()) {
+        this._lastSyncedAt = at;
+    }
     load(recipes, categories) {
         this.baseLoad(recipes);
         this.setCategories(categories);

package/dist/entity/index.d.ts

@@ -1 +1,2 @@
 export { EntityStore, type PendingWrite } from "./store.js";
+export { TombstoneEntityStore } from "./tombstone-store.js";

package/dist/entity/index.js

@@ -1 +1,2 @@
 export { EntityStore } from "./store.js";
+export { TombstoneEntityStore } from "./tombstone-store.js";

package/dist/entity/tombstone-store.d.ts

@@ -0,0 +1,10 @@
+import { EntityStore } from "./store.js";
+export declare abstract class TombstoneEntityStore<T extends {
+    uid: UID;
+}, UID extends string> extends EntityStore<T, UID> {
+    private readonly _tombstones;
+    load(items: ReadonlyArray<T>): void;
+    set(item: T): void;
+    delete(uid: UID): void;
+    isTombstone(uid: UID): boolean;
+}

package/dist/entity/tombstone-store.js

@@ -0,0 +1,21 @@
+import { EntityStore } from "./store.js";
+export class TombstoneEntityStore extends EntityStore {
+    _tombstones = new Set();
+    load(items) {
+        this.baseLoad(items);
+        for (const item of items) {
+            this._tombstones.delete(this.getUid(item));
+        }
+    }
+    set(item) {
+        super.set(item);
+        this._tombstones.delete(this.getUid(item));
+    }
+    delete(uid) {
+        this._tombstones.add(uid);
+        super.delete(uid);
+    }
+    isTombstone(uid) {
+        return this._tombstones.has(uid);
+    }
+}

package/dist/paprika/client.d.ts

@@ -1,14 +1,5 @@
-/**
- * Typed HTTP client for the Paprika Cloud Sync API.
- *
- * Encapsulates authentication against the v1 login endpoint
- * and resilient request execution against the v2 data endpoint.
- *
- * Provides recipe and category read methods, plus write methods
- * added in P1-U07 (saveRecipe, deleteRecipe, notifySync).
- */
 import type { Logger } from "pino";
-import type { Category, PantryItem, Recipe, RecipeEntry, RecipeUid } from "./types.js";
+import type { Aisle, Category, GroceryIngredient, GroceryItem, GroceryList, PantryItem, Recipe, RecipeEntry, RecipeUid } from "./types.js";
 export declare class PaprikaClient {
     private readonly email;
     private readonly password;
@@ -24,12 +15,20 @@ export declare class PaprikaClient {
     getRecipe(uid: string): Promise<Recipe>;
     getRecipes(uids: ReadonlyArray<string>): Promise<Array<Recipe>>;
     listCategories(): Promise<Array<Category>>;
+    listAisles(): Promise<Array<Aisle>>;
+    listGroceryLists(): Promise<Array<GroceryList>>;
+    listGroceryItems(): Promise<Array<GroceryItem>>;
+    listGroceryIngredients(): Promise<Array<GroceryIngredient>>;
     listPantry(): Promise<Array<PantryItem>>;
     saveRecipe(recipe: Readonly<Recipe>): Promise<Recipe>;
-    savePantryItem(item: Readonly<PantryItem>): Promise<PantryItem>;
+    saveAisle(aisle: Readonly<Aisle>): Promise<Aisle>;
+    savePantryItems(items: ReadonlyArray<Readonly<PantryItem>>): Promise<ReadonlyArray<PantryItem>>;
+    saveGroceryList(list: Readonly<GroceryList>): Promise<GroceryList>;
+    saveGroceryItems(items: ReadonlyArray<Readonly<GroceryItem>>): Promise<ReadonlyArray<GroceryItem>>;
+    saveGroceryIngredient(ingredient: Readonly<GroceryIngredient>): Promise<GroceryIngredient>;
     notifySync(): Promise<void>;
     deleteRecipe(uid: RecipeUid): Promise<void>;
-    private buildRecipeFormData;
-    private buildPantryFormData;
+    private buildEntityFormData;
+    private postEntities;
     private request;
 }