@yuiseki/gyazocli 0.7.0 → 0.9.0

package/dist/commands/sync.js

@@ -13,13 +13,52 @@ function registerSyncCommand(program) {
         .option('--days <number>', 'number of days to sync (used when --date is omitted)')
         .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'sync only this date/month/year range')
         .option('--max-pages <number>', 'max pages to fetch', '10')
+        .option('--query <query>', 'fill the cache from a search instead of the listing')
+        .option('--refresh', 'fetch every capture again, even one already cached')
+        .option('--continue', 'resume the last walk of this query instead of starting at the top')
         .action(async (options) => {
         await (0, credentials_1.ensureAccessToken)();
         if (options.date && options.days) {
             console.error('Error: --date and --days cannot be used together.');
             process.exit(1);
         }
+        if (options.query && (options.date || options.days)) {
+            // Search results are not ordered the same way for every query: a plain
+            // query comes back newest first, while a `date:` one starts at the
+            // beginning of its range. Nothing here can bound a walk by date
+            // safely, and the query language can: put the range in the query.
+            console.error('Error: --query cannot be used with --date or --days.');
+            console.error('Hint: bound the range inside the query, as');
+            console.error('  --query "has:exif date:2026-08"');
+            console.error('  --query "has:exif since:2026-08-01 until:2026-08-31"');
+            process.exit(1);
+        }
+        if (options.continue && !options.query) {
+            console.error('Error: --continue needs --query, because it resumes a query.');
+            process.exit(1);
+        }
         const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+        /** The day part of an instant, in local time, as the operators want it. */
+        const dayOf = (date) => {
+            const pad = (value) => String(value).padStart(2, '0');
+            return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+        };
+        let query = options.query;
+        if (options.continue) {
+            if (/\b(date|since|until):/i.test(query)) {
+                console.error('Error: --continue cannot resume a query that bounds its own dates.');
+                console.error('Hint: drop date:, since: and until: from --query, or drop --continue.');
+                process.exit(1);
+            }
+            const state = (0, storage_1.loadSyncState)(query);
+            if (state) {
+                query = `${query} until:${state.oldestDay}`;
+                console.log(`Resuming from ${state.oldestDay} (walked ${state.updatedAt}).`);
+            }
+            else {
+                console.log('Nothing walked for this query yet; starting at the top.');
+            }
+        }
         let startDate;
         let endDate;
         if (options.date) {
@@ -37,23 +76,36 @@ function registerSyncCommand(program) {
             startDate.setDate(startDate.getDate() - days - 1);
             startDate.setHours(0, 0, 0, 0);
         }
-        console.log(`Syncing images between ${startDate.toISOString()} and ${endDate.toISOString()}...`);
+        if (query) {
+            console.log(`Syncing images matching ${JSON.stringify(query)}...`);
+        }
+        else {
+            console.log(`Syncing images between ${startDate.toISOString()} and ${endDate.toISOString()}...`);
+        }
         const hourlyIndices = new Map();
+        let oldestSeen = null;
         for (let page = 1; page <= maxPages; page++) {
-            const images = await (0, api_1.listImages)(page, 100);
+            const images = query
+                ? await (0, api_1.searchImages)(query, page, 100)
+                : await (0, api_1.listImages)(page, 100);
             if (images.length === 0)
                 break;
             let reachedLimit = false;
             for (const img of images) {
                 const createdAt = new Date(img.created_at);
-                if (createdAt > endDate) {
+                // A query says for itself what it covers, and the results are not
+                // ordered predictably enough to stop early on a date.
+                if (!query && createdAt > endDate) {
                     // Skip images newer than target range.
                     continue;
                 }
-                if (createdAt < startDate) {
+                if (!query && createdAt < startDate) {
                     reachedLimit = true;
                     break;
                 }
+                if (!oldestSeen || createdAt < oldestSeen) {
+                    oldestSeen = createdAt;
+                }
                 // Add to hourly index
                 const y = createdAt.getFullYear().toString();
                 const m = (createdAt.getMonth() + 1).toString().padStart(2, '0');
@@ -63,8 +115,13 @@ function registerSyncCommand(program) {
                 if (!hourlyIndices.has(key))
                     hourlyIndices.set(key, new Set());
                 hourlyIndices.get(key)?.add(img.image_id);
-                const cached = (0, storage_1.loadImageCache)(img.image_id);
-                if (cached && cached.ocr) {
+                // Already fetched is already fetched. This used to test `cached.ocr`,
+                // which is null in every response the API returns -- the OCR text
+                // lives under `metadata` -- so the check never fired and every sync
+                // re-fetched everything it had. On an API with undocumented rate
+                // limits that is the expensive kind of mistake.
+                const cached = options.refresh ? null : (0, storage_1.loadImageCache)(img.image_id);
+                if (cached) {
                     process.stdout.write(`s`);
                     continue;
                 }
@@ -81,6 +138,12 @@ function registerSyncCommand(program) {
             console.log(`\nPage ${page} processed.`);
             if (reachedLimit)
                 break;
+            // A breath between pages. The rate limits here are real and
+            // undocumented, and a walk of a hundred pages is exactly the shape
+            // that finds them.
+            if (page < maxPages) {
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
         }
         // Save hourly indices
         console.log(`Updating hourly indices...`);
@@ -90,6 +153,16 @@ function registerSyncCommand(program) {
             const merged = Array.from(new Set([...existing, ...ids]));
             (0, storage_1.saveHourlyCache)(y, m, d, h, merged);
         }
+        // Remember how far back this query got, so a later --continue can pick
+        // up there rather than walking the same pages again. Only for a query
+        // the caller did not bound itself: a bounded one says what it covers.
+        if (options.query && oldestSeen && !/\b(date|since|until):/i.test(options.query)) {
+            (0, storage_1.saveSyncState)({
+                query: options.query,
+                oldestDay: dayOf(oldestSeen),
+                updatedAt: new Date().toISOString(),
+            });
+        }
         console.log(`Sync complete.`);
     });
 }

package/dist/index.js

@@ -26,7 +26,7 @@ program
     .name('gyazo')
     .description('Gyazo Memory CLI for AI Secretary')
     .option('--mcp-server', 'run as a Model Context Protocol server over stdio')
-    .version('0.7.0');
+    .version('0.9.0');
 (0, config_1.registerConfigCommand)(program);
 (0, list_1.registerListCommand)(program);
 (0, get_1.registerGetCommand)(program);

package/dist/storage.js

@@ -15,8 +15,11 @@ exports.saveHourlyCache = saveHourlyCache;
 exports.loadHourlyCache = loadHourlyCache;
 exports.saveHourlyMetadataCache = saveHourlyMetadataCache;
 exports.loadHourlyMetadataCache = loadHourlyMetadataCache;
+exports.loadSyncState = loadSyncState;
+exports.saveSyncState = saveSyncState;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
 const os_1 = __importDefault(require("os"));
 function getCacheDir() {
     if (process.env.GYAZO_CACHE_DIR) {
@@ -105,3 +108,25 @@ function loadHourlyMetadataCache(kind, year, month, day, hour) {
     }
     return null;
 }
+function getSyncStatePath(query) {
+    const dir = path_1.default.join(getCacheDir(), 'sync');
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    const key = crypto_1.default.createHash('sha1').update(query).digest('hex');
+    return path_1.default.join(dir, `${key}.json`);
+}
+function loadSyncState(query) {
+    const file = getSyncStatePath(query);
+    if (!fs_1.default.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveSyncState(state) {
+    fs_1.default.writeFileSync(getSyncStatePath(state.query), JSON.stringify(state, null, 2));
+}

package/docs/ADR/003-cli-structure.md

@@ -13,7 +13,7 @@ Adopt and document the existing top-level command structure.
 
 ### 1. Program Metadata
 - Binary name: `gyazo`
-- Version: `0.7.0`
+- Version: `0.9.0`
 - Description: `Gyazo Memory CLI for AI Secretary`
 
 ### 2. Commands
@@ -118,6 +118,10 @@ Adopt and document the existing top-level command structure.
     - `--days <number>` (default: `1`, used when `--date` is omitted)
     - `--date <yyyy|yyyy-mm|yyyy-mm-dd>`
     - `--max-pages <number>` (default: `10`)
+    - `--query <query>` (fill from a search instead of the listing; not with
+      `--date` or `--days`, because the range belongs inside the query)
+    - `--refresh` (fetch every capture again, even one already cached)
+    - `--continue` (resume the last walk of this query, with `--query`)
 - `gyazo import <type> <dir>`
   - Supported types: `json`, `hourly`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuiseki/gyazocli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Gyazo Memory CLI for AI Secretary",
   "repository": {
     "type": "git",

package/skills/gyazo/SKILL.md

@@ -25,6 +25,7 @@ gyazo ls --hour 2026-08-30-14        # one hour, from the cache only
 gyazo ls --photos                    # shorthand for has:location
 gyazo get <image_id>                 # one capture in detail
 gyazo get <image_id> --ocr           # just the OCR text
+gyazo get <image_id> --objects       # just what was detected in it
 gyazo <image_id>                     # same as get
 gyazo <https://gyazo.com/...>        # same as get
 gyazo ./screenshot.png               # an existing file uploads instead
@@ -97,12 +98,29 @@ endpoint returns the first 100 and cannot page.
 ```bash
 gyazo sync --days 7                  # yesterday back through 7 days
 gyazo sync --date 2026-08            # a whole month
+gyazo sync --query "has:exif OR has:location" --max-pages 20
+gyazo sync --query "has:exif" --max-pages 20 --continue   # carry on from last time
 ```
 
 `sync` covers yesterday backwards and never today, because today is still
 happening. For anything from today use `ls --today`, `search`, or a ranking
 command with `--today`.
 
+`--query` fills the cache from a search instead of the listing, which is how to
+gather one kind of capture without walking past everything else: photographs
+are a small fraction of a day's screenshots. Put any date range inside the
+query (`date:2026-08`, `since:... until:...`) rather than in `--date`, which
+`--query` refuses.
+
+A capture already in the cache is not fetched again, so a repeated sync costs
+only the search pages: 100 cached captures take under a second, 100 new ones
+about 40 seconds. `--continue` remembers how far back the last walk of that
+query reached and resumes with `until:<that day>`, which is how to backfill a
+long history a few hundred pages at a time without asking for the same pages
+twice. Gyazo rate-limits without documenting it, so prefer resuming over
+re-walking, and leave `--refresh` alone unless a capture really needs
+re-fetching.
+
 ## Answering questions with captures
 
 - A day is a local day. `--date 2026-08-30` means that date in this machine's
@@ -111,9 +129,10 @@ command with `--today`.
   work, and `ls --date` over a wide range walks many pages.
 - OCR text is noisy: it comes from screenshots at whatever resolution, and
   `locale` is often `und`. Treat it as a hint, not a transcript.
-- `get --objects` prints detected objects, but the API no longer returns the
-  field it reads, so it exits non-zero with "Object annotations not found" on
-  every capture tested. Use the OCR text instead.
+- `get --objects` prints what was detected in the image, with a confidence.
+  About 59% of captures carry annotations; the rest exit non-zero with "Object
+  annotations not found", which means this capture has none, not that the
+  command is broken. `--ocr` and `--objects` cannot be combined.
 - **Do not turn a capture into a claim it does not support.** A product page or
   a cart is interest; an order confirmation or a payment receipt is a purchase.
   Say which capture the conclusion rests on.