@jackwener/opencli 1.7.6 → 1.7.7

package/clis/twitter/likes.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { resolveTwitterQueryId, sanitizeQueryId } from './shared.js';
+import { resolveTwitterQueryId, sanitizeQueryId, extractMedia } from './shared.js';
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const LIKES_QUERY_ID = 'RozQdCp4CilQzrcuU0NY5w';
 const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
@@ -99,6 +99,7 @@ function extractLikedTweet(result, seen) {
         retweets: legacy.retweet_count || 0,
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(legacy),
     };
 }
 function parseLikes(data, seen) {
@@ -144,7 +145,7 @@ cli({
         { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (without @). Defaults to logged-in user.' },
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['author', 'name', 'text', 'likes', 'url'],
+    columns: ['author', 'name', 'text', 'likes', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         let username = (kwargs.username || '').replace(/^@/, '');

package/clis/twitter/search.js

@@ -1,5 +1,6 @@
 import { CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { extractMedia } from './shared.js';
 /**
  * Trigger Twitter search SPA navigation with fallback strategies.
  *
@@ -102,7 +103,7 @@ cli({
         { name: 'filter', type: 'string', default: 'top', choices: ['top', 'live'] },
         { name: 'limit', type: 'int', default: 15 },
     ],
-    columns: ['id', 'author', 'text', 'created_at', 'likes', 'views', 'url'],
+    columns: ['id', 'author', 'text', 'created_at', 'likes', 'views', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const query = kwargs.query;
         const filter = kwargs.filter === 'live' ? 'live' : 'top';
@@ -156,7 +157,8 @@ cli({
                         created_at: tweet.legacy?.created_at || '',
                         likes: tweet.legacy?.favorite_count || 0,
                         views: tweet.views?.count || '0',
-                        url: `https://x.com/i/status/${tweet.rest_id}`
+                        url: `https://x.com/i/status/${tweet.rest_id}`,
+                        ...extractMedia(tweet.legacy),
                     });
                 }
             }

package/clis/twitter/search.test.js

@@ -75,6 +75,8 @@ describe('twitter search command', () => {
                 likes: 7,
                 views: '12',
                 url: 'https://x.com/i/status/1',
+                has_media: false,
+                media_urls: [],
             },
         ]);
         expect(page.installInterceptor).toHaveBeenCalledWith('SearchTimeline');
@@ -203,6 +205,8 @@ describe('twitter search command', () => {
                 likes: 3,
                 views: '5',
                 url: 'https://x.com/i/status/99',
+                has_media: false,
+                media_urls: [],
             },
         ]);
         // 6 evaluate calls: 2x pushState + 2x pathname check + 1x fallback + 1x pathname check

package/clis/twitter/shared.js

@@ -35,6 +35,34 @@ export async function resolveTwitterQueryId(page, operationName, fallbackId) {
   }`);
     return sanitizeQueryId(resolved, fallbackId);
 }
+/**
+ * Extract media flags and URLs from a tweet's `legacy` object.
+ *
+ * Prefers `extended_entities.media` (superset with full video_info) and falls
+ * back to `entities.media` when the extended form is missing. For videos and
+ * animated GIFs, returns the mp4 variant URL; for photos, returns
+ * `media_url_https`.
+ */
+export function extractMedia(legacy) {
+    const media = legacy?.extended_entities?.media || legacy?.entities?.media;
+    if (!Array.isArray(media) || media.length === 0) {
+        return { has_media: false, media_urls: [] };
+    }
+    const urls = [];
+    for (const m of media) {
+        if (!m) continue;
+        if (m.type === 'video' || m.type === 'animated_gif') {
+            const variants = m.video_info?.variants || [];
+            const mp4 = variants.find((v) => v?.content_type === 'video/mp4');
+            const url = mp4?.url || m.media_url_https;
+            if (url) urls.push(url);
+        } else {
+            if (m.media_url_https) urls.push(m.media_url_https);
+        }
+    }
+    return { has_media: urls.length > 0, media_urls: urls };
+}
 export const __test__ = {
     sanitizeQueryId,
+    extractMedia,
 };

package/clis/twitter/shared.test.js

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './shared.js';
+
+const { extractMedia } = __test__;
+
+describe('twitter extractMedia', () => {
+    it('returns false + empty list when legacy has no media', () => {
+        expect(extractMedia({})).toEqual({ has_media: false, media_urls: [] });
+        expect(extractMedia(undefined)).toEqual({ has_media: false, media_urls: [] });
+        expect(extractMedia({ extended_entities: { media: [] } })).toEqual({
+            has_media: false,
+            media_urls: [],
+        });
+    });
+
+    it('extracts photo urls from extended_entities', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/a.jpg' },
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/b.jpg' },
+                ],
+            },
+        });
+        expect(result.has_media).toBe(true);
+        expect(result.media_urls).toEqual([
+            'https://pbs.twimg.com/media/a.jpg',
+            'https://pbs.twimg.com/media/b.jpg',
+        ]);
+    });
+
+    it('prefers mp4 variant for video and animated_gif', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    {
+                        type: 'video',
+                        media_url_https: 'https://pbs.twimg.com/media/thumb.jpg',
+                        video_info: {
+                            variants: [
+                                { content_type: 'application/x-mpegURL', url: 'https://video.twimg.com/x.m3u8' },
+                                { content_type: 'video/mp4', url: 'https://video.twimg.com/x.mp4' },
+                            ],
+                        },
+                    },
+                    {
+                        type: 'animated_gif',
+                        media_url_https: 'https://pbs.twimg.com/tweet_video_thumb/g.jpg',
+                        video_info: {
+                            variants: [
+                                { content_type: 'video/mp4', url: 'https://video.twimg.com/g.mp4' },
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+        expect(result.has_media).toBe(true);
+        expect(result.media_urls).toEqual([
+            'https://video.twimg.com/x.mp4',
+            'https://video.twimg.com/g.mp4',
+        ]);
+    });
+
+    it('falls back to media_url_https when no mp4 variant is available', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    {
+                        type: 'video',
+                        media_url_https: 'https://pbs.twimg.com/media/thumb.jpg',
+                        video_info: { variants: [] },
+                    },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/thumb.jpg'],
+        });
+    });
+
+    it('falls back to entities.media when extended_entities is missing', () => {
+        const result = extractMedia({
+            entities: {
+                media: [
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/c.jpg' },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/c.jpg'],
+        });
+    });
+});

package/clis/twitter/thread.js

@@ -1,5 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { extractMedia } from './shared.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const TWEET_DETAIL_QUERY_ID = 'nBS-WpgA6ZG0CyNHD517JQ';
@@ -54,6 +55,7 @@ function extractTweet(r, seen) {
         in_reply_to: l.in_reply_to_status_id_str || undefined,
         created_at: l.created_at,
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(l),
     };
 }
 function parseTweetDetail(data, seen) {
@@ -101,7 +103,7 @@ cli({
         { name: 'tweet-id', positional: true, type: 'string', required: true },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url'],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         let tweetId = kwargs['tweet-id'];
         const urlMatch = tweetId.match(/\/status\/(\d+)/);

package/clis/twitter/timeline.js

@@ -1,6 +1,6 @@
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { resolveTwitterQueryId } from './shared.js';
+import { resolveTwitterQueryId, extractMedia } from './shared.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
@@ -85,6 +85,7 @@ function extractTweet(result, seen) {
         views,
         created_at: l.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(l),
     };
 }
 function parseHomeTimeline(data, seen) {
@@ -148,7 +149,7 @@ cli({
         },
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url'],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';

package/clis/twitter/tweets.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { resolveTwitterQueryId, sanitizeQueryId } from './shared.js';
+import { resolveTwitterQueryId, sanitizeQueryId, extractMedia } from './shared.js';
 
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const USER_TWEETS_QUERY_ID = '6fWQaBPK51aGyC_VC7t9GQ';
@@ -105,6 +105,7 @@ function extractTweet(result, seen) {
         is_retweet: isRetweet,
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(legacy),
     };
 }
 
@@ -151,7 +152,7 @@ cli({
         { name: 'username', type: 'string', positional: true, required: true, help: 'Twitter screen name (with or without @)' },
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },
     ],
-    columns: ['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url'],
+    columns: ['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = Math.max(1, Math.min(200, kwargs.limit || 20));
         const username = String(kwargs.username || '').replace(/^@/, '').trim();

package/clis/twitter/tweets.test.js

@@ -5,7 +5,7 @@ import { __test__ } from './tweets.js';
 describe('twitter tweets helpers', () => {
     it('registers is_retweet in the default columns', () => {
         const cmd = getRegistry().get('twitter/tweets');
-        expect(cmd?.columns).toEqual(['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url']);
+        expect(cmd?.columns).toEqual(['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls']);
     });
 
     it('falls back when queryId contains unsafe characters', () => {

package/clis/web/read.js

@@ -15,7 +15,7 @@
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { downloadArticle } from '@jackwener/opencli/download/article-download';
-cli({
+const command = cli({
     site: 'web',
     name: 'read',
     description: 'Fetch any web page and export as Markdown',
@@ -26,6 +26,7 @@ cli({
         { name: 'output', default: './web-articles', help: 'Output directory' },
         { name: 'download-images', type: 'boolean', default: true, help: 'Download images locally' },
         { name: 'wait', type: 'int', default: 3, help: 'Seconds to wait after page load' },
+        { name: 'stdout', type: 'boolean', default: false, help: 'Print markdown to stdout instead of saving to a file' },
     ],
     columns: ['title', 'author', 'publish_time', 'status', 'size', 'saved'],
     func: async (page, kwargs) => {
@@ -162,14 +163,26 @@ cli({
           if (el.children && el.children.length > 2) dedup(el);
         });
 
+        // --- Lazy-load image src rewrite ---
+        // Many sites render <img src="placeholder.gif" data-src="real.jpg">.
+        // Promote the real URL onto src so both the markdown body and the
+        // image download list reference the same URL.
+        clone.querySelectorAll('img').forEach(img => {
+          const srcset = img.getAttribute('data-srcset') || '';
+          const srcsetFirst = srcset.split(',')[0]?.trim().split(' ')[0] || '';
+          const real = img.getAttribute('data-src')
+            || img.getAttribute('data-original')
+            || img.getAttribute('data-lazy-src')
+            || srcsetFirst;
+          if (real) img.setAttribute('src', real);
+        });
+
         result.contentHtml = clone.innerHTML;
 
         // --- Image extraction ---
         const seen = new Set();
         clone.querySelectorAll('img').forEach(img => {
-          const src = img.getAttribute('data-src')
-            || img.getAttribute('data-original')
-            || img.getAttribute('src');
+          const src = img.getAttribute('src') || '';
           if (src && !src.startsWith('data:') && !seen.has(src)) {
             seen.add(src);
             result.imageUrls.push(src);
@@ -186,7 +199,7 @@ cli({
             referer = parsed.origin + '/';
         }
         catch { /* ignore */ }
-        return downloadArticle({
+        const result = await downloadArticle({
             title: data?.title || 'untitled',
             author: data?.author,
             publishTime: data?.publishTime,
@@ -197,6 +210,13 @@ cli({
             output: kwargs.output,
             downloadImages: kwargs['download-images'],
             imageHeaders: referer ? { Referer: referer } : undefined,
+            stdout: kwargs.stdout,
         });
+        // `--stdout` is a content-streaming mode. The markdown body already went
+        // to process.stdout inside downloadArticle(), so returning rows here
+        // would make Commander append table/JSON output to the same stdout
+        // stream and break piping.
+        return kwargs.stdout ? null : result;
     },
 });
+export const __test__ = { command };

package/clis/web/read.test.js

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockDownloadArticle } = vi.hoisted(() => ({
+    mockDownloadArticle: vi.fn(),
+}));
+
+vi.mock('@jackwener/opencli/download/article-download', () => ({
+    downloadArticle: mockDownloadArticle,
+}));
+
+const { __test__ } = await import('./read.js');
+
+describe('web/read stdout behavior', () => {
+    const read = __test__.command;
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue({
+            title: 'Example Article',
+            author: 'Author',
+            publishTime: '2026-04-22',
+            contentHtml: '<p>hello</p>',
+            imageUrls: ['https://example.com/a.jpg'],
+        }),
+    };
+
+    beforeEach(() => {
+        mockDownloadArticle.mockReset();
+        mockDownloadArticle.mockResolvedValue([{
+            title: 'Example Article',
+            author: 'Author',
+            publish_time: '2026-04-22',
+            status: 'success',
+            size: '1 KB',
+            saved: '-',
+        }]);
+        page.goto.mockClear();
+        page.wait.mockClear();
+        page.evaluate.mockClear();
+    });
+
+    it('returns null in --stdout mode so the CLI does not append result rows to stdout', async () => {
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: true,
+        });
+
+        expect(result).toBeNull();
+        expect(mockDownloadArticle).toHaveBeenCalledWith(
+            expect.objectContaining({
+                title: 'Example Article',
+                sourceUrl: 'https://example.com/article',
+            }),
+            expect.objectContaining({
+                output: '/tmp/out',
+                stdout: true,
+            }),
+        );
+    });
+
+    it('still returns the saved-row payload when writing to disk', async () => {
+        const rows = [{ title: 'Example Article', saved: '/tmp/out/Example Article/example.md' }];
+        mockDownloadArticle.mockResolvedValue(rows);
+
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: false,
+        });
+
+        expect(result).toBe(rows);
+    });
+});

package/clis/weread/ai-outline.js

@@ -0,0 +1,170 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CliError } from '@jackwener/opencli/errors';
+import { WEREAD_UA, WEREAD_WEB_ORIGIN, WEREAD_DOMAIN } from './utils.js';
+
+const WEB_API = `${WEREAD_WEB_ORIGIN}/web`;
+
+function buildCookieHeader(cookies) {
+    return cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+}
+
+async function postWebApiWithCookies(page, path, body) {
+    const url = `${WEB_API}${path}`;
+    const [apiCookies, domainCookies] = await Promise.all([
+        page.getCookies({ url }),
+        page.getCookies({ domain: WEREAD_DOMAIN }),
+    ]);
+    const merged = new Map();
+    for (const c of domainCookies) merged.set(c.name, c);
+    for (const c of apiCookies) merged.set(c.name, c);
+    const cookieHeader = buildCookieHeader(Array.from(merged.values()));
+
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'User-Agent': WEREAD_UA,
+            'Content-Type': 'application/json',
+            'Origin': WEREAD_WEB_ORIGIN,
+            'Referer': `${WEREAD_WEB_ORIGIN}/`,
+            ...(cookieHeader ? { 'Cookie': cookieHeader } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (resp.status === 401) {
+        throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+    }
+
+    let data;
+    try {
+        data = await resp.json();
+    } catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+    }
+
+    if (data?.errcode === -2010 || data?.errcode === -2012) {
+        throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+    }
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    return data;
+}
+
+async function postWebApi(path, body) {
+    const url = `${WEB_API}${path}`;
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'User-Agent': WEREAD_UA,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    try {
+        return await resp.json();
+    } catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+    }
+}
+
+cli({
+    site: 'weread',
+    name: 'ai-outline',
+    description: 'Get AI-generated outline for a book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'plain',
+    args: [
+        { name: 'book-id', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+        { name: 'limit', type: 'int', default: 200, help: 'Max outline items to return' },
+        { name: 'depth', type: 'int', default: 4, help: 'Max outline depth (2=topics, 3=key points, 4=details)' },
+        { name: 'raw', type: 'boolean', default: false, help: 'Output structured rows (chapter/idx/level/text) for programmatic use' },
+    ],
+    columns: undefined,
+    func: async (page, args) => {
+        const bookId = String(args['book-id'] || '').trim();
+        const rawMode = Boolean(args.raw);
+
+        const chapterData = await postWebApiWithCookies(page, '/book/chapterInfos', {
+            bookIds: [bookId],
+            sinces: [0],
+        });
+        const chapters = chapterData?.data?.[0]?.updated ?? [];
+        if (chapters.length === 0) {
+            throw new CliError('NOT_FOUND', 'No chapters found for this book', 'Check that the book ID is correct');
+        }
+
+        const chapterUids = chapters.map((c) => c.chapterUid);
+        const chapterNameMap = new Map();
+        for (const c of chapters) {
+            chapterNameMap.set(c.chapterUid, c.title ?? '');
+        }
+
+        const outlineData = await postWebApi('/book/outline', {
+            bookId,
+            chapterUids,
+        });
+
+        const itemsArray = outlineData?.itemsArray ?? [];
+        const maxDepth = Number(args.depth);
+        const rawRows = [];
+
+        for (const entry of itemsArray) {
+            const items = entry.items;
+            if (!Array.isArray(items) || items.length === 0) continue;
+
+            const chapterName = chapterNameMap.get(entry.chapterUid) ?? `Chapter ${entry.chapterUid}`;
+            let lastL3Idx = '';
+            let l4Counter = 0;
+
+            for (const item of items) {
+                const level = item.level ?? 1;
+                if (level <= 1) continue;
+                if (level > maxDepth) continue;
+
+                let idx = item.uiIdx ?? '';
+                if (level === 3 && idx) {
+                    lastL3Idx = idx;
+                    l4Counter = 0;
+                }
+                if (level === 4 && !idx && lastL3Idx) {
+                    l4Counter++;
+                    idx = `${lastL3Idx}.${l4Counter}`;
+                }
+
+                rawRows.push({ chapter: chapterName, idx, level, text: item.text ?? '' });
+            }
+        }
+
+        if (rawRows.length === 0) {
+            throw new CliError('NOT_FOUND', 'No AI outline available for this book', 'AI outlines may not be generated for all books');
+        }
+
+        if (rawMode) {
+            return rawRows.slice(0, Number(args.limit));
+        }
+
+        const grouped = new Map();
+        for (const row of rawRows) {
+            if (!grouped.has(row.chapter)) grouped.set(row.chapter, []);
+            grouped.get(row.chapter).push(row);
+        }
+
+        const results = [];
+        for (const [chapter, rows] of grouped) {
+            const lines = [`📖 ${chapter}`];
+            for (const row of rows) {
+                const indent = '  '.repeat(row.level - 2);
+                const prefix = row.level === 2 ? `${row.idx}. ` : `${row.idx} `;
+                lines.push(`${indent}${prefix}${row.text}`);
+            }
+            results.push({ outline: lines.join('\n') });
+        }
+
+        return results.slice(0, Number(args.limit));
+    },
+});