@yuiseki/gyazocli 0.0.1

package/dist/index.js

@@ -0,0 +1,1903 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("./api");
+const storage_1 = require("./storage");
+const credentials_1 = require("./credentials");
+const program = new commander_1.Command();
+const UPLOAD_DESC_TAG = '#gyazocli_uploads';
+const WEEKDAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+program
+    .name('gyazo')
+    .description('Gyazo Memory CLI for AI Secretary')
+    .version('0.0.1');
+// Config Command
+const configCmd = program.command('config').description('Manage configuration');
+configCmd
+    .command('set <key> <value>')
+    .description('Set a configuration value')
+    .action((key, value) => {
+    (0, credentials_1.setStoredConfig)(key, value);
+});
+configCmd
+    .command('get <key>')
+    .description('Get a configuration value')
+    .option('-j, --json', 'output as JSON')
+    .action(async (key, options) => {
+    if (key === 'me') {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const me = await (0, api_1.getCurrentUser)();
+            if (options.json) {
+                console.log(JSON.stringify(me, null, 2));
+                return;
+            }
+            const user = me?.user || {};
+            if (user.uid)
+                console.log(`UID: ${user.uid}`);
+            if (user.name)
+                console.log(`Name: ${user.name}`);
+            if (user.email)
+                console.log(`Email: ${user.email}`);
+            if (typeof user.is_pro === 'boolean')
+                console.log(`Plan: ${user.is_pro ? 'Pro' : 'Free'}`);
+            if (typeof user.is_team === 'boolean')
+                console.log(`Team: ${user.is_team ? 'Yes' : 'No'}`);
+            if (user.profile_image)
+                console.log(`Profile image: ${user.profile_image}`);
+        }
+        catch (error) {
+            console.error('Error getting current user:', error.message);
+            process.exit(1);
+        }
+        return;
+    }
+    const value = (0, credentials_1.getStoredConfig)(key);
+    if (value) {
+        if (key === 'token') {
+            const masked = value.length > 8
+                ? `${value.substring(0, 4)}...${value.substring(value.length - 4)}`
+                : '********';
+            console.log(masked);
+        }
+        else {
+            console.log(value);
+        }
+    }
+    else {
+        console.error(`Config key '${key}' not found.`);
+        process.exit(1);
+    }
+});
+function isToday(date) {
+    const today = new Date();
+    return date.getDate() === today.getDate() &&
+        date.getMonth() === today.getMonth() &&
+        date.getFullYear() === today.getFullYear();
+}
+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 ensureUploadDescTag(desc) {
+    const normalized = normalizeText(desc);
+    if (!normalized)
+        return UPLOAD_DESC_TAG;
+    const words = normalized
+        .split(' ')
+        .filter(word => word.toLowerCase() !== UPLOAD_DESC_TAG.toLowerCase());
+    words.push(UPLOAD_DESC_TAG);
+    return words.join(' ').trim();
+}
+function parseUploadTimestamp(value) {
+    if (!value)
+        return undefined;
+    if (!/^\d+$/.test(value)) {
+        console.error('Error: --timestamp must be a unix timestamp in seconds.');
+        process.exit(1);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        console.error('Error: --timestamp is out of range.');
+        process.exit(1);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    if (parsed > now) {
+        console.error('Error: --timestamp must be current time or in the past.');
+        process.exit(1);
+    }
+    return parsed;
+}
+function parsePositiveIntegerOption(value, optionName) {
+    if (!/^\d+$/.test(value)) {
+        console.error(`Error: ${optionName} must be a positive integer.`);
+        process.exit(1);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        console.error(`Error: ${optionName} must be a positive integer.`);
+        process.exit(1);
+    }
+    return parsed;
+}
+function parseDateOption(value) {
+    if (!value) {
+        const today = new Date();
+        const year = String(today.getFullYear());
+        const month = String(today.getMonth() + 1).padStart(2, '0');
+        const day = String(today.getDate()).padStart(2, '0');
+        return {
+            granularity: 'day',
+            dateKey: `${year}-${month}-${day}`,
+            start: new Date(today.getFullYear(), today.getMonth(), today.getDate(), 0, 0, 0, 0),
+            end: new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999),
+        };
+    }
+    if (/^\d{4}$/.test(value)) {
+        const year = Number(value);
+        return {
+            granularity: 'year',
+            dateKey: value,
+            start: new Date(year, 0, 1, 0, 0, 0, 0),
+            end: new Date(year, 11, 31, 23, 59, 59, 999),
+        };
+    }
+    if (/^\d{4}-\d{2}$/.test(value)) {
+        const [yearText, monthText] = value.split('-');
+        const year = Number(yearText);
+        const month = Number(monthText);
+        const probe = new Date(year, month - 1, 1);
+        if (probe.getFullYear() !== year || probe.getMonth() !== month - 1) {
+            console.error('Error: --date month is invalid.');
+            process.exit(1);
+        }
+        return {
+            granularity: 'month',
+            dateKey: value,
+            start: new Date(year, month - 1, 1, 0, 0, 0, 0),
+            end: new Date(year, month, 0, 23, 59, 59, 999),
+        };
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        const [yearText, monthText, dayText] = value.split('-');
+        const year = Number(yearText);
+        const month = Number(monthText);
+        const day = Number(dayText);
+        const probe = new Date(year, month - 1, day);
+        if (probe.getFullYear() !== year ||
+            probe.getMonth() !== month - 1 ||
+            probe.getDate() !== day) {
+            console.error('Error: --date day is invalid.');
+            process.exit(1);
+        }
+        return {
+            granularity: 'day',
+            dateKey: value,
+            start: new Date(year, month - 1, day, 0, 0, 0, 0),
+            end: new Date(year, month - 1, day, 23, 59, 59, 999),
+        };
+    }
+    console.error('Error: --date format must be yyyy or yyyy-mm or yyyy-mm-dd.');
+    process.exit(1);
+}
+function formatDateYmd(date) {
+    const year = String(date.getFullYear());
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function buildRecentWeekRangeUntilYesterday() {
+    const today = new Date();
+    const end = new Date(today.getFullYear(), today.getMonth(), today.getDate() - 1, 23, 59, 59, 999);
+    const start = new Date(today.getFullYear(), today.getMonth(), today.getDate() - 8, 0, 0, 0, 0);
+    return {
+        granularity: 'day',
+        dateKey: `${formatDateYmd(start)}..${formatDateYmd(end)}`,
+        start,
+        end,
+    };
+}
+function resolveRankingRangeOption(options) {
+    if (options.today && options.date) {
+        console.error('Error: --today and --date cannot be used together.');
+        process.exit(1);
+    }
+    if (options.today) {
+        return parseDateOption();
+    }
+    if (options.date) {
+        return parseDateOption(options.date);
+    }
+    return buildRecentWeekRangeUntilYesterday();
+}
+function buildStatsDateRange(dateOption, daysOption) {
+    if (!dateOption && daysOption === '7') {
+        const weekly = buildRecentWeekRangeUntilYesterday();
+        return {
+            range: weekly,
+            days: 7,
+            startLabel: formatDateYmd(weekly.start),
+            endLabel: formatDateYmd(weekly.end),
+        };
+    }
+    const days = parsePositiveIntegerOption(daysOption, '--days');
+    let endDate;
+    if (dateOption) {
+        const parsed = parseDateOption(dateOption);
+        endDate = new Date(parsed.end);
+    }
+    else {
+        const now = new Date();
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, 23, 59, 59, 999);
+    }
+    const startDate = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate(), 0, 0, 0, 0);
+    startDate.setDate(startDate.getDate() - (days - 1));
+    const startLabel = formatDateYmd(startDate);
+    const endLabel = formatDateYmd(endDate);
+    return {
+        range: {
+            granularity: 'day',
+            dateKey: `${startLabel}..${endLabel}`,
+            start: startDate,
+            end: endDate,
+        },
+        days,
+        startLabel,
+        endLabel,
+    };
+}
+function getDateHourStrings() {
+    const hours = [];
+    for (let hour = 0; hour < 24; hour++) {
+        hours.push(String(hour).padStart(2, '0'));
+    }
+    return hours;
+}
+function buildHourlyBucketKey(year, month, day, hour) {
+    return `${year}-${month}-${day}-${hour}`;
+}
+function splitHourlyBucketKey(key) {
+    const [year, month, day, hour] = key.split('-');
+    return { year, month, day, hour };
+}
+function toDateParts(date) {
+    return {
+        year: String(date.getFullYear()),
+        month: String(date.getMonth() + 1).padStart(2, '0'),
+        day: String(date.getDate()).padStart(2, '0'),
+        hour: String(date.getHours()).padStart(2, '0'),
+    };
+}
+function getDatePartsInRange(start, end) {
+    const dates = [];
+    const cursor = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, 0, 0, 0);
+    const last = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 0, 0, 0, 0);
+    while (cursor.getTime() <= last.getTime()) {
+        dates.push({
+            year: String(cursor.getFullYear()),
+            month: String(cursor.getMonth() + 1).padStart(2, '0'),
+            day: String(cursor.getDate()).padStart(2, '0'),
+        });
+        cursor.setDate(cursor.getDate() + 1);
+    }
+    return dates;
+}
+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 normalizeHourlyMetadataEntries(valuesByImageId) {
+    if (!valuesByImageId || typeof valuesByImageId !== 'object')
+        return {};
+    const normalized = {};
+    for (const [imageId, rawValues] of Object.entries(valuesByImageId)) {
+        const values = Array.isArray(rawValues)
+            ? rawValues.map(value => String(value))
+            : [];
+        normalized[imageId] = normalizeRankingValues(values);
+    }
+    return normalized;
+}
+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);
+}
+async function warmDateCacheForApps(targetDate, maxPages, useCache) {
+    return warmDateCacheForRanking(targetDate, maxPages, useCache, 'apps', extractImageApps);
+}
+async function warmDateCacheForDomains(targetDate, maxPages, useCache) {
+    return warmDateCacheForRanking(targetDate, maxPages, useCache, 'domains', extractImageDomains);
+}
+async function warmDateCacheForTags(targetDate, maxPages, useCache) {
+    return warmDateCacheForRanking(targetDate, maxPages, useCache, 'tags', extractImageTags);
+}
+async function warmDateCacheForLocations(targetDate, maxPages, useCache) {
+    return warmDateCacheForRanking(targetDate, maxPages, useCache, 'locations', extractImageLocations);
+}
+async function warmDateCacheForRanking(targetDate, maxPages, useCache, metadataKind, extractValues) {
+    const hourlyIndices = new Map();
+    const hourlyMetadataEntries = new Map();
+    const existingHourlyMetadataEntries = new Map();
+    const imageIds = new Set();
+    for (let page = 1; page <= maxPages; page++) {
+        const images = 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 (Number.isNaN(createdAt.getTime()))
+                continue;
+            if (createdAt > targetDate.end)
+                continue;
+            if (createdAt < targetDate.start) {
+                reachedLimit = true;
+                break;
+            }
+            const dateParts = toDateParts(createdAt);
+            const bucketKey = buildHourlyBucketKey(dateParts.year, dateParts.month, dateParts.day, dateParts.hour);
+            if (!hourlyIndices.has(bucketKey)) {
+                hourlyIndices.set(bucketKey, new Set());
+            }
+            if (!hourlyMetadataEntries.has(bucketKey)) {
+                hourlyMetadataEntries.set(bucketKey, new Map());
+            }
+            hourlyIndices.get(bucketKey)?.add(img.image_id);
+            imageIds.add(img.image_id);
+            let merged = img;
+            const cached = useCache ? (0, storage_1.loadImageCache)(img.image_id) : null;
+            if (cached) {
+                merged = mergeImageForDisplay(img, cached);
+            }
+            let values;
+            let hasExistingMetadataEntry = false;
+            if (useCache) {
+                let existingForBucket = existingHourlyMetadataEntries.get(bucketKey);
+                if (!existingForBucket) {
+                    existingForBucket = normalizeHourlyMetadataEntries((0, storage_1.loadHourlyMetadataCache)(metadataKind, dateParts.year, dateParts.month, dateParts.day, dateParts.hour));
+                    existingHourlyMetadataEntries.set(bucketKey, existingForBucket);
+                }
+                if (Object.prototype.hasOwnProperty.call(existingForBucket, img.image_id)) {
+                    values = existingForBucket[img.image_id];
+                    hasExistingMetadataEntry = true;
+                }
+            }
+            if (!values) {
+                values = normalizeRankingValues(extractValues(merged));
+            }
+            if (values.length === 0 && !hasExistingMetadataEntry) {
+                try {
+                    const detail = await (0, api_1.getImageDetail)(img.image_id);
+                    merged = mergeImageForDisplay(merged, detail);
+                    values = normalizeRankingValues(extractValues(merged));
+                }
+                catch (_error) {
+                    // Keep best effort result when detail fetch fails.
+                }
+            }
+            (0, storage_1.saveImageCache)(img.image_id, merged);
+            hourlyMetadataEntries.get(bucketKey)?.set(img.image_id, values);
+        }
+        if (reachedLimit)
+            break;
+    }
+    for (const [bucketKey, current] of hourlyIndices.entries()) {
+        const { year, month, day, hour } = splitHourlyBucketKey(bucketKey);
+        if (useCache) {
+            const existing = (0, storage_1.loadHourlyCache)(year, month, day, hour) || [];
+            for (const id of existing)
+                current.add(id);
+        }
+        (0, storage_1.saveHourlyCache)(year, month, day, hour, Array.from(current));
+        for (const id of current)
+            imageIds.add(id);
+        const mergedMetadataEntries = useCache
+            ? normalizeHourlyMetadataEntries((0, storage_1.loadHourlyMetadataCache)(metadataKind, year, month, day, hour))
+            : {};
+        const currentMetadataEntries = hourlyMetadataEntries.get(bucketKey) || new Map();
+        for (const [imageId, values] of currentMetadataEntries.entries()) {
+            mergedMetadataEntries[imageId] = values;
+        }
+        (0, storage_1.saveHourlyMetadataCache)(metadataKind, year, month, day, hour, mergedMetadataEntries);
+    }
+    if (useCache) {
+        const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+        const hours = getDateHourStrings();
+        for (const date of dates) {
+            for (const hour of hours) {
+                const existing = (0, storage_1.loadHourlyCache)(date.year, date.month, date.day, hour) || [];
+                for (const id of existing)
+                    imageIds.add(id);
+            }
+        }
+    }
+    return Array.from(imageIds);
+}
+function buildHourlyMetadataEntriesFromImageCache(year, month, day, hour, extractValues) {
+    const imageIds = (0, storage_1.loadHourlyCache)(year, month, day, hour) || [];
+    const valuesByImageId = {};
+    for (const imageId of imageIds) {
+        const image = (0, storage_1.loadImageCache)(imageId);
+        if (!image)
+            continue;
+        valuesByImageId[imageId] = normalizeRankingValues(extractValues(image));
+    }
+    return valuesByImageId;
+}
+function loadOrBuildHourlyMetadataEntries(metadataKind, year, month, day, hour, extractValues) {
+    const rawCached = (0, storage_1.loadHourlyMetadataCache)(metadataKind, year, month, day, hour);
+    if (rawCached !== null) {
+        return normalizeHourlyMetadataEntries(rawCached);
+    }
+    const built = buildHourlyMetadataEntriesFromImageCache(year, month, day, hour, extractValues);
+    const hasHourlyIndex = Boolean((0, storage_1.loadHourlyCache)(year, month, day, hour));
+    if (hasHourlyIndex || Object.keys(built).length > 0) {
+        (0, storage_1.saveHourlyMetadataCache)(metadataKind, year, month, day, hour, built);
+    }
+    return built;
+}
+function aggregateRankingFromHourlyMetadataCache(targetDate, metadataKind, extractValues) {
+    const counts = new Map();
+    const seenImageIds = new Set();
+    let totalImages = 0;
+    let imageCountWithValues = 0;
+    let totalAssignments = 0;
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const hours = getDateHourStrings();
+    for (const date of dates) {
+        for (const hour of hours) {
+            const entries = loadOrBuildHourlyMetadataEntries(metadataKind, date.year, date.month, date.day, hour, extractValues);
+            for (const [imageId, values] of Object.entries(entries)) {
+                if (seenImageIds.has(imageId))
+                    continue;
+                seenImageIds.add(imageId);
+                totalImages++;
+                if (values.length === 0)
+                    continue;
+                imageCountWithValues++;
+                totalAssignments += values.length;
+                for (const value of values) {
+                    counts.set(value, (counts.get(value) || 0) + 1);
+                }
+            }
+        }
+    }
+    const ranking = Array.from(counts.entries())
+        .map(([key, count]) => ({ key, count }))
+        .sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.key.localeCompare(b.key);
+    });
+    return {
+        ranking,
+        totalImages,
+        imageCountWithValues,
+        totalAssignments,
+    };
+}
+function buildAppsRankingFromCache(imageIds) {
+    const counts = new Map();
+    for (const imageId of imageIds) {
+        const image = (0, storage_1.loadImageCache)(imageId);
+        const apps = extractImageApps(image);
+        if (apps.length === 0)
+            continue;
+        const app = apps[0];
+        counts.set(app, (counts.get(app) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .map(([app, count]) => ({ app, count }))
+        .sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.app.localeCompare(b.app);
+    });
+}
+function buildAppsRankingFromHourlyCache(targetDate) {
+    const summary = aggregateRankingFromHourlyMetadataCache(targetDate, 'apps', extractImageApps);
+    return {
+        ranking: summary.ranking.map(item => ({ app: item.key, count: item.count })),
+        totalImages: summary.totalImages,
+        imageCountWithApps: summary.imageCountWithValues,
+    };
+}
+function buildDomainsRankingFromCache(imageIds) {
+    const counts = new Map();
+    for (const imageId of imageIds) {
+        const image = (0, storage_1.loadImageCache)(imageId);
+        const domains = extractImageDomains(image);
+        if (domains.length === 0)
+            continue;
+        const domain = domains[0];
+        counts.set(domain, (counts.get(domain) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .map(([domain, count]) => ({ domain, count }))
+        .sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.domain.localeCompare(b.domain);
+    });
+}
+function buildDomainsRankingFromHourlyCache(targetDate) {
+    const summary = aggregateRankingFromHourlyMetadataCache(targetDate, 'domains', extractImageDomains);
+    return {
+        ranking: summary.ranking.map(item => ({ domain: item.key, count: item.count })),
+        totalImages: summary.totalImages,
+        imageCountWithDomains: summary.imageCountWithValues,
+    };
+}
+function buildLocationsRankingFromCache(imageIds) {
+    const counts = new Map();
+    for (const imageId of imageIds) {
+        const image = (0, storage_1.loadImageCache)(imageId);
+        const locations = extractImageLocations(image);
+        if (locations.length === 0)
+            continue;
+        const location = locations[0];
+        counts.set(location, (counts.get(location) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .map(([location, count]) => ({ location, count }))
+        .sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.location.localeCompare(b.location);
+    });
+}
+function buildLocationsRankingFromHourlyCache(targetDate) {
+    const summary = aggregateRankingFromHourlyMetadataCache(targetDate, 'locations', extractImageLocations);
+    return {
+        ranking: summary.ranking.map(item => ({ location: item.key, count: item.count })),
+        totalImages: summary.totalImages,
+        imageCountWithLocations: summary.imageCountWithValues,
+    };
+}
+function buildTagsRankingFromCache(imageIds) {
+    const counts = new Map();
+    let imageCountWithTags = 0;
+    let totalTagAssignments = 0;
+    for (const imageId of imageIds) {
+        const image = (0, storage_1.loadImageCache)(imageId);
+        const tags = extractImageTags(image);
+        if (tags.length === 0)
+            continue;
+        imageCountWithTags++;
+        for (const tag of tags) {
+            counts.set(tag, (counts.get(tag) || 0) + 1);
+            totalTagAssignments++;
+        }
+    }
+    const ranking = Array.from(counts.entries())
+        .map(([tag, count]) => ({ tag, count }))
+        .sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.tag.localeCompare(b.tag);
+    });
+    return {
+        ranking,
+        imageCountWithTags,
+        totalTagAssignments,
+    };
+}
+function buildTagsRankingFromHourlyCache(targetDate) {
+    const summary = aggregateRankingFromHourlyMetadataCache(targetDate, 'tags', extractImageTags);
+    return {
+        ranking: summary.ranking.map(item => ({ tag: item.key, count: item.count })),
+        totalImages: summary.totalImages,
+        imageCountWithTags: summary.imageCountWithValues,
+        totalTagAssignments: summary.totalAssignments,
+    };
+}
+function buildUploadTimeSummaryFromHourlyCache(targetDate) {
+    const seen = new Set();
+    const hourCounts = Array.from({ length: 24 }, (_, hour) => ({ hour, count: 0 }));
+    const weekdayCounts = Array.from({ length: 7 }, (_, weekday) => ({ weekday, count: 0 }));
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const hours = getDateHourStrings();
+    for (const date of dates) {
+        for (const hourText of hours) {
+            const hour = Number(hourText);
+            const imageIds = (0, storage_1.loadHourlyCache)(date.year, date.month, date.day, hourText) || [];
+            const weekday = new Date(Number(date.year), Number(date.month) - 1, Number(date.day), hour, 0, 0, 0).getDay();
+            for (const imageId of imageIds) {
+                if (seen.has(imageId))
+                    continue;
+                seen.add(imageId);
+                hourCounts[hour].count++;
+                weekdayCounts[weekday].count++;
+            }
+        }
+    }
+    return {
+        totalImages: seen.size,
+        byHour: hourCounts.sort((a, b) => {
+            if (b.count !== a.count)
+                return b.count - a.count;
+            return a.hour - b.hour;
+        }),
+        byWeekday: weekdayCounts.sort((a, b) => {
+            if (b.count !== a.count)
+                return b.count - a.count;
+            return a.weekday - b.weekday;
+        }),
+    };
+}
+function buildUploadTimeSummaryFromImageCache(imageIds, targetDate) {
+    const seen = new Set();
+    const hourCounts = Array.from({ length: 24 }, (_, hour) => ({ hour, count: 0 }));
+    const weekdayCounts = Array.from({ length: 7 }, (_, weekday) => ({ weekday, count: 0 }));
+    for (const imageId of imageIds) {
+        if (seen.has(imageId))
+            continue;
+        const image = (0, storage_1.loadImageCache)(imageId);
+        const createdAtText = normalizeText(image?.created_at);
+        if (!createdAtText)
+            continue;
+        const createdAt = new Date(createdAtText);
+        if (Number.isNaN(createdAt.getTime()))
+            continue;
+        if (createdAt < targetDate.start || createdAt > targetDate.end)
+            continue;
+        seen.add(imageId);
+        hourCounts[createdAt.getHours()].count++;
+        weekdayCounts[createdAt.getDay()].count++;
+    }
+    return {
+        totalImages: seen.size,
+        byHour: hourCounts.sort((a, b) => {
+            if (b.count !== a.count)
+                return b.count - a.count;
+            return a.hour - b.hour;
+        }),
+        byWeekday: weekdayCounts.sort((a, b) => {
+            if (b.count !== a.count)
+                return b.count - a.count;
+            return a.weekday - b.weekday;
+        }),
+    };
+}
+function appendStatsRankSection(lines, title, rows, top) {
+    lines.push(`### ${title}`);
+    const filtered = rows.filter(row => row.count > 0).slice(0, top);
+    if (filtered.length === 0) {
+        lines.push('- No data');
+        lines.push('');
+        return;
+    }
+    for (const row of filtered) {
+        lines.push(`- ${row.label}: ${row.count}`);
+    }
+    lines.push('');
+}
+function renderStatsMarkdown(params) {
+    const lines = [];
+    lines.push('## Gyazo Stats');
+    lines.push('');
+    lines.push(`- Window: ${params.startLabel} to ${params.endLabel} (${params.days} days)`);
+    lines.push(`- Total uploads: ${params.totalUploads}`);
+    lines.push('');
+    appendStatsRankSection(lines, 'Upload Time (Hour)', params.uploadTime.byHour.map(item => ({
+        label: `${String(item.hour).padStart(2, '0')}:00`,
+        count: item.count,
+    })), params.top);
+    appendStatsRankSection(lines, 'Upload Weekday', params.uploadTime.byWeekday.map(item => ({
+        label: WEEKDAY_LABELS[item.weekday] || String(item.weekday),
+        count: item.count,
+    })), Math.min(params.top, 7));
+    appendStatsRankSection(lines, 'Apps', params.apps.map(item => ({ label: item.app, count: item.count })), params.top);
+    appendStatsRankSection(lines, 'Domains', params.domains.map(item => ({ label: item.domain, count: item.count })), params.top);
+    appendStatsRankSection(lines, 'Tags', params.tags.map(item => ({ label: `#${item.tag}`, count: item.count })), params.top);
+    return lines.join('\n').trimEnd();
+}
+async function readStdinBuffer() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on('data', (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks)));
+        process.stdin.on('error', reject);
+    });
+}
+function printGetMarkdown(image, ocrDescription, objects = []) {
+    const lines = [];
+    lines.push('## Gyazo Image');
+    lines.push('');
+    lines.push(`- URL: <${image.permalink_url}>`);
+    lines.push(`- Created at: ${formatCreatedAt(image.created_at)}`);
+    const title = normalizeText(image.metadata?.title);
+    if (title)
+        lines.push(`- Title: ${title}`);
+    const address = extractImageAddressText(image);
+    if (address)
+        lines.push(`- Address: ${address}`);
+    const altText = normalizeText(image.alt_text);
+    if (altText)
+        lines.push(`- Alt text: ${altText}`);
+    if (objects.length > 0) {
+        lines.push('');
+        lines.push('### Objects');
+        for (const object of objects) {
+            lines.push(`- ${formatObjectAnnotationLine(object)}`);
+        }
+    }
+    if (ocrDescription) {
+        const preview = buildOcrPreview(ocrDescription, 5);
+        lines.push('');
+        lines.push('### OCR');
+        lines.push('```text');
+        lines.push(preview.text);
+        lines.push('```');
+        if (preview.truncated) {
+            lines.push('');
+            lines.push(`> Truncated to first 5 lines. Use \`gyazo get --ocr ${image.image_id}\` for full text.`);
+        }
+    }
+    console.log(lines.join('\n'));
+}
+function summarizeImageForList(img) {
+    const domain = extractDomain(normalizeText(img.metadata?.url));
+    const cleanedTitle = sanitizeSummaryText(img.metadata?.title, domain);
+    const cleanedDesc = sanitizeSummaryText(img.metadata?.desc, domain);
+    const locationLabel = sanitizeSummaryText(extractImageLocationLabel(img));
+    const cleanedAltText = sanitizeSummaryText(img.alt_text);
+    let main = '(no title/description)';
+    if (cleanedTitle && cleanedDesc) {
+        main = `${cleanedTitle} | ${cleanedDesc}`;
+    }
+    else if (cleanedTitle) {
+        main = cleanedTitle;
+    }
+    else if (cleanedDesc) {
+        main = cleanedDesc;
+    }
+    if (cleanedAltText) {
+        if (main === '(no title/description)') {
+            main = cleanedAltText;
+        }
+        else if (cleanedAltText !== main) {
+            main = `${main} | alt: ${cleanedAltText}`;
+        }
+    }
+    const prefixes = [];
+    if (domain)
+        prefixes.push(`[${domain}]`);
+    if (locationLabel)
+        prefixes.push(`[${locationLabel}]`);
+    if (main === '(no title/description)') {
+        if (prefixes.length > 0)
+            return prefixes.join(' ');
+        return main;
+    }
+    if (prefixes.length > 0) {
+        return `${prefixes.join(' ')} ${main}`;
+    }
+    return main;
+}
+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,
+    };
+}
+function cacheSearchResultImages(images) {
+    for (const img of images) {
+        if (!img?.image_id)
+            continue;
+        (0, storage_1.saveSearchImageCache)(img.image_id, img);
+    }
+}
+function supplementAltTextFromSearchCache(image, useCache = true) {
+    const hasAltText = Boolean(normalizeText(image.alt_text));
+    if (hasAltText)
+        return { image, supplemented: false };
+    if (!useCache)
+        return { image, supplemented: false };
+    const cached = (0, storage_1.loadSearchImageCache)(image.image_id);
+    const cachedAltText = normalizeText(cached?.alt_text);
+    const cachedHasAltText = Boolean(cachedAltText);
+    if (!cachedHasAltText)
+        return { image, supplemented: false };
+    return {
+        image: {
+            ...image,
+            alt_text: cachedAltText,
+        },
+        supplemented: true,
+    };
+}
+function supplementAltTextForDisplay(images, useCache = true) {
+    return images.map(img => supplementAltTextFromSearchCache(img, useCache).image);
+}
+async function prepareImagesForDisplay(images, options = {}) {
+    const useCache = options.useCache !== false;
+    if (options.cacheSearchResults) {
+        cacheSearchResultImages(images);
+    }
+    let prepared = images;
+    if (options.enrichLocation) {
+        prepared = await enrichImagesForLocationDisplay(prepared, useCache);
+    }
+    prepared = supplementAltTextForDisplay(prepared, useCache);
+    return prepared;
+}
+async function enrichImagesForLocationDisplay(images, useCache = true) {
+    const enriched = [];
+    for (const img of images) {
+        let current = img;
+        if (!shouldEnrichForLocationDisplay(current)) {
+            enriched.push(current);
+            continue;
+        }
+        if (useCache) {
+            const cached = (0, storage_1.loadImageCache)(img.image_id);
+            if (cached) {
+                current = mergeImageForDisplay(current, cached);
+            }
+        }
+        if (!shouldEnrichForLocationDisplay(current)) {
+            enriched.push(current);
+            continue;
+        }
+        try {
+            const detail = await (0, api_1.getImageDetail)(img.image_id);
+            (0, storage_1.saveImageCache)(img.image_id, detail);
+            current = mergeImageForDisplay(current, detail);
+        }
+        catch (_error) {
+            // Keep current data when detail fetch fails.
+        }
+        enriched.push(current);
+    }
+    return enriched;
+}
+function printListImages(images) {
+    images.forEach(img => {
+        const summary = truncateText(summarizeImageForList(img), 120);
+        const created = formatCreatedAt(img.created_at);
+        const shortId = shortenImageId(img.image_id);
+        const imageUrl = img.permalink_url || `https://gyazo.com/${img.image_id}`;
+        const linkedId = formatTerminalLink(shortId, imageUrl);
+        console.log(`- [${created}] ${summary} (id: ${linkedId})`);
+    });
+}
+program
+    .command('list')
+    .alias('ls')
+    .description('List recent images')
+    .option('-p, --page <number>', 'page number', '1')
+    .option('-l, --limit <number>', 'items per page', '20')
+    .option('-j, --json', 'output as JSON')
+    .option('-H, --hour <yyyy-mm-dd-hh>', 'target hour')
+    .option('--photos', 'alias of search "has:location"')
+    .option('--uploaded', 'alias of search "gyazocli_uploads"')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const useCache = options.cache !== false;
+        if (options.photos && options.uploaded) {
+            console.error('Error: --photos and --uploaded cannot be used together.');
+            process.exit(1);
+        }
+        if ((options.photos || options.uploaded) && options.hour) {
+            console.error('Error: --photos/--uploaded and --hour cannot be used together.');
+            process.exit(1);
+        }
+        const aliasQuery = options.photos
+            ? 'has:location'
+            : options.uploaded
+                ? 'gyazocli_uploads'
+                : undefined;
+        if (aliasQuery) {
+            const images = await (0, api_1.searchImages)(aliasQuery, parseInt(options.page, 10), parseInt(options.limit, 10));
+            if (options.json) {
+                console.log(JSON.stringify(images, null, 2));
+            }
+            else {
+                const imagesForDisplay = await prepareImagesForDisplay(images, {
+                    cacheSearchResults: true,
+                    enrichLocation: true,
+                    useCache,
+                });
+                printListImages(imagesForDisplay);
+            }
+            return;
+        }
+        if (options.hour) {
+            const parts = options.hour.split('-');
+            if (parts.length !== 4) {
+                console.error('Error: hour format must be yyyy-mm-dd-hh');
+                process.exit(1);
+            }
+            const [year, month, day, hour] = parts;
+            const imageIds = (0, storage_1.loadHourlyCache)(year, month, day, hour);
+            if (!imageIds) {
+                console.log(`No images found for ${options.hour} in cache.`);
+                return;
+            }
+            let images = [];
+            if (useCache) {
+                images = imageIds.map(id => (0, storage_1.loadImageCache)(id)).filter(img => img !== null);
+            }
+            else {
+                for (const imageId of imageIds) {
+                    try {
+                        const detail = await (0, api_1.getImageDetail)(imageId);
+                        (0, storage_1.saveImageCache)(imageId, detail);
+                        images.push(detail);
+                    }
+                    catch (_error) {
+                        // Skip failed items and continue with the rest.
+                    }
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify(images, null, 2));
+            }
+            else {
+                const imagesForDisplay = await prepareImagesForDisplay(images, {
+                    enrichLocation: true,
+                    useCache,
+                });
+                printListImages(imagesForDisplay);
+            }
+            return;
+        }
+        const images = await (0, api_1.listImages)(parseInt(options.page, 10), parseInt(options.limit, 10));
+        if (options.json) {
+            console.log(JSON.stringify(images, null, 2));
+        }
+        else {
+            const imagesForDisplay = await prepareImagesForDisplay(images, {
+                enrichLocation: true,
+                useCache,
+            });
+            printListImages(imagesForDisplay);
+        }
+    }
+    catch (error) {
+        console.error('Error listing images:', error.message);
+    }
+});
+program
+    .command('get <image_id>')
+    .description('Get detailed metadata for an image')
+    .option('-j, --json', 'output as JSON')
+    .option('--ocr', 'output OCR text only')
+    .option('--objects', 'output object annotations only')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (imageId, options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        if (options.json && (options.ocr || options.objects)) {
+            console.error('Error: --json cannot be used with --ocr or --objects.');
+            process.exit(1);
+        }
+        if (options.ocr && options.objects) {
+            console.error('Error: --ocr and --objects cannot be used together.');
+            process.exit(1);
+        }
+        let image = options.cache !== false ? (0, storage_1.loadImageCache)(imageId) : null;
+        if (!image) {
+            image = await (0, api_1.getImageDetail)(imageId);
+            (0, storage_1.saveImageCache)(imageId, image);
+        }
+        const supplemented = supplementAltTextFromSearchCache(image);
+        image = supplemented.image;
+        if (supplemented.supplemented) {
+            (0, storage_1.saveImageCache)(imageId, image);
+        }
+        const ocrDescription = extractOcrDescription(image);
+        const objects = extractObjectAnnotations(image);
+        if (options.ocr) {
+            if (!ocrDescription) {
+                console.error('OCR not found for this image.');
+                process.exit(1);
+            }
+            console.log(ocrDescription);
+            return;
+        }
+        if (options.objects) {
+            if (objects.length === 0) {
+                console.error('Object annotations not found for this image.');
+                process.exit(1);
+            }
+            console.log(objects.map(formatObjectAnnotationLine).join('\n'));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify(image, null, 2));
+        }
+        else {
+            printGetMarkdown(image, ocrDescription, objects);
+        }
+    }
+    catch (error) {
+        console.error('Error getting image:', error.message);
+    }
+});
+program
+    .command('search [query]')
+    .description('Search images')
+    .option('-j, --json', 'output as JSON')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (query, options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        if (!normalizeText(query)) {
+            console.error('Error: Query is required.');
+            console.error('Hint: Run `gyazo search -h` for usage.');
+            process.exit(1);
+        }
+        const images = await (0, api_1.searchImages)(query);
+        const useCache = options.cache !== false;
+        if (options.json) {
+            cacheSearchResultImages(images);
+            console.log(JSON.stringify(images, null, 2));
+        }
+        else {
+            const imagesForDisplay = await prepareImagesForDisplay(images, {
+                cacheSearchResults: true,
+                enrichLocation: true,
+                useCache,
+            });
+            printListImages(imagesForDisplay);
+        }
+    }
+    catch (error) {
+        console.error('Error searching images:', error.message);
+    }
+});
+program
+    .command('apps')
+    .description('Rank metadata app names for a specific date')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+    .option('--today', 'target today only (overrides default weekly range)')
+    .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+    .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+    .option('-j, --json', 'output as JSON')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const targetDate = resolveRankingRangeOption(options);
+        const requestedLimit = parsePositiveIntegerOption(options.limit, '--limit');
+        const limit = Math.min(requestedLimit, 10);
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const useCache = options.cache !== false;
+        let ranking = [];
+        let totalWithApp = 0;
+        let totalImages = 0;
+        if (useCache) {
+            let cacheSummary = buildAppsRankingFromHourlyCache(targetDate);
+            if (cacheSummary.totalImages === 0) {
+                await warmDateCacheForApps(targetDate, maxPages, true);
+                cacheSummary = buildAppsRankingFromHourlyCache(targetDate);
+            }
+            ranking = cacheSummary.ranking;
+            totalWithApp = cacheSummary.imageCountWithApps;
+            totalImages = cacheSummary.totalImages;
+        }
+        else {
+            const imageIds = await warmDateCacheForApps(targetDate, maxPages, false);
+            ranking = buildAppsRankingFromCache(imageIds);
+            totalWithApp = ranking.reduce((sum, item) => sum + item.count, 0);
+            totalImages = imageIds.length;
+        }
+        const displayedRanking = ranking.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({
+                date: targetDate.dateKey,
+                image_count: totalImages,
+                app_image_count: totalWithApp,
+                total_apps: ranking.length,
+                ranking: displayedRanking,
+            }, null, 2));
+            return;
+        }
+        if (ranking.length === 0) {
+            console.log(`No app metadata found for ${targetDate.dateKey}.`);
+            return;
+        }
+        console.log(`Apps on ${targetDate.dateKey}`);
+        displayedRanking.forEach((item, index) => {
+            console.log(`${index + 1}. ${item.app}: ${item.count}`);
+        });
+        console.log(`Total images with app metadata: ${totalWithApp}`);
+    }
+    catch (error) {
+        console.error('Error ranking apps:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('domains')
+    .description('Rank metadata URL domains for a specific date')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+    .option('--today', 'target today only (overrides default weekly range)')
+    .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+    .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+    .option('-j, --json', 'output as JSON')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const targetDate = resolveRankingRangeOption(options);
+        const requestedLimit = parsePositiveIntegerOption(options.limit, '--limit');
+        const limit = Math.min(requestedLimit, 10);
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const useCache = options.cache !== false;
+        let ranking = [];
+        let totalWithDomain = 0;
+        let totalImages = 0;
+        if (useCache) {
+            let cacheSummary = buildDomainsRankingFromHourlyCache(targetDate);
+            if (cacheSummary.totalImages === 0) {
+                await warmDateCacheForDomains(targetDate, maxPages, true);
+                cacheSummary = buildDomainsRankingFromHourlyCache(targetDate);
+            }
+            ranking = cacheSummary.ranking;
+            totalWithDomain = cacheSummary.imageCountWithDomains;
+            totalImages = cacheSummary.totalImages;
+        }
+        else {
+            const imageIds = await warmDateCacheForDomains(targetDate, maxPages, false);
+            ranking = buildDomainsRankingFromCache(imageIds);
+            totalWithDomain = ranking.reduce((sum, item) => sum + item.count, 0);
+            totalImages = imageIds.length;
+        }
+        const displayedRanking = ranking.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({
+                date: targetDate.dateKey,
+                image_count: totalImages,
+                domain_image_count: totalWithDomain,
+                total_domains: ranking.length,
+                ranking: displayedRanking,
+            }, null, 2));
+            return;
+        }
+        if (ranking.length === 0) {
+            console.log(`No domain metadata found for ${targetDate.dateKey}.`);
+            return;
+        }
+        console.log(`Domains on ${targetDate.dateKey}`);
+        displayedRanking.forEach((item, index) => {
+            console.log(`${index + 1}. ${item.domain}: ${item.count}`);
+        });
+        console.log(`Total images with domain metadata: ${totalWithDomain}`);
+    }
+    catch (error) {
+        console.error('Error ranking domains:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('tags')
+    .description('Rank metadata tags for a specific date')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+    .option('--today', 'target today only (overrides default weekly range)')
+    .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+    .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+    .option('-j, --json', 'output as JSON')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const targetDate = resolveRankingRangeOption(options);
+        const requestedLimit = parsePositiveIntegerOption(options.limit, '--limit');
+        const limit = Math.min(requestedLimit, 10);
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const useCache = options.cache !== false;
+        let summary;
+        let totalImages = 0;
+        if (useCache) {
+            let cacheSummary = buildTagsRankingFromHourlyCache(targetDate);
+            if (cacheSummary.totalImages === 0) {
+                await warmDateCacheForTags(targetDate, maxPages, true);
+                cacheSummary = buildTagsRankingFromHourlyCache(targetDate);
+            }
+            summary = cacheSummary;
+            totalImages = cacheSummary.totalImages;
+        }
+        else {
+            const imageIds = await warmDateCacheForTags(targetDate, maxPages, false);
+            summary = buildTagsRankingFromCache(imageIds);
+            totalImages = imageIds.length;
+        }
+        const displayedRanking = summary.ranking.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({
+                date: targetDate.dateKey,
+                image_count: totalImages,
+                image_count_with_tags: summary.imageCountWithTags,
+                total_tag_assignments: summary.totalTagAssignments,
+                total_tags: summary.ranking.length,
+                ranking: displayedRanking,
+            }, null, 2));
+            return;
+        }
+        if (summary.ranking.length === 0) {
+            console.log(`No tag metadata found for ${targetDate.dateKey}.`);
+            return;
+        }
+        console.log(`Tags on ${targetDate.dateKey}`);
+        displayedRanking.forEach((item, index) => {
+            console.log(`${index + 1}. #${item.tag}: ${item.count}`);
+        });
+        console.log(`Total images with tag metadata: ${summary.imageCountWithTags}`);
+    }
+    catch (error) {
+        console.error('Error ranking tags:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('locations')
+    .description('Rank metadata locations for a specific date')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+    .option('--today', 'target today only (overrides default weekly range)')
+    .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+    .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+    .option('-j, --json', 'output as JSON')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const targetDate = resolveRankingRangeOption(options);
+        const requestedLimit = parsePositiveIntegerOption(options.limit, '--limit');
+        const limit = Math.min(requestedLimit, 10);
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const useCache = options.cache !== false;
+        let ranking = [];
+        let totalWithLocation = 0;
+        let totalImages = 0;
+        if (useCache) {
+            let cacheSummary = buildLocationsRankingFromHourlyCache(targetDate);
+            if (cacheSummary.totalImages === 0) {
+                await warmDateCacheForLocations(targetDate, maxPages, true);
+                cacheSummary = buildLocationsRankingFromHourlyCache(targetDate);
+            }
+            ranking = cacheSummary.ranking;
+            totalWithLocation = cacheSummary.imageCountWithLocations;
+            totalImages = cacheSummary.totalImages;
+        }
+        else {
+            const imageIds = await warmDateCacheForLocations(targetDate, maxPages, false);
+            ranking = buildLocationsRankingFromCache(imageIds);
+            totalWithLocation = ranking.reduce((sum, item) => sum + item.count, 0);
+            totalImages = imageIds.length;
+        }
+        const displayedRanking = ranking.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({
+                date: targetDate.dateKey,
+                image_count: totalImages,
+                location_image_count: totalWithLocation,
+                total_locations: ranking.length,
+                ranking: displayedRanking,
+            }, null, 2));
+            return;
+        }
+        if (ranking.length === 0) {
+            console.log(`No location metadata found for ${targetDate.dateKey}.`);
+            return;
+        }
+        console.log(`Locations on ${targetDate.dateKey}`);
+        displayedRanking.forEach((item, index) => {
+            console.log(`${index + 1}. ${item.location}: ${item.count}`);
+        });
+        console.log(`Total images with location metadata: ${totalWithLocation}`);
+    }
+    catch (error) {
+        console.error('Error ranking locations:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('stats')
+    .description('Show weekly stats summary in Markdown')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'window end date anchor (default: yesterday)')
+    .option('--days <number>', 'window length in days', '7')
+    .option('--top <number>', 'rows per section', '10')
+    .option('--max-pages <number>', 'max pages to fetch when warming cache', '10')
+    .option('--no-cache', 'force fetch from API')
+    .action(async (options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    try {
+        const { range, days, startLabel, endLabel } = buildStatsDateRange(options.date, options.days || '7');
+        const top = Math.min(parsePositiveIntegerOption(options.top, '--top'), 20);
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const useCache = options.cache !== false;
+        let uploadTime;
+        let apps = [];
+        let domains = [];
+        let tags = [];
+        let totalUploads = 0;
+        if (useCache) {
+            uploadTime = buildUploadTimeSummaryFromHourlyCache(range);
+            if (uploadTime.totalImages === 0) {
+                await warmDateCacheForApps(range, maxPages, true);
+                uploadTime = buildUploadTimeSummaryFromHourlyCache(range);
+            }
+            let appsSummary = buildAppsRankingFromHourlyCache(range);
+            if (uploadTime.totalImages > 0 && appsSummary.totalImages === 0) {
+                await warmDateCacheForApps(range, maxPages, true);
+                appsSummary = buildAppsRankingFromHourlyCache(range);
+            }
+            let domainsSummary = buildDomainsRankingFromHourlyCache(range);
+            if (uploadTime.totalImages > 0 && domainsSummary.totalImages === 0) {
+                await warmDateCacheForDomains(range, maxPages, true);
+                domainsSummary = buildDomainsRankingFromHourlyCache(range);
+            }
+            let tagsSummary = buildTagsRankingFromHourlyCache(range);
+            if (uploadTime.totalImages > 0 && tagsSummary.totalImages === 0) {
+                await warmDateCacheForTags(range, maxPages, true);
+                tagsSummary = buildTagsRankingFromHourlyCache(range);
+            }
+            apps = appsSummary.ranking;
+            domains = domainsSummary.ranking;
+            tags = tagsSummary.ranking;
+            totalUploads = uploadTime.totalImages;
+        }
+        else {
+            const imageIds = await warmDateCacheForTags(range, maxPages, false);
+            uploadTime = buildUploadTimeSummaryFromImageCache(imageIds, range);
+            apps = buildAppsRankingFromCache(imageIds);
+            domains = buildDomainsRankingFromCache(imageIds);
+            tags = buildTagsRankingFromCache(imageIds).ranking;
+            totalUploads = uploadTime.totalImages;
+        }
+        console.log(renderStatsMarkdown({
+            startLabel,
+            endLabel,
+            days,
+            totalUploads,
+            uploadTime,
+            apps,
+            domains,
+            tags,
+            top,
+        }));
+    }
+    catch (error) {
+        console.error('Error building stats:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('upload [path]')
+    .description('Upload an image file (or read image bytes from stdin)')
+    .option('--title <title>', 'image title')
+    .option('--app <app>', 'application name', 'gyazocli')
+    .option('--url <url>', 'source URL (sent as referer_url)')
+    .option('--timestamp <unix_timestamp>', 'created_at unix timestamp (current or past)')
+    .option('--desc <desc>', 'image description')
+    .action(async (inputPath, options) => {
+    await (0, credentials_1.ensureAccessToken)();
+    let imageData;
+    let filename = 'stdin-upload.bin';
+    if (inputPath && inputPath !== '-') {
+        const resolvedPath = path_1.default.resolve(inputPath);
+        if (!fs_1.default.existsSync(resolvedPath)) {
+            console.error(`Error: File not found: ${resolvedPath}`);
+            process.exit(1);
+        }
+        imageData = fs_1.default.readFileSync(resolvedPath);
+        filename = path_1.default.basename(resolvedPath);
+    }
+    else {
+        if (process.stdin.isTTY) {
+            console.error('Error: Provide an image path or pipe image data via stdin.');
+            console.error('Hint: Run `gyazo upload -h` for usage.');
+            process.exit(1);
+        }
+        imageData = await readStdinBuffer();
+        if (imageData.length === 0) {
+            console.error('Error: No image data received from stdin.');
+            process.exit(1);
+        }
+    }
+    const desc = ensureUploadDescTag(options.desc);
+    const timestamp = parseUploadTimestamp(options.timestamp);
+    try {
+        const uploaded = await (0, api_1.uploadImage)({
+            imageData,
+            filename,
+            title: options.title,
+            app: options.app || 'gyazocli',
+            refererUrl: options.url,
+            desc,
+            timestamp,
+        });
+        console.log(`URL: ${uploaded.permalink_url}`);
+        console.log(`ID: ${uploaded.image_id}`);
+        if (uploaded.created_at) {
+            console.log(`Created at: ${formatCreatedAt(uploaded.created_at)}`);
+        }
+        console.log(`App: ${options.app || 'gyazocli'}`);
+        console.log(`Desc: ${desc}`);
+    }
+    catch (error) {
+        console.error('Error uploading image:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('sync')
+    .description('Sync images from yesterday back to N days')
+    .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')
+    .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);
+    }
+    const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+    let startDate;
+    let endDate;
+    if (options.date) {
+        const parsed = parseDateOption(options.date);
+        startDate = parsed.start;
+        endDate = parsed.end;
+    }
+    else {
+        const days = options.days ? parsePositiveIntegerOption(options.days, '--days') : 1;
+        const now = new Date();
+        endDate = new Date(now);
+        endDate.setDate(endDate.getDate() - 1);
+        endDate.setHours(23, 59, 59, 999);
+        startDate = new Date(now);
+        startDate.setDate(startDate.getDate() - days - 1);
+        startDate.setHours(0, 0, 0, 0);
+    }
+    console.log(`Syncing images between ${startDate.toISOString()} and ${endDate.toISOString()}...`);
+    const hourlyIndices = new Map();
+    for (let page = 1; page <= maxPages; page++) {
+        const images = 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) {
+                // Skip images newer than target range.
+                continue;
+            }
+            if (createdAt < startDate) {
+                reachedLimit = true;
+                break;
+            }
+            // Add to hourly index
+            const y = createdAt.getFullYear().toString();
+            const m = (createdAt.getMonth() + 1).toString().padStart(2, '0');
+            const d = createdAt.getDate().toString().padStart(2, '0');
+            const h = createdAt.getHours().toString().padStart(2, '0');
+            const key = `${y}-${m}-${d}-${h}`;
+            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) {
+                process.stdout.write(`s`);
+                continue;
+            }
+            process.stdout.write(`.`);
+            try {
+                const detail = await (0, api_1.getImageDetail)(img.image_id);
+                (0, storage_1.saveImageCache)(img.image_id, detail);
+                await new Promise(resolve => setTimeout(resolve, 200));
+            }
+            catch (e) {
+                process.stdout.write(`x`);
+            }
+        }
+        console.log(`\nPage ${page} processed.`);
+        if (reachedLimit)
+            break;
+    }
+    // Save hourly indices
+    console.log(`Updating hourly indices...`);
+    for (const [key, ids] of hourlyIndices.entries()) {
+        const [y, m, d, h] = key.split('-');
+        const existing = (0, storage_1.loadHourlyCache)(y, m, d, h) || [];
+        const merged = Array.from(new Set([...existing, ...ids]));
+        (0, storage_1.saveHourlyCache)(y, m, d, h, merged);
+    }
+    console.log(`Sync complete.`);
+});
+program
+    .command('import <type> <dir>')
+    .description('Import legacy data (type: json|hourly)')
+    .action(async (type, dir) => {
+    const sourceDir = path_1.default.resolve(dir);
+    if (!fs_1.default.existsSync(sourceDir)) {
+        console.error(`Error: Source directory ${sourceDir} does not exist.`);
+        process.exit(1);
+    }
+    if (type === 'json') {
+        const targetDir = path_1.default.join((0, storage_1.getCacheDir)(), 'images');
+        console.log(`Importing legacy Gyazo JSON from ${sourceDir}...`);
+        let total = 0;
+        const walk = (d) => {
+            fs_1.default.readdirSync(d, { withFileTypes: true }).forEach(e => {
+                const p = path_1.default.join(d, e.name);
+                if (e.isDirectory())
+                    walk(p);
+                else if (e.name.endsWith('.json')) {
+                    const id = e.name.replace('.json', '');
+                    const p1 = id[0] || '_', p2 = id[1] || '_';
+                    const dest = path_1.default.join(targetDir, p1, p2);
+                    if (!fs_1.default.existsSync(dest))
+                        fs_1.default.mkdirSync(dest, { recursive: true });
+                    fs_1.default.copyFileSync(p, path_1.default.join(dest, e.name));
+                    total++;
+                    if (total % 100 === 0)
+                        process.stdout.write('.');
+                }
+            });
+        };
+        walk(sourceDir);
+        console.log(`\nImport complete. Copied ${total} files.`);
+    }
+    else if (type === 'hourly') {
+        console.log(`Importing legacy Gyazo hourly data from ${sourceDir}...`);
+        let total = 0;
+        const years = fs_1.default.readdirSync(sourceDir).filter(f => /^[0-9]{4}$/.test(f));
+        for (const y of years) {
+            const months = fs_1.default.readdirSync(path_1.default.join(sourceDir, y)).filter(f => /^[0-9]{2}$/.test(f));
+            for (const m of months) {
+                const days = fs_1.default.readdirSync(path_1.default.join(sourceDir, y, m)).filter(f => /^[0-9]{2}$/.test(f));
+                for (const d of days) {
+                    const hours = fs_1.default.readdirSync(path_1.default.join(sourceDir, y, m, d)).filter(f => /^[0-9]{2}$/.test(f));
+                    for (const h of hours) {
+                        const txt = path_1.default.join(sourceDir, y, m, d, h, 'image_ids.txt');
+                        if (fs_1.default.existsSync(txt)) {
+                            const ids = fs_1.default.readFileSync(txt, 'utf-8').split('\n').map(id => id.trim()).filter(id => id.length > 0);
+                            (0, storage_1.saveHourlyCache)(y, m, d, h, ids);
+                            total++;
+                        }
+                    }
+                }
+            }
+            process.stdout.write('.');
+        }
+        console.log(`\nImport complete. Copied ${total} hourly index files.`);
+    }
+    else {
+        console.error('Error: type must be "json" or "hourly"');
+        process.exit(1);
+    }
+});
+program.parseAsync(process.argv);