@yuiseki/gyazocli 0.0.1 → 0.0.2

package/README.md

@@ -16,6 +16,26 @@ gyazo sync --days 10
 gyazo --help
 ```
 
+### Detail
+
+- `gyazo config set token <token>`: Save your access token
+- `gyazo config get token|me`: Show saved token (masked) or `me` profile info
+- `gyazo ls` (`gyazo list`): List images (`--date`/`--today`, `--photos`, `--uploaded`, `-H` available; `--photos/--uploaded` can be combined with `--date`/`--today`)
+- `gyazo search <query>`: Search images
+- `gyazo get <image_id>`: Show image details (`--ocr`, `--objects`, `-j` available)
+- `gyazo apps|domains|tags|locations`: Show rankings
+- `gyazo summary`: Show day-by-day weekly summary in Markdown (`##`/`###` headings, image count, apps, domains, tags, locations per day)
+- `gyazo stats`: Show weekly summary
+- `gyazo upload [path]`: Upload an image (uses stdin when path is omitted)
+- `gyazo sync`: Sync cache
+
+Date range notes:
+- Default range for `apps|domains|tags|locations|stats` is from 8 days ago to yesterday
+- Use `--today` for today only, or `--date <yyyy|yyyy-mm|yyyy-mm-dd>` for a custom range
+
+JSON output:
+- `-j, --json` is available for `config get`, `ls`, `get`, `search`, `apps`, `domains`, `tags`, `locations`, and `summary`
+
 ## Development
 
 ### Build

package/dist/index.js

@@ -16,7 +16,7 @@ const WEEKDAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 program
     .name('gyazo')
     .description('Gyazo Memory CLI for AI Secretary')
-    .version('0.0.1');
+    .version('0.0.2');
 // Config Command
 const configCmd = program.command('config').description('Manage configuration');
 configCmd
@@ -540,6 +540,19 @@ function getDatePartsInRange(start, end) {
     }
     return dates;
 }
+function loadImageIdsFromDateRangeCache(targetDate) {
+    const imageIds = new Set();
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const hours = getDateHourStrings();
+    for (const date of dates) {
+        for (const hour of hours) {
+            const ids = (0, storage_1.loadHourlyCache)(date.year, date.month, date.day, hour) || [];
+            for (const id of ids)
+                imageIds.add(id);
+        }
+    }
+    return Array.from(imageIds);
+}
 function normalizeRankingValues(values) {
     const uniqueByLower = new Map();
     for (const raw of values) {
@@ -630,6 +643,59 @@ async function warmDateCacheForTags(targetDate, maxPages, useCache) {
 async function warmDateCacheForLocations(targetDate, maxPages, useCache) {
     return warmDateCacheForRanking(targetDate, maxPages, useCache, 'locations', extractImageLocations);
 }
+async function warmDateCacheForList(targetDate, maxPages, useCache) {
+    const hourlyIndices = 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());
+            }
+            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);
+            }
+            (0, storage_1.saveImageCache)(img.image_id, merged);
+        }
+        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);
+    }
+    if (useCache) {
+        for (const id of loadImageIdsFromDateRangeCache(targetDate)) {
+            imageIds.add(id);
+        }
+    }
+    return Array.from(imageIds);
+}
 async function warmDateCacheForRanking(targetDate, maxPages, useCache, metadataKind, extractValues) {
     const hourlyIndices = new Map();
     const hourlyMetadataEntries = new Map();
@@ -975,6 +1041,122 @@ function buildUploadTimeSummaryFromImageCache(imageIds, targetDate) {
         }),
     };
 }
+function buildDailyUploadCountsFromHourlyCache(targetDate) {
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const hours = getDateHourStrings();
+    const byDate = new Map();
+    for (const date of dates) {
+        const dateLabel = `${date.year}-${date.month}-${date.day}`;
+        if (!byDate.has(dateLabel)) {
+            byDate.set(dateLabel, new Set());
+        }
+        const ids = byDate.get(dateLabel);
+        for (const hour of hours) {
+            const imageIds = (0, storage_1.loadHourlyCache)(date.year, date.month, date.day, hour) || [];
+            for (const imageId of imageIds)
+                ids.add(imageId);
+        }
+    }
+    return dates.map(date => {
+        const dateLabel = `${date.year}-${date.month}-${date.day}`;
+        return {
+            date: dateLabel,
+            count: byDate.get(dateLabel)?.size || 0,
+        };
+    });
+}
+function buildDailyUploadCountsFromImageCache(imageIds, targetDate) {
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const byDate = new Map();
+    for (const date of dates) {
+        const dateLabel = `${date.year}-${date.month}-${date.day}`;
+        byDate.set(dateLabel, new Set());
+    }
+    for (const imageId of imageIds) {
+        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;
+        const dateLabel = formatDateYmd(createdAt);
+        const ids = byDate.get(dateLabel);
+        if (!ids)
+            continue;
+        ids.add(imageId);
+    }
+    return dates.map(date => {
+        const dateLabel = `${date.year}-${date.month}-${date.day}`;
+        return {
+            date: dateLabel,
+            count: byDate.get(dateLabel)?.size || 0,
+        };
+    });
+}
+function buildDailySummariesFromImageCache(targetDate) {
+    const dates = getDatePartsInRange(targetDate.start, targetDate.end);
+    const hours = getDateHourStrings();
+    const summaries = [];
+    for (const date of dates) {
+        const dateLabel = `${date.year}-${date.month}-${date.day}`;
+        const imageIds = new Set();
+        for (const hour of hours) {
+            const ids = (0, storage_1.loadHourlyCache)(date.year, date.month, date.day, hour) || [];
+            for (const id of ids)
+                imageIds.add(id);
+        }
+        const appCounts = new Map();
+        const domainCounts = new Map();
+        const tagCounts = new Map();
+        const locationCounts = new Map();
+        for (const imageId of imageIds) {
+            const image = (0, storage_1.loadImageCache)(imageId);
+            if (!image)
+                continue;
+            for (const app of extractImageApps(image)) {
+                appCounts.set(app, (appCounts.get(app) || 0) + 1);
+            }
+            for (const domain of extractImageDomains(image)) {
+                domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
+            }
+            for (const tag of extractImageTags(image)) {
+                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+            }
+            for (const location of extractImageLocations(image)) {
+                locationCounts.set(location, (locationCounts.get(location) || 0) + 1);
+            }
+        }
+        const sortEntries = (a, b) => {
+            if (b[1] !== a[1])
+                return b[1] - a[1];
+            return a[0].localeCompare(b[0]);
+        };
+        const apps = Array.from(appCounts.entries())
+            .sort(sortEntries)
+            .map(([app, count]) => ({ app, count }));
+        const domains = Array.from(domainCounts.entries())
+            .sort(sortEntries)
+            .map(([domain, count]) => ({ domain, count }));
+        const tags = Array.from(tagCounts.entries())
+            .sort(sortEntries)
+            .map(([tag, count]) => ({ tag, count }));
+        const locations = Array.from(locationCounts.entries())
+            .sort(sortEntries)
+            .map(([location, count]) => ({ location, count }));
+        summaries.push({
+            date: dateLabel,
+            imageCount: imageIds.size,
+            apps,
+            domains,
+            tags,
+            locations,
+        });
+    }
+    return summaries;
+}
 function appendStatsRankSection(lines, title, rows, top) {
     lines.push(`### ${title}`);
     const filtered = rows.filter(row => row.count > 0).slice(0, top);
@@ -1008,6 +1190,34 @@ function renderStatsMarkdown(params) {
     appendStatsRankSection(lines, 'Tags', params.tags.map(item => ({ label: `#${item.tag}`, count: item.count })), params.top);
     return lines.join('\n').trimEnd();
 }
+function renderSummaryText(params) {
+    const appendRankSection = (lines, title, rows, limit) => {
+        lines.push(`- ${title}:`);
+        const items = rows.filter(row => row.count > 0).slice(0, limit);
+        if (items.length === 0) {
+            lines.push('  - (none)');
+            return;
+        }
+        for (const row of items) {
+            lines.push(`  - ${row.label}${row.count > 1 ? ` (${row.count})` : ''}`);
+        }
+    };
+    const lines = [];
+    lines.push('## Gyazo Summary');
+    lines.push('');
+    lines.push(`- Window: ${params.dateKey}`);
+    lines.push('');
+    for (const day of params.dailySummaries) {
+        lines.push(`### ${day.date}`);
+        lines.push(`- Image count: ${day.imageCount}`);
+        appendRankSection(lines, 'Apps', day.apps.map(item => ({ label: item.app, count: item.count })), params.limit);
+        appendRankSection(lines, 'Domains', day.domains.map(item => ({ label: item.domain, count: item.count })), params.limit);
+        appendRankSection(lines, 'Tags', day.tags.map(item => ({ label: `#${item.tag}`, count: item.count })), params.limit);
+        appendRankSection(lines, 'Locations', day.locations.map(item => ({ label: item.location, count: item.count })), params.limit);
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
 async function readStdinBuffer() {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -1197,6 +1407,9 @@ program
     .option('-l, --limit <number>', 'items per page', '20')
     .option('-j, --json', 'output as JSON')
     .option('-H, --hour <yyyy-mm-dd-hh>', 'target hour')
+    .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+    .option('--today', 'target today only')
+    .option('--max-pages <number>', 'max pages to scan for --date/--today mode', '100')
     .option('--photos', 'alias of search "has:location"')
     .option('--uploaded', 'alias of search "gyazocli_uploads"')
     .option('--no-cache', 'force fetch from API')
@@ -1204,21 +1417,69 @@ program
     await (0, credentials_1.ensureAccessToken)();
     try {
         const useCache = options.cache !== false;
+        const page = parsePositiveIntegerOption(options.page, '--page');
+        const limit = parsePositiveIntegerOption(options.limit, '--limit');
+        const maxPages = parsePositiveIntegerOption(options.maxPages, '--max-pages');
+        const hasDateRange = Boolean(options.date || options.today);
+        const targetDate = hasDateRange
+            ? (options.today ? parseDateOption() : parseDateOption(options.date))
+            : undefined;
         if (options.photos && options.uploaded) {
             console.error('Error: --photos and --uploaded cannot be used together.');
             process.exit(1);
         }
+        if (options.today && options.date) {
+            console.error('Error: --today and --date 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);
         }
+        if (options.hour && hasDateRange) {
+            console.error('Error: --hour and --date/--today 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));
+            let images = [];
+            if (targetDate) {
+                const collected = [];
+                for (let searchPage = 1; searchPage <= maxPages; searchPage++) {
+                    const pageImages = await (0, api_1.searchImages)(aliasQuery, searchPage, 100);
+                    if (pageImages.length === 0)
+                        break;
+                    let reachedLimit = false;
+                    for (const img of pageImages) {
+                        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;
+                        }
+                        collected.push(img);
+                    }
+                    if (reachedLimit)
+                        break;
+                }
+                collected.sort((a, b) => {
+                    const ta = new Date(a.created_at).getTime();
+                    const tb = new Date(b.created_at).getTime();
+                    return tb - ta;
+                });
+                const startIndex = (page - 1) * limit;
+                images = collected.slice(startIndex, startIndex + limit);
+            }
+            else {
+                images = await (0, api_1.searchImages)(aliasQuery, page, limit);
+            }
             if (options.json) {
                 console.log(JSON.stringify(images, null, 2));
             }
@@ -1232,6 +1493,50 @@ program
             }
             return;
         }
+        if (targetDate) {
+            let imageIds = [];
+            if (useCache) {
+                imageIds = loadImageIdsFromDateRangeCache(targetDate);
+                if (imageIds.length === 0) {
+                    await warmDateCacheForList(targetDate, maxPages, true);
+                    imageIds = loadImageIdsFromDateRangeCache(targetDate);
+                }
+            }
+            else {
+                imageIds = await warmDateCacheForList(targetDate, maxPages, false);
+            }
+            if (imageIds.length === 0) {
+                console.log(`No images found for ${targetDate.dateKey}.`);
+                return;
+            }
+            let images = imageIds
+                .map(id => (0, storage_1.loadImageCache)(id))
+                .filter((img) => img !== null);
+            images = images.filter((img) => {
+                const createdAt = new Date(img.created_at);
+                if (Number.isNaN(createdAt.getTime()))
+                    return false;
+                return createdAt >= targetDate.start && createdAt <= targetDate.end;
+            });
+            images.sort((a, b) => {
+                const ta = new Date(a.created_at).getTime();
+                const tb = new Date(b.created_at).getTime();
+                return tb - ta;
+            });
+            const startIndex = (page - 1) * limit;
+            const pageImages = images.slice(startIndex, startIndex + limit);
+            if (options.json) {
+                console.log(JSON.stringify(pageImages, null, 2));
+            }
+            else {
+                const imagesForDisplay = await prepareImagesForDisplay(pageImages, {
+                    enrichLocation: true,
+                    useCache,
+                });
+                printListImages(imagesForDisplay);
+            }
+            return;
+        }
         if (options.hour) {
             const parts = options.hour.split('-');
             if (parts.length !== 4) {
@@ -1272,7 +1577,7 @@ program
             }
             return;
         }
-        const images = await (0, api_1.listImages)(parseInt(options.page, 10), parseInt(options.limit, 10));
+        const images = await (0, api_1.listImages)(page, limit);
         if (options.json) {
             console.log(JSON.stringify(images, null, 2));
         }
@@ -1623,6 +1928,71 @@ program
         process.exit(1);
     }
 });
+program
+    .command('summary')
+    .description('Show weekly summary with daily uploads and metadata rankings')
+    .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 dailySummaries = [];
+        if (useCache) {
+            dailySummaries = buildDailySummariesFromImageCache(targetDate);
+            const totalUploads = dailySummaries.reduce((sum, day) => sum + day.imageCount, 0);
+            if (totalUploads === 0) {
+                await warmDateCacheForTags(targetDate, maxPages, true);
+                await warmDateCacheForLocations(targetDate, maxPages, true);
+                dailySummaries = buildDailySummariesFromImageCache(targetDate);
+            }
+            else {
+                const hasMetadata = dailySummaries.some(day => day.apps.length > 0 || day.domains.length > 0 || day.tags.length > 0 || day.locations.length > 0);
+                if (!hasMetadata) {
+                    await warmDateCacheForTags(targetDate, maxPages, true);
+                    await warmDateCacheForLocations(targetDate, maxPages, true);
+                    dailySummaries = buildDailySummariesFromImageCache(targetDate);
+                }
+            }
+        }
+        else {
+            await warmDateCacheForTags(targetDate, maxPages, false);
+            await warmDateCacheForLocations(targetDate, maxPages, false);
+            dailySummaries = buildDailySummariesFromImageCache(targetDate);
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                date: targetDate.dateKey,
+                days: dailySummaries.map(day => ({
+                    date: day.date,
+                    image_count: day.imageCount,
+                    apps: day.apps.slice(0, limit),
+                    domains: day.domains.slice(0, limit),
+                    tags: day.tags.slice(0, limit),
+                    locations: day.locations.slice(0, limit),
+                })),
+            }, null, 2));
+            return;
+        }
+        console.log(renderSummaryText({
+            dateKey: targetDate.dateKey,
+            dailySummaries,
+            limit,
+        }));
+    }
+    catch (error) {
+        console.error('Error building summary:', error.message);
+        process.exit(1);
+    }
+});
 program
     .command('stats')
     .description('Show weekly stats summary in Markdown')

package/docs/ADR/002-caching-strategy.md

@@ -47,6 +47,9 @@ Store cache files under XDG-style user cache location by default, with an enviro
 - `gyazo get <image_id>`:
   - Uses cached detail by default.
   - `--no-cache` forces API fetch and rewrites cache.
+- `gyazo list --date <...>`:
+  - Reads image IDs from hourly index cache files in the target day/month/year range.
+  - If the range has no hourly cache entries, it warms cache from API list pages and then reads from cache.
 - `gyazo sync`:
   - Fetches list pages (`per_page=100`) for a bounded date range.
   - Skips detail fetch when cached record already has `ocr`.
@@ -69,6 +72,11 @@ Store cache files under XDG-style user cache location by default, with an enviro
   - Aggregates upload time bands and rankings of apps/domains/tags from hourly caches.
   - Uses the same hourly metadata extract cache mechanism as ranking commands.
   - If cache data for the target window is absent, warming is triggered once, then summary is built from cache.
+- `gyazo summary`:
+  - Default window is from 8 days ago to yesterday (`7` days).
+  - Outputs day-by-day Markdown sections with `image count` plus rankings of apps/domains/tags/locations.
+  - Uses hourly index cache to discover images per day, then builds rankings from image cache records.
+  - If image-cache metadata is insufficient, warming via list/detail fetch is triggered through ranking warmers.
 
 ## Consequences
 - Cache is portable and independent from the repository working tree.

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

@@ -11,7 +11,7 @@ Adopt and document the existing top-level command structure.
 
 ### 1. Program Metadata
 - Binary name: `gyazo`
-- Version: `1.0.0`
+- Version: `0.0.2`
 - Description: `Gyazo Memory CLI for AI Secretary`
 
 ### 2. Commands
@@ -28,8 +28,11 @@ Adopt and document the existing top-level command structure.
     - `-l, --limit <number>` (default: `20`)
     - `-j, --json`
     - `-H, --hour <yyyy-mm-dd-hh>` (reads hourly cache only)
-    - `--photos` (alias of `search has:location`)
-    - `--uploaded` (alias of `search gyazocli_uploads`)
+    - `--date <yyyy|yyyy-mm|yyyy-mm-dd>` (reads date range from hourly cache; warms from API if needed)
+    - `--today` (target today only)
+    - `--max-pages <number>` (default: `100`, used for `--date`/`--today` warming)
+    - `--photos` (alias of `search has:location`, can be combined with `--date`/`--today`)
+    - `--uploaded` (alias of `search gyazocli_uploads`, can be combined with `--date`/`--today`)
     - `--no-cache`
 - `gyazo get <image_id>`
   - Options:
@@ -77,6 +80,18 @@ Adopt and document the existing top-level command structure.
     - `--max-pages <number>` (default: `10`)
     - `-j, --json`
     - `--no-cache`
+- `gyazo summary`
+  - Default range: from 8 days ago to yesterday
+  - Shows day-by-day Markdown sections (`### YYYY-MM-DD`) with:
+    - `image count`
+    - rankings of apps/domains/tags/locations
+  - Options:
+    - `--date <yyyy|yyyy-mm|yyyy-mm-dd>`
+    - `--today` (target today only)
+    - `-l, --limit <number>` (default: `10`, max: `10`)
+    - `--max-pages <number>` (default: `10`)
+    - `-j, --json`
+    - `--no-cache`
 - `gyazo stats`
   - Default range: from 8 days ago to yesterday
   - Default behavior: weekly Markdown summary.
@@ -103,7 +118,8 @@ Adopt and document the existing top-level command structure.
   - Supported types: `json`, `hourly`
 
 ### 3. Output and Behavior Notes
-- `-j, --json` is available on `config get`, `list`, `get`, `search`, `apps`, `domains`, `tags`, and `locations`.
+- `-j, --json` is available on `config get`, `list`, `get`, `search`, `apps`, `domains`, `tags`, `locations`, and `summary`.
+- `summary` default output is Markdown with headings (`## Gyazo Summary`, `### YYYY-MM-DD`) and nested bullet lists.
 - There are no global `--plain` or `--verbose` flags in current implementation.
 - Authenticated commands call token resolution before API access.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuiseki/gyazocli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Gyazo Memory CLI for AI Secretary",
   "main": "dist/index.js",
   "bin": {