@yuiseki/gyazocli 0.5.0 → 0.5.2

package/README.md

@@ -122,15 +122,26 @@ results back from the detail endpoint to confirm the filter had applied:
 
 | Operator | Matches |
 | --- | --- |
+| `has:exif` | photographs rather than screenshots |
+| `has:location` | captures with coordinates |
 | `address:広島`, `address:Hiroshima`, `address:730-0041` | the reverse-geocoded address of a capture with GPS, in any language or case, postal codes included |
 | `app:"Gyazo Android"` | the application the capture came from |
 | `title:`, `url:`, `desc:` | the page it was captured from |
 | `ocr:` | the text in the image |
 | `type:png` | the file type |
-| `has:location` | only captures with coordinates |
-| `has:exif` | only captures with EXIF, which is not the same thing |
 | `since:2026-08-30 until:2026-08-31` | the upload date |
 | `-address:広島` | negation |
+| `OR` | alternation; terms are ANDed otherwise |
+
+To narrow to photographs, reach for `has:exif`. The application does not tell
+them apart: `app:"Gyazo Android"` includes screenshots and screen recordings
+from the same phone, and one page of `app:"Gyazo Android" -has:exif` came back
+as 68 gif and 30 png against 2 jpg.
+
+`has:exif` and `has:location` overlap without either containing the other. A
+photo taken indoors has EXIF and no coordinates; 86 captures here carry
+coordinates without the EXIF flag. `has:exif OR has:location` is the widest
+reading of "a photo".
 
 There is no coordinate or radius search. `location:`, `geo:`, `near:`,
 `bbox:`, `city:`, `lat:` and the like all return nothing, exactly as an

package/dist/api.js

@@ -119,7 +119,11 @@ async function listCollectionImages(collectionId, page = 1, per = 100) {
  */
 async function fetchImageRendition(imageId, width, format = 'webp') {
     const extension = format === 'jpeg' ? 'jpg' : 'webp';
-    const url = `${imageOrigin()}/thumb/${width}_w/${imageId}.${extension}`;
+    // The `-jpg` before the extension is a source-type marker, and it has to be
+    // there: without it the route answers 404 for any capture whose derivative
+    // is not already stored, which is most of them. Its value is ignored, and
+    // the extension alone decides what comes back, so a constant will do.
+    const url = `${imageOrigin()}/thumb/${width}_w/${imageId}-jpg.${extension}`;
     const response = await axios_1.default.get(url, { responseType: 'arraybuffer' });
     const data = Buffer.from(response.data);
     const contentType = String(response.headers['content-type'] || '').split(';')[0].trim();

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.5.0');
+    .version('0.5.2');
 (0, config_1.registerConfigCommand)(program);
 (0, list_1.registerListCommand)(program);
 (0, get_1.registerGetCommand)(program);

package/dist/mcp.js

@@ -34,20 +34,26 @@ const collections_1 = require("./services/collections");
  */
 const SEARCH_QUERY_DESCRIPTION = [
     'Search keyword, up to 200 characters. Bare words match the OCR text, title and',
-    'description.',
-    'Operators, all confirmed to work: address: matches the reverse-geocoded address of',
-    'a capture with GPS, in any language and case, and also matches postal codes, so',
-    'address:広島 and address:Hiroshima and address:730-0041 all find the same photos;',
-    'app: the application it came from, as app:"Gyazo Android"; title:, url: and desc:',
-    'the page it was captured from; ocr: the text in the image; type: the file type, as',
-    'type:png; has:location only captures with coordinates; has:exif only captures with',
-    'EXIF, which is not the same thing; since: and until: bound the upload date, as',
-    'since:2026-08-30 until:2026-08-31. A leading - negates, as -address:広島. Quote a',
-    'value that contains spaces.',
-    'There is no coordinate or radius search: location:, geo:, near:, bbox:, city: and',
-    'the like all return nothing. To search by place, use address: with a place name.',
-    'If nothing suitable comes back, rephrase the query to match what the user meant and',
-    'search again rather than giving up on the first attempt.',
+    'description. Terms are ANDed; OR in capitals is honoured, and a leading - negates.',
+    'To narrow to photographs rather than screenshots, use has:exif. The application is',
+    'not the distinction: app:"Gyazo Android" includes screenshots and screen recordings',
+    'from the same phone, and of one such page 68 were gif and 30 png against 2 jpg.',
+    'has:location narrows to captures with coordinates. It is not a subset of has:exif',
+    'and does not contain it either: a photo taken indoors has EXIF and no coordinates,',
+    'and some photos carry coordinates without the EXIF flag, so has:exif OR has:location',
+    'is the widest reading of "a photo".',
+    'address: matches the reverse-geocoded address of a capture with GPS, in any language',
+    'and case, and matches postal codes too, so address:広島 and address:Hiroshima and',
+    'address:730-0041 all find the same photos.',
+    'Also: app: the application it came from; title:, url: and desc: the page it was',
+    'captured from; ocr: the text in the image; type: the file type, as type:png; since:',
+    'and until: bound the upload date, as since:2026-08-30 until:2026-08-31. Quote a value',
+    'that contains spaces.',
+    'There is no coordinate or radius search: location:, geo:, near:, bbox:, city: and the',
+    'like all return nothing. To search by place, use address: with a place name.',
+    'An operator Gyazo does not know returns nothing rather than matching as text, so an',
+    'invented operator looks exactly like "no such captures". If nothing suitable comes',
+    'back, rephrase the query rather than giving up on the first attempt.',
 ].join(' ');
 function serverVersion() {
     // The published tarball always contains package.json, and dist/ sits one
@@ -187,16 +193,35 @@ const INCLUDE_LOCATION = zod_1.z
     .boolean()
     .default(true)
     .describe('Fill in the location, which the listing and search endpoints leave out. Costs one ' +
-    'extra lookup per capture the local cache does not already hold. Set false when the ' +
-    'coordinates do not matter');
+    'extra lookup per capture the local cache does not already hold, so a page of 40 ' +
+    'uncached captures adds a few seconds; the next look at the same captures is free. ' +
+    'Set false when the coordinates do not matter');
+/**
+ * Fill in the locations, and say so when the per-call limit stopped it part
+ * way: past that point a capture without a location is indistinguishable from
+ * one that has none, which is exactly the sort of silence worth breaking.
+ */
 async function withLocations(images, includeLocation) {
-    return includeLocation ? (0, memory_1.enrichImageLocations)(images) : images;
+    if (!includeLocation)
+        return { images };
+    const result = await (0, memory_1.enrichImageLocations)(images);
+    if (result.skipped === 0)
+        return { images: result.images };
+    return {
+        images: result.images,
+        note: `The location was filled in for ${result.considered} captures; ${result.skipped} were ` +
+            'left as the listing returned them, so their missing location means "not looked up" ' +
+            'rather than "no location". Ask for fewer at a time to cover them all.',
+    };
 }
-function asMetadataListResult(images) {
+function asMetadataListResult(images, note) {
     if (!images || images.length === 0) {
         return NO_IMAGES;
     }
-    return asJsonResult(images.map(toMetadata));
+    const json = asJsonResult(images.map(toMetadata));
+    if (!note)
+        return json;
+    return { content: [...json.content, { type: 'text', text: note }] };
 }
 /**
  * A date argument, refused by throwing. The CLI reports and exits here, which
@@ -243,7 +268,8 @@ function createMcpServer() {
         if (!images || images.length === 0) {
             return NO_IMAGES;
         }
-        return asMetadataListResult(await withLocations(images, includeLocation));
+        const withLocation = await withLocations(images, includeLocation);
+        return asMetadataListResult(withLocation.images, withLocation.note);
     }));
     server.registerTool('gyazo_image', {
         title: 'Describe one Gyazo capture',
@@ -359,7 +385,8 @@ function createMcpServer() {
             hour: hour || undefined,
             alias,
         });
-        return asMetadataListResult(await withLocations(images, args.include_location));
+        const withLocation = await withLocations(images, args.include_location);
+        return asMetadataListResult(withLocation.images, withLocation.note);
     }));
     server.registerTool('gyazo_summary', {
         title: 'Summarise a stretch of Gyazo captures',
@@ -529,7 +556,8 @@ function createMcpServer() {
                 'recent pages of captures. It may be older than that, or belong to another ' +
                 'account. Ask for a window in minutes instead, or raise max_pages.');
         }
-        return asMetadataListResult(await withLocations(result.images, args.include_location));
+        const withLocation = await withLocations(result.images, args.include_location);
+        return asMetadataListResult(withLocation.images, withLocation.note);
     }));
     server.registerTool('gyazo_collections', {
         title: 'Find a Gyazo collection by name',

package/dist/services/memory.js

@@ -416,26 +416,23 @@ async function listCapturesSince(options) {
     }
     return { images: collected.slice(0, limit), pagesWalked };
 }
-/**
- * Fill in what the lean endpoints leave out.
- *
- * The listing and the search endpoints return an image without its
- * coordinates or its address, whatever the capture actually carries; only the
- * detail endpoint has them. So a caller that needs a location has to ask again
- * per image, which is what this does: the cache first, the API for the rest,
- * a few at a time, writing what it fetches back to the cache so the next look
- * is free.
- */
 async function enrichImageLocations(images, options = {}) {
     const useCache = options.useCache !== false;
     const limit = options.limit ?? 40;
-    const concurrency = Math.max(1, options.concurrency ?? 5);
+    const concurrency = Math.max(1, options.concurrency ?? 10);
     const enriched = [...images];
     const pending = [];
-    for (let index = 0; index < enriched.length && pending.length < limit; index++) {
+    let considered = 0;
+    let skipped = 0;
+    for (let index = 0; index < enriched.length; index++) {
         const image = enriched[index];
         if (image?.metadata?.exif_normalized || image?.metadata?.exif_address)
             continue;
+        if (considered >= limit) {
+            skipped++;
+            continue;
+        }
+        considered++;
         if (useCache) {
             const cached = (0, storage_1.loadImageCache)(image?.image_id);
             if (cached) {
@@ -459,5 +456,5 @@ async function enrichImageLocations(images, options = {}) {
             }
         }));
     }
-    return enriched;
+    return { images: enriched, considered, skipped };
 }

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.5.0`
+- Version: `0.5.2`
 - Description: `Gyazo Memory CLI for AI Secretary`
 
 ### 2. Commands

package/package.json

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