@yuiseki/gyazocli 0.1.1 → 0.3.0

package/dist/format.js

@@ -0,0 +1,375 @@
+"use strict";
+/**
+ * Reading and presenting the fields of a Gyazo image: the domain a capture
+ * came from, the address recorded in its EXIF, its OCR text, the objects
+ * detected in it. Nothing here talks to the API or the cache, so both the CLI
+ * and the aggregations can share it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeText = normalizeText;
+exports.extractDomain = extractDomain;
+exports.isXDomain = isXDomain;
+exports.cleanTextForDomain = cleanTextForDomain;
+exports.stripInlineUrls = stripInlineUrls;
+exports.sanitizeSummaryText = sanitizeSummaryText;
+exports.getAddressEntry = getAddressEntry;
+exports.getAddressComponent = getAddressComponent;
+exports.buildJaLocationLabel = buildJaLocationLabel;
+exports.buildEnLocationLabel = buildEnLocationLabel;
+exports.extractImageAddressText = extractImageAddressText;
+exports.extractImageLocationLabel = extractImageLocationLabel;
+exports.truncateText = truncateText;
+exports.formatCreatedAt = formatCreatedAt;
+exports.shortenImageId = shortenImageId;
+exports.formatTerminalLink = formatTerminalLink;
+exports.normalizeOcrText = normalizeOcrText;
+exports.extractOcrDescription = extractOcrDescription;
+exports.buildOcrPreview = buildOcrPreview;
+exports.extractObjectAnnotations = extractObjectAnnotations;
+exports.formatObjectAnnotationLine = formatObjectAnnotationLine;
+exports.extractImageApps = extractImageApps;
+exports.extractImageDomains = extractImageDomains;
+exports.extractImageLocations = extractImageLocations;
+exports.normalizeTagText = normalizeTagText;
+exports.extractTagFromLinkValue = extractTagFromLinkValue;
+exports.extractImageTags = extractImageTags;
+exports.normalizeRankingValues = normalizeRankingValues;
+exports.shouldEnrichForLocationDisplay = shouldEnrichForLocationDisplay;
+exports.mergeImageForDisplay = mergeImageForDisplay;
+function normalizeText(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function extractDomain(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        return url.hostname.replace(/^www\./, '');
+    }
+    catch (e) {
+        try {
+            const url = new URL(`https://${value}`);
+            return url.hostname.replace(/^www\./, '');
+        }
+        catch (_e) {
+            return undefined;
+        }
+    }
+}
+function isXDomain(domain) {
+    if (!domain)
+        return false;
+    return domain === 'x.com' ||
+        domain.endsWith('.x.com') ||
+        domain === 'twitter.com' ||
+        domain.endsWith('.twitter.com');
+}
+function cleanTextForDomain(value, domain) {
+    if (!isXDomain(domain))
+        return value;
+    return value
+        .replace(/^Xユーザーの/, '')
+        .replace(/\s*\/\s*X$/, '')
+        .trim();
+}
+function stripInlineUrls(value) {
+    return value
+        .replace(/https?:\/\/\S+/g, '')
+        .replace(/\bwww\.\S+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function sanitizeSummaryText(value, domain) {
+    if (!value)
+        return undefined;
+    return normalizeText(stripInlineUrls(cleanTextForDomain(value, domain)));
+}
+function getAddressEntry(exifAddress, locale) {
+    if (!exifAddress || typeof exifAddress !== 'object')
+        return undefined;
+    if (typeof exifAddress.address === 'string')
+        return exifAddress;
+    const entry = exifAddress[locale];
+    if (!entry || typeof entry !== 'object')
+        return undefined;
+    return entry;
+}
+function getAddressComponent(addressEntry, type) {
+    if (!addressEntry || typeof addressEntry !== 'object')
+        return undefined;
+    const components = Array.isArray(addressEntry.address_components)
+        ? addressEntry.address_components
+        : [];
+    for (const component of components) {
+        if (!component || typeof component !== 'object')
+            continue;
+        const types = Array.isArray(component.types) ? component.types : [];
+        if (!types.includes(type))
+            continue;
+        const value = normalizeText(component.long_name || component.short_name);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function buildJaLocationLabel(exifAddress) {
+    const ja = getAddressEntry(exifAddress, 'ja');
+    if (!ja)
+        return undefined;
+    const pref = getAddressComponent(ja, 'administrative_area_level_1');
+    const locality = getAddressComponent(ja, 'locality') || getAddressComponent(ja, 'administrative_area_level_2');
+    const sublocality = getAddressComponent(ja, 'sublocality_level_2') ||
+        getAddressComponent(ja, 'sublocality_level_1') ||
+        getAddressComponent(ja, 'sublocality_level_3');
+    const fromComponents = normalizeText([pref, locality, sublocality].filter(Boolean).join(''));
+    if (fromComponents)
+        return fromComponents;
+    const raw = normalizeText(ja.address);
+    if (!raw)
+        return undefined;
+    const compact = raw
+        .replace(/^日本、?/, '')
+        .replace(/〒\d{3}-\d{4}\s*/g, '')
+        .replace(/[0-9０-９].*$/, '')
+        .trim();
+    return normalizeText(compact);
+}
+function buildEnLocationLabel(exifAddress) {
+    const en = getAddressEntry(exifAddress, 'en');
+    if (!en)
+        return undefined;
+    const pref = getAddressComponent(en, 'administrative_area_level_1');
+    const locality = getAddressComponent(en, 'locality') || getAddressComponent(en, 'administrative_area_level_2');
+    const sublocality = getAddressComponent(en, 'sublocality_level_2') ||
+        getAddressComponent(en, 'sublocality_level_1') ||
+        getAddressComponent(en, 'sublocality_level_3');
+    const fromComponents = normalizeText([sublocality, locality, pref].filter(Boolean).join(', '));
+    if (fromComponents)
+        return fromComponents;
+    return normalizeText(en.address);
+}
+function extractImageAddressText(img) {
+    const exifAddress = img.metadata?.exif_address ?? img.exif_address;
+    if (!exifAddress)
+        return undefined;
+    if (typeof exifAddress === 'string')
+        return normalizeText(exifAddress);
+    if (typeof exifAddress !== 'object')
+        return undefined;
+    const ja = getAddressEntry(exifAddress, 'ja');
+    const jaAddress = normalizeText(ja?.address);
+    if (jaAddress)
+        return jaAddress;
+    const en = getAddressEntry(exifAddress, 'en');
+    const enAddress = normalizeText(en?.address);
+    if (enAddress)
+        return enAddress;
+    for (const value of Object.values(exifAddress)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = normalizeText(value.address);
+        if (raw)
+            return raw;
+    }
+    return undefined;
+}
+function extractImageLocationLabel(img) {
+    const exifAddress = img.metadata?.exif_address ?? img.exif_address;
+    if (!exifAddress)
+        return undefined;
+    if (typeof exifAddress === 'string')
+        return normalizeText(exifAddress);
+    if (typeof exifAddress !== 'object')
+        return undefined;
+    const jaLabel = buildJaLocationLabel(exifAddress);
+    if (jaLabel)
+        return jaLabel;
+    const enLabel = buildEnLocationLabel(exifAddress);
+    if (enLabel)
+        return enLabel;
+    for (const value of Object.values(exifAddress)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = normalizeText(value.address);
+        if (raw)
+            return raw;
+    }
+    return undefined;
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 3)
+        return value.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+function formatCreatedAt(value) {
+    const match = value.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})/);
+    if (match) {
+        return `${match[1]} ${match[2]}:${match[3]}`;
+    }
+    return value;
+}
+function shortenImageId(imageId) {
+    if (!imageId)
+        return '';
+    if (imageId.length <= 4)
+        return imageId;
+    return `${imageId.slice(0, 4)}...`;
+}
+function formatTerminalLink(label, url) {
+    if (!url || !process.stdout.isTTY)
+        return label;
+    return `\u001B]8;;${url}\u0007${label}\u001B]8;;\u0007`;
+}
+function normalizeOcrText(value) {
+    if (!value)
+        return undefined;
+    const normalized = value
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map(line => line.trimEnd())
+        .join('\n')
+        .trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function extractOcrDescription(image) {
+    const direct = normalizeOcrText(image?.ocr?.description);
+    if (direct)
+        return direct;
+    return normalizeOcrText(image?.metadata?.ocr?.description);
+}
+function buildOcrPreview(ocrText, maxLines) {
+    const lines = ocrText.split('\n');
+    if (lines.length <= maxLines) {
+        return { text: ocrText, truncated: false };
+    }
+    return {
+        text: lines.slice(0, maxLines).join('\n'),
+        truncated: true,
+    };
+}
+function extractObjectAnnotations(image) {
+    const rawAnnotations = image?.localizedObjectAnnotations ||
+        image?.localized_object_annotations ||
+        image?.metadata?.localizedObjectAnnotations ||
+        image?.metadata?.localized_object_annotations ||
+        [];
+    if (!Array.isArray(rawAnnotations))
+        return [];
+    const bestByName = new Map();
+    for (const annotation of rawAnnotations) {
+        if (!annotation || typeof annotation !== 'object')
+            continue;
+        const name = normalizeText(annotation.name_ja || annotation.nameJa || annotation.name);
+        if (!name)
+            continue;
+        const score = typeof annotation.score === 'number' ? annotation.score : undefined;
+        const existing = bestByName.get(name);
+        if (!existing) {
+            bestByName.set(name, { name, score });
+            continue;
+        }
+        const existingScore = existing.score ?? -1;
+        const nextScore = score ?? -1;
+        if (nextScore > existingScore) {
+            bestByName.set(name, { name, score });
+        }
+    }
+    return Array.from(bestByName.values()).sort((a, b) => {
+        const sa = a.score ?? -1;
+        const sb = b.score ?? -1;
+        return sb - sa;
+    });
+}
+function formatObjectAnnotationLine(annotation) {
+    if (typeof annotation.score === 'number') {
+        return `${annotation.name} (${(annotation.score * 100).toFixed(1)}%)`;
+    }
+    return annotation.name;
+}
+function extractImageApps(image) {
+    const app = normalizeText(image?.metadata?.app);
+    return app ? [app] : [];
+}
+function extractImageDomains(image) {
+    const domain = extractDomain(normalizeText(image?.metadata?.url));
+    return domain ? [domain] : [];
+}
+function extractImageLocations(image) {
+    const location = normalizeText(extractImageLocationLabel(image));
+    return location ? [location] : [];
+}
+function normalizeTagText(value) {
+    if (!value)
+        return undefined;
+    const normalized = normalizeText(value);
+    if (!normalized)
+        return undefined;
+    const stripped = normalized.replace(/^[#＃]+/, '').trim();
+    return stripped.length > 0 ? stripped : undefined;
+}
+function extractTagFromLinkValue(value) {
+    if (typeof value === 'string') {
+        return normalizeTagText(value);
+    }
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidates = [
+        value.tag,
+        value.name,
+        value.title,
+        value.text,
+        value.keyword,
+    ];
+    for (const candidate of candidates) {
+        const tag = normalizeTagText(candidate);
+        if (tag)
+            return tag;
+    }
+    return undefined;
+}
+function extractImageTags(image) {
+    const rawLinks = image?.metadata?.links ?? image?.links;
+    if (!Array.isArray(rawLinks))
+        return [];
+    const tags = [];
+    for (const rawLink of rawLinks) {
+        const tag = extractTagFromLinkValue(rawLink);
+        if (tag)
+            tags.push(tag);
+    }
+    return normalizeRankingValues(tags);
+}
+function normalizeRankingValues(values) {
+    const uniqueByLower = new Map();
+    for (const raw of values) {
+        const value = normalizeText(raw);
+        if (!value)
+            continue;
+        const key = value.toLocaleLowerCase();
+        if (!uniqueByLower.has(key)) {
+            uniqueByLower.set(key, value);
+        }
+    }
+    return Array.from(uniqueByLower.values());
+}
+function shouldEnrichForLocationDisplay(img) {
+    const locationLabel = sanitizeSummaryText(extractImageLocationLabel(img));
+    return !locationLabel;
+}
+function mergeImageForDisplay(base, detail) {
+    return {
+        ...base,
+        ...detail,
+        metadata: {
+            ...(base?.metadata || {}),
+            ...(detail?.metadata || {}),
+        },
+        ocr: detail?.ocr ?? base?.ocr,
+    };
+}

package/dist/ids.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Turning what a human or an agent typed into a Gyazo ID. Kept apart from the
+ * CLI itself so that other entry points, such as the MCP server, can reuse it
+ * without loading commander and its commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeImageId = normalizeImageId;
+exports.normalizeCollectionId = normalizeCollectionId;
+const IMAGE_ID_PATTERN = /^[0-9a-f]{32}$/i;
+const GYAZO_HOST_PATTERN = /(^|\.)gyazo\.com$/i;
+/**
+ * Accept either a bare Gyazo image id (32 hex characters) or any Gyazo URL that
+ * carries one, and return the canonical lowercase id. Returns null otherwise.
+ */
+function normalizeImageId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment)
+        return null;
+    // /collections/<id> is a collection, not an image.
+    if (segments[segments.length - 2] === 'collections')
+        return null;
+    const withoutExtension = lastSegment.replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}
+/**
+ * A collection ID looks exactly like an image ID (32 hex characters), so only
+ * the URL form tells the two apart. `/collections/<id>` is a collection;
+ * `/<id>` is an image.
+ */
+function normalizeCollectionId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    if (segments.length < 2 || segments[segments.length - 2] !== 'collections') {
+        return null;
+    }
+    const withoutExtension = segments[segments.length - 1].replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}