untappd-mcp 2.1.2 → 2.2.0

package/dist/cache/store.js

@@ -175,7 +175,9 @@ export const SCHEMA_STATEMENTS = [
      beers_offset       INTEGER,
      beers_total        INTEGER,
      beers_complete     INTEGER NOT NULL DEFAULT 0,
-     served_backfill_last INTEGER NOT NULL DEFAULT 0
+     served_backfill_last INTEGER NOT NULL DEFAULT 0,
+     beers_accepted_gap INTEGER NOT NULL DEFAULT 0,
+     beers_rescan_target INTEGER
    )`,
 ];
 /** Columns added after the initial release, each applied idempotently on open. */
@@ -186,6 +188,8 @@ export const MIGRATIONS = [
     'ALTER TABLE sync_state ADD COLUMN beers_total INTEGER',
     'ALTER TABLE sync_state ADD COLUMN beers_complete INTEGER NOT NULL DEFAULT 0',
     'ALTER TABLE sync_state ADD COLUMN served_backfill_last INTEGER NOT NULL DEFAULT 0',
+    'ALTER TABLE sync_state ADD COLUMN beers_accepted_gap INTEGER NOT NULL DEFAULT 0',
+    'ALTER TABLE sync_state ADD COLUMN beers_rescan_target INTEGER',
 ];
 /**
  * The cache logic over a synchronous {@link SqlDriver}. Usernames are keyed
@@ -298,6 +302,8 @@ export class CheckinStoreCore {
             beers_total: num(row.beers_total),
             beers_complete: Number(row.beers_complete) === 1,
             served_backfill_last: Number(row.served_backfill_last) === 1,
+            beers_accepted_gap: num(row.beers_accepted_gap) ?? 0,
+            beers_rescan_target: num(row.beers_rescan_target),
         };
     }
     /**
@@ -322,20 +328,24 @@ export class CheckinStoreCore {
             beers_total: pick('beers_total', null),
             beers_complete: pick('beers_complete', false),
             served_backfill_last: pick('served_backfill_last', false),
+            beers_accepted_gap: pick('beers_accepted_gap', 0),
+            beers_rescan_target: pick('beers_rescan_target', null),
         };
         this.db.run(`INSERT INTO sync_state
-         (username, oldest_max_id, newest_checkin_id, catchup_max_id, last_synced_at, backfill_complete, total_checkins, checkins_truncated, beers_offset, beers_total, beers_complete, served_backfill_last)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         (username, oldest_max_id, newest_checkin_id, catchup_max_id, last_synced_at, backfill_complete, total_checkins, checkins_truncated, beers_offset, beers_total, beers_complete, served_backfill_last, beers_accepted_gap, beers_rescan_target)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(username) DO UPDATE SET
          oldest_max_id=excluded.oldest_max_id, newest_checkin_id=excluded.newest_checkin_id,
          catchup_max_id=excluded.catchup_max_id, last_synced_at=excluded.last_synced_at,
          backfill_complete=excluded.backfill_complete, total_checkins=excluded.total_checkins,
          checkins_truncated=excluded.checkins_truncated, beers_offset=excluded.beers_offset,
          beers_total=excluded.beers_total, beers_complete=excluded.beers_complete,
-         served_backfill_last=excluded.served_backfill_last`, [
+         served_backfill_last=excluded.served_backfill_last, beers_accepted_gap=excluded.beers_accepted_gap,
+         beers_rescan_target=excluded.beers_rescan_target`, [
             key, next.oldest_max_id, next.newest_checkin_id, next.catchup_max_id, next.last_synced_at,
             next.backfill_complete ? 1 : 0, next.total_checkins, next.checkins_truncated ? 1 : 0,
             next.beers_offset, next.beers_total, next.beers_complete ? 1 : 0, next.served_backfill_last ? 1 : 0,
+            next.beers_accepted_gap, next.beers_rescan_target,
         ]);
     }
     /**

package/dist/cache/sync-beers.js

@@ -1,6 +1,10 @@
 import { createHelpfulError, RateLimitError, messageOf } from '@chrischall/mcp-utils';
 import { mapBeerRow } from './store.js';
 const PAGE_LIMIT = 50; // Untappd's max page size for /user/beers.
+// A resumed backfill re-reads this many already-fetched items: if beers dropped
+// out of the list between runs, everything below shifted UP past the stored
+// offset, and without the overlap the beers that crossed it would be skipped.
+const RESUME_OVERLAP = 10;
 /** One `/user/beers` page fetch (offset-paged), tolerant of the fat shape. */
 async function fetchBeersPage(client, encodedUser, offset) {
     const data = await client.get(`/user/beers/${encodedUser}`, { limit: PAGE_LIMIT, offset, sort: 'date' });
@@ -35,8 +39,15 @@ export async function syncUserBeers(client, cache, rawUsername, maxPages = 10) {
     // An already-complete cache re-scans from the top to pick up newly-had beers,
     // stopping on the first page with nothing new. Otherwise resume the backfill.
     const incremental = (prior?.beers_complete ?? false) && !!prior?.last_synced_at;
-    let offset = incremental ? 0 : (prior?.beers_offset ?? 0);
+    // `refreshing` is the live mode: it starts as `incremental` and is cleared when
+    // a shortfall forces a rescan (which must page past "nothing new" pages).
+    let refreshing = incremental;
+    let offset = incremental ? 0 : Math.max(0, (prior?.beers_offset ?? 0) - RESUME_OVERLAP);
     let total = prior?.beers_total ?? null;
+    let acceptedGap = prior?.beers_accepted_gap ?? 0;
+    // Non-null while a coverage rescan is walking down from the top (possibly
+    // across runs): it stops as soon as the shortfall is back within this target.
+    let rescanTarget = incremental ? null : (prior?.beers_rescan_target ?? null);
     let complete = false;
     let pages = 0;
     let added = 0;
@@ -52,42 +63,60 @@ export async function syncUserBeers(client, cache, rawUsername, maxPages = 10) {
             });
         }
     };
+    const gapNow = async () => total === null ? 0 : total - (await cache.distinctBeersCount(rawUsername));
     for (; pages < maxPages && !complete;) {
         const page = pages === 0 ? await firstFetch(offset) : await fetchBeersPage(client, encodedUser, offset);
         pages++;
         if (page.total !== null)
             total = page.total;
-        if (page.items.length === 0) {
-            // An empty (e.g. first) page still means the list is fully paged — persist
-            // completion so a subsequent call doesn't re-run the same empty fetch.
-            complete = true;
-            await cache.setState(rawUsername, {
-                beers_offset: incremental ? (total ?? offset) : offset,
-                beers_total: total,
-                beers_complete: true,
-                last_synced_at: now(),
-            });
-            break;
+        // An empty (e.g. first) page still means the list is fully paged.
+        let atEnd = page.items.length === 0;
+        if (!atEnd) {
+            const rows = rowsOf(rawUsername, page.items);
+            const netNew = await cache.upsertDistinctBeers(rawUsername, rows);
+            added += netNew;
+            offset += page.items.length;
+            // End conditions: caught the whole list, a short (final) page, or — during an
+            // incremental top refresh — a page that added nothing new.
+            if (total !== null && offset >= total)
+                atEnd = true;
+            else if (page.items.length < PAGE_LIMIT)
+                atEnd = true;
+            else if (refreshing && netNew === 0)
+                atEnd = true;
+            else if (rescanTarget !== null && (await gapNow()) <= rescanTarget)
+                atEnd = true;
+        }
+        if (atEnd) {
+            // Offset paging across runs is not a snapshot: when the list churns between
+            // runs (a beer drops out, or is re-sorted) a beer can slip behind the resumed
+            // offset and never be fetched. Reaching the end is therefore only "complete"
+            // if the cache actually holds total_count beers — less whatever shortfall a
+            // previous full pass already proved the list can never close (a count Untappd
+            // reports but never lists). A NEW shortfall means skipped beers: rescan from
+            // the top (upserts are idempotent) instead of reporting false coverage.
+            const gap = await gapNow();
+            if (gap > acceptedGap && rescanTarget === null) {
+                rescanTarget = acceptedGap;
+                acceptedGap = gap; // a rescan that finds nothing new accepts this gap
+                refreshing = false;
+                offset = 0;
+            }
+            else {
+                complete = true;
+                rescanTarget = null;
+                acceptedGap = Math.max(0, gap);
+            }
         }
-        const rows = rowsOf(rawUsername, page.items);
-        const netNew = await cache.upsertDistinctBeers(rawUsername, rows);
-        added += netNew;
-        offset += page.items.length;
-        // End conditions: caught the whole list, a short (final) page, or — during an
-        // incremental top refresh — a page that added nothing new.
-        if (total !== null && offset >= total)
-            complete = true;
-        else if (page.items.length < PAGE_LIMIT)
-            complete = true;
-        else if (incremental && netNew === 0)
-            complete = true;
         // Persist progress after EVERY page. During an incremental refresh the stored
         // offset stays at the completed total so the next run refreshes from the top
         // again rather than resuming a stale cursor.
         await cache.setState(rawUsername, {
-            beers_offset: incremental ? (total ?? offset) : offset,
+            beers_offset: refreshing ? (total ?? offset) : offset,
             beers_total: total,
             beers_complete: complete,
+            beers_accepted_gap: acceptedGap,
+            beers_rescan_target: rescanTarget,
             last_synced_at: now(),
         });
     }