@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/pixiv/illusts.js

@@ -0,0 +1,65 @@
+/**
+ * Pixiv illusts — list illustrations by an artist.
+ *
+ * Two-step process:
+ * 1. Fetch all illust IDs from the user's profile
+ * 2. Batch-fetch details for the most recent ones (max 48 IDs per request)
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { pixivFetch, BATCH_SIZE } from './utils.js';
+cli({
+    site: 'pixiv',
+    name: 'illusts',
+    description: "List a Pixiv artist's illustrations",
+    domain: 'www.pixiv.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'user-id', positional: true, required: true, help: 'Pixiv user ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created'],
+    func: async (page, kwargs) => {
+        const userId = String(kwargs['user-id'] ?? '');
+        const limit = Number(kwargs.limit) || 20;
+        if (!/^\d+$/.test(userId)) {
+            throw new CommandExecutionError(`Invalid user ID: ${userId}`);
+        }
+        // Step 1: get all illust IDs
+        const profileBody = await pixivFetch(page, `/ajax/user/${userId}/profile/all`, {
+            notFoundMsg: `User not found: ${userId}`,
+        });
+        const allIds = Object.keys(profileBody?.illusts || {})
+            .sort((a, b) => Number(b) - Number(a))
+            .slice(0, limit);
+        if (allIds.length === 0)
+            return [];
+        // Step 2: batch fetch details (Pixiv supports up to ~48 IDs per request)
+        const allWorks = {};
+        for (let offset = 0; offset < allIds.length; offset += BATCH_SIZE) {
+            const batch = allIds.slice(offset, offset + BATCH_SIZE);
+            const idsParam = batch.map(id => `ids[]=${id}`).join('&');
+            // pixivFetch navigates on each call; for subsequent batches we re-navigate,
+            // which is fine — the cookie is already attached.
+            const detailBody = await pixivFetch(page, `/ajax/user/${userId}/profile/illusts?${idsParam}&work_category=illustManga&is_first_page=${offset === 0 ? 1 : 0}`);
+            Object.assign(allWorks, detailBody?.works || {});
+        }
+        return allIds
+            .map((id, i) => {
+            const w = allWorks[id];
+            if (!w)
+                return null;
+            return {
+                rank: i + 1,
+                title: w.title || '',
+                illust_id: w.id,
+                pages: w.pageCount || 1,
+                bookmarks: w.bookmarkCount || 0,
+                tags: (w.tags || []).slice(0, 5).join(', '),
+                created: (w.createDate || '').split('T')[0],
+                url: 'https://www.pixiv.net/artworks/' + w.id,
+            };
+        })
+            .filter(Boolean);
+    },
+});

package/vendor/opencli/dist/clis/pixiv/illusts.test.d.ts

@@ -0,0 +1 @@
+import './illusts.js';

package/vendor/opencli/dist/clis/pixiv/illusts.test.js

@@ -0,0 +1,99 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './illusts.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/illusts');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv illusts', () => {
+    it('throws CommandExecutionError on invalid user ID', async () => {
+        const page = createPageMock([]);
+        await expect(cmd.func(page, { 'user-id': 'abc', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws generic error on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('returns empty array when user has no illusts', async () => {
+        const page = createPageMock([
+            { body: { illusts: {} } },
+        ]);
+        const result = await cmd.func(page, { 'user-id': '11', limit: 5 });
+        expect(result).toEqual([]);
+    });
+    it('fetches illust IDs then batch-fetches details', async () => {
+        const page = createPageMock([
+            // Step 1: profile/all returns illust IDs
+            {
+                body: {
+                    illusts: { '99999': null, '88888': null, '77777': null },
+                },
+            },
+            // Step 2: batch detail response
+            {
+                body: {
+                    works: {
+                        '99999': {
+                            id: '99999',
+                            title: 'Latest Work',
+                            pageCount: 2,
+                            bookmarkCount: 300,
+                            tags: ['original', 'fantasy'],
+                            createDate: '2025-01-15T12:00:00+09:00',
+                        },
+                        '88888': {
+                            id: '88888',
+                            title: 'Older Work',
+                            pageCount: 1,
+                            bookmarkCount: 150,
+                            tags: ['landscape'],
+                            createDate: '2024-12-01T10:00:00+09:00',
+                        },
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { 'user-id': '11', limit: 3 }));
+        // Should be sorted newest first (99999 > 88888 > 77777)
+        expect(result).toHaveLength(2); // 77777 has no detail data, filtered out
+        expect(result[0]).toMatchObject({
+            rank: 1,
+            title: 'Latest Work',
+            illust_id: '99999',
+            pages: 2,
+            bookmarks: 300,
+            created: '2025-01-15',
+        });
+        expect(result[1]).toMatchObject({
+            rank: 2,
+            title: 'Older Work',
+            illust_id: '88888',
+        });
+    });
+    it('respects the limit on illust IDs fetched', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illusts: { '100': null, '200': null, '300': null, '400': null, '500': null },
+                },
+            },
+            {
+                body: {
+                    works: {
+                        '500': { id: '500', title: 'W5', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+                        '400': { id: '400', title: 'W4', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { 'user-id': '11', limit: 2 }));
+        expect(result).toHaveLength(2);
+    });
+});

package/vendor/opencli/dist/clis/pixiv/ranking.yaml

@@ -0,0 +1,53 @@
+site: pixiv
+name: ranking
+description: Pixiv illustration rankings (daily/weekly/monthly)
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  mode:
+    type: str
+    default: daily
+    description: Ranking mode
+    choices: [daily, weekly, monthly, rookie, original, male, female, daily_r18, weekly_r18]
+  page:
+    type: int
+    default: 1
+    description: Page number
+  limit:
+    type: int
+    default: 20
+    description: Number of results
+
+pipeline:
+  - navigate: https://www.pixiv.net
+
+  - evaluate: |
+      (async () => {
+        const mode = ${{ args.mode | json }};
+        const page = ${{ args.page | json }};
+        const limit = ${{ args.limit | json }};
+        const res = await fetch(
+          'https://www.pixiv.net/ranking.php?mode=' + mode + '&p=' + page + '&format=json',
+          { credentials: 'include' }
+        );
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
+          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
+        }
+        const data = await res.json();
+        const items = (data?.contents || []).slice(0, limit);
+        return items.map((item, i) => ({
+          rank: item.rank,
+          title: item.title,
+          author: item.user_name,
+          user_id: item.user_id,
+          illust_id: item.illust_id,
+          pages: item.illust_page_count,
+          bookmarks: item.illust_bookmark_count,
+          url: 'https://www.pixiv.net/artworks/' + item.illust_id
+        }));
+      })()
+
+columns: [rank, title, author, illust_id, pages, bookmarks]

package/vendor/opencli/dist/clis/pixiv/search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pixiv search — search illustrations by keyword/tag.
+ *
+ * Uses the internal Ajax search API with browser cookies for authentication.
+ */
+export {};

package/vendor/opencli/dist/clis/pixiv/search.js

@@ -0,0 +1,43 @@
+/**
+ * Pixiv search — search illustrations by keyword/tag.
+ *
+ * Uses the internal Ajax search API with browser cookies for authentication.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { pixivFetch } from './utils.js';
+cli({
+    site: 'pixiv',
+    name: 'search',
+    description: 'Search Pixiv illustrations by keyword',
+    domain: 'www.pixiv.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword or tag' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'order', type: 'str', default: 'date_d', help: 'Sort order', choices: ['date_d', 'date', 'popular_d', 'popular_male_d', 'popular_female_d'] },
+        { name: 'mode', type: 'str', default: 'all', help: 'Search mode', choices: ['all', 'safe', 'r18'] },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+    ],
+    columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks', 'tags'],
+    func: async (page, kwargs) => {
+        const { query, limit = 20, order = 'date_d', mode = 'all', page: pageNum = 1 } = kwargs;
+        const encoded = encodeURIComponent(query);
+        // Pixiv search API requires the keyword in BOTH the URL path and the `word` query param.
+        const body = await pixivFetch(page, `/ajax/search/illustrations/${encoded}`, { params: { word: query, order, mode, p: pageNum, s_mode: 's_tag_full', type: 'illust_and_ugoira' } });
+        const items = body?.illust?.data || [];
+        return items
+            .filter((item) => item.id)
+            .slice(0, Number(limit))
+            .map((item, i) => ({
+            rank: i + 1,
+            title: item.title || '',
+            author: item.userName || '',
+            user_id: item.userId || '',
+            illust_id: item.id,
+            pages: item.pageCount || 1,
+            bookmarks: item.bookmarkCount || 0,
+            tags: (item.tags || []).slice(0, 5).join(', '),
+            url: 'https://www.pixiv.net/artworks/' + item.id,
+        }));
+    },
+});

package/vendor/opencli/dist/clis/pixiv/search.test.d.ts

@@ -0,0 +1 @@
+import './search.js';

package/vendor/opencli/dist/clis/pixiv/search.test.js

@@ -0,0 +1,83 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './search.js';
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('pixiv/search');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+describe('pixiv search', () => {
+    it('throws AuthRequiredError on 401', async () => {
+        const page = createPageMock([{ __httpError: 401 }]);
+        await expect(cmd.func(page, { query: '初音ミク', limit: 5 })).rejects.toThrow(AuthRequiredError);
+    });
+    it('throws generic error on non-auth HTTP failure', async () => {
+        const page = createPageMock([{ __httpError: 500 }]);
+        await expect(cmd.func(page, { query: 'test', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+    it('returns ranked results with correct fields', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illust: {
+                        data: [
+                            {
+                                id: '12345',
+                                title: 'Miku Illustration',
+                                userName: 'artist1',
+                                userId: '100',
+                                pageCount: 3,
+                                bookmarkCount: 500,
+                                tags: ['初音ミク', 'VOCALOID', 'ミク'],
+                            },
+                            {
+                                id: '67890',
+                                title: 'Another Art',
+                                userName: 'artist2',
+                                userId: '200',
+                                pageCount: 1,
+                                bookmarkCount: 100,
+                                tags: ['オリジナル'],
+                            },
+                        ],
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { query: '初音ミク', limit: 10 }));
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({
+            rank: 1,
+            title: 'Miku Illustration',
+            author: 'artist1',
+            illust_id: '12345',
+            pages: 3,
+            bookmarks: 500,
+        });
+        expect(result[1]).toMatchObject({ rank: 2, illust_id: '67890' });
+    });
+    it('respects the limit parameter', async () => {
+        const page = createPageMock([
+            {
+                body: {
+                    illust: {
+                        data: [
+                            { id: '1', title: 'A', userName: 'u1', userId: '1', pageCount: 1, bookmarkCount: 0, tags: [] },
+                            { id: '2', title: 'B', userName: 'u2', userId: '2', pageCount: 1, bookmarkCount: 0, tags: [] },
+                            { id: '3', title: 'C', userName: 'u3', userId: '3', pageCount: 1, bookmarkCount: 0, tags: [] },
+                        ],
+                    },
+                },
+            },
+        ]);
+        const result = (await cmd.func(page, { query: 'test', limit: 2 }));
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty array when no results', async () => {
+        const page = createPageMock([{ body: { illust: { data: [] } } }]);
+        const result = await cmd.func(page, { query: 'nonexistent', limit: 10 });
+        expect(result).toEqual([]);
+    });
+});

package/vendor/opencli/dist/clis/pixiv/test-utils.d.ts

@@ -0,0 +1,12 @@
+import type { IPage } from '../../types.js';
+/**
+ * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
+ *
+ * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
+ * the evaluate results should match the raw Pixiv Ajax response format:
+ * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
+ * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
+ *
+ * Additional methods can be overridden via the overrides parameter.
+ */
+export declare function createPageMock(evaluateResults: any[], overrides?: Partial<IPage>): IPage;

package/vendor/opencli/dist/clis/pixiv/test-utils.js

@@ -0,0 +1,23 @@
+import { vi } from 'vitest';
+/**
+ * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
+ *
+ * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
+ * the evaluate results should match the raw Pixiv Ajax response format:
+ * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
+ * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
+ *
+ * Additional methods can be overridden via the overrides parameter.
+ */
+export function createPageMock(evaluateResults, overrides) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        ...overrides,
+    };
+}

package/vendor/opencli/dist/clis/pixiv/user.yaml

@@ -0,0 +1,46 @@
+site: pixiv
+name: user
+description: View Pixiv artist profile
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  uid:
+    type: str
+    required: true
+    positional: true
+    description: Pixiv user ID
+
+pipeline:
+  - navigate: https://www.pixiv.net
+
+  - evaluate: |
+      (async () => {
+        const uid = ${{ args.uid | json }};
+        const res = await fetch(
+          'https://www.pixiv.net/ajax/user/' + uid + '?full=1',
+          { credentials: 'include' }
+        );
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
+          if (res.status === 404) throw new Error('User not found: ' + uid);
+          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
+        }
+        const data = await res.json();
+        const b = data?.body;
+        if (!b) throw new Error('User not found');
+        return [{
+          user_id: uid,
+          name: b.name,
+          premium: b.premium ? 'Yes' : 'No',
+          following: b.following,
+          illusts: typeof b.illusts === 'object' ? Object.keys(b.illusts).length : (b.illusts || 0),
+          manga: typeof b.manga === 'object' ? Object.keys(b.manga).length : (b.manga || 0),
+          novels: typeof b.novels === 'object' ? Object.keys(b.novels).length : (b.novels || 0),
+          comment: (b.comment || '').slice(0, 80),
+          url: 'https://www.pixiv.net/users/' + uid
+        }];
+      })()
+
+columns: [user_id, name, premium, following, illusts, manga, novels, comment]

package/vendor/opencli/dist/clis/pixiv/utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pixiv shared helpers: authenticated Ajax fetch with standard error handling.
+ *
+ * All Pixiv Ajax APIs return `{ error: false, body: ... }` on success.
+ * On failure the HTTP status code is used to distinguish auth (401/403),
+ * not-found (404), and other errors.
+ */
+import type { IPage } from '../../types.js';
+/**
+ * Navigate to Pixiv (to attach cookies) then fetch a Pixiv Ajax API endpoint.
+ *
+ * Handles the common navigate → evaluate(fetch) → error-check pattern used
+ * by every Pixiv TS adapter.
+ *
+ * @param page  - Browser page instance
+ * @param path  - API path, e.g. '/ajax/illust/12345'
+ * @param opts  - Optional query params
+ * @returns     - The parsed `body` from the JSON response
+ * @throws AuthRequiredError on 401/403
+ * @throws CommandExecutionError on 404 or other HTTP errors
+ */
+export declare function pixivFetch(page: IPage, path: string, opts?: {
+    params?: Record<string, string | number>;
+    notFoundMsg?: string;
+}): Promise<any>;
+/** Maximum number of illust IDs per batch detail request (Pixiv server limit). */
+export declare const BATCH_SIZE = 48;

package/vendor/opencli/dist/clis/pixiv/utils.js

@@ -0,0 +1,49 @@
+/**
+ * Pixiv shared helpers: authenticated Ajax fetch with standard error handling.
+ *
+ * All Pixiv Ajax APIs return `{ error: false, body: ... }` on success.
+ * On failure the HTTP status code is used to distinguish auth (401/403),
+ * not-found (404), and other errors.
+ */
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+const PIXIV_DOMAIN = 'www.pixiv.net';
+/**
+ * Navigate to Pixiv (to attach cookies) then fetch a Pixiv Ajax API endpoint.
+ *
+ * Handles the common navigate → evaluate(fetch) → error-check pattern used
+ * by every Pixiv TS adapter.
+ *
+ * @param page  - Browser page instance
+ * @param path  - API path, e.g. '/ajax/illust/12345'
+ * @param opts  - Optional query params
+ * @returns     - The parsed `body` from the JSON response
+ * @throws AuthRequiredError on 401/403
+ * @throws CommandExecutionError on 404 or other HTTP errors
+ */
+export async function pixivFetch(page, path, opts = {}) {
+    await page.goto(`https://${PIXIV_DOMAIN}`);
+    const qs = opts.params
+        ? '?' + Object.entries(opts.params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&')
+        : '';
+    const url = `https://${PIXIV_DOMAIN}${path}${qs}`;
+    const data = await page.evaluate(`
+    (async () => {
+      const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+      if (!res.ok) return { __httpError: res.status };
+      return await res.json();
+    })()
+  `);
+    if (data?.__httpError) {
+        const status = data.__httpError;
+        if (status === 401 || status === 403) {
+            throw new AuthRequiredError(PIXIV_DOMAIN, 'Authentication required — please log in to Pixiv in Chrome');
+        }
+        if (status === 404) {
+            throw new CommandExecutionError(opts.notFoundMsg || `Pixiv resource not found (HTTP 404)`);
+        }
+        throw new CommandExecutionError(`Pixiv request failed (HTTP ${status})`);
+    }
+    return data?.body;
+}
+/** Maximum number of illust IDs per batch detail request (Pixiv server limit). */
+export const BATCH_SIZE = 48;

package/vendor/opencli/dist/clis/producthunt/browse.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/producthunt/browse.js

@@ -0,0 +1,99 @@
+/**
+ * Product Hunt category browse — INTERCEPT strategy.
+ *
+ * Navigates to a Product Hunt category page and scrapes the top-rated products.
+ * Shows all-time best products for a category (ranked by review score, not daily votes).
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
+cli({
+    site: 'producthunt',
+    name: 'browse',
+    description: 'Best products in a Product Hunt category',
+    domain: 'www.producthunt.com',
+    strategy: Strategy.INTERCEPT,
+    args: [
+        {
+            name: 'category',
+            type: 'string',
+            positional: true,
+            required: true,
+            help: `Category slug, e.g. vibe-coding, ai-agents, developer-tools`,
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+    ],
+    columns: ['rank', 'name', 'tagline', 'reviews', 'url'],
+    func: async (page, args) => {
+        const count = Math.min(Number(args.limit) || 20, 50);
+        const slug = String(args.category || '').trim().toLowerCase();
+        await page.installInterceptor('producthunt.com');
+        await page.goto(`https://www.producthunt.com/categories/${slug}`);
+        await page.waitForCapture(5);
+        const domItems = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+
+        // Card links: <a class="...flex-col" href="/products/<slug>"> (not review links)
+        const cardLinks = Array.from(document.querySelectorAll('a[href^="/products/"]')).filter(a => {
+          const href = a.getAttribute('href') || '';
+          const cls = a.className || '';
+          return cls.includes('flex-col') && !href.includes('/reviews');
+        });
+
+        for (const cardLink of cardLinks) {
+          const href = cardLink.getAttribute('href');
+          if (!href || seen.has(href)) continue;
+
+          // Child 0: div with name (strip "Launched this month/week/year" noise)
+          const nameDiv = cardLink.querySelector('div');
+          const rawName = nameDiv?.textContent?.trim() || '';
+          const name = rawName
+            .replace(/\\s*Launched\\s+this\\s+(month|week|year|day)\\s*/gi, '')
+            .replace(/\\s*Featured\\s*/gi, '')
+            .trim();
+
+          // Child 1: span.text-secondary — tagline
+          const taglineEl = cardLink.querySelector('span.text-secondary, span[class*="text-secondary"]');
+          const tagline = taglineEl?.textContent?.trim() || '';
+
+          if (!name) continue;
+
+          // Find reviews count from sibling /reviews link
+          let reviews = '';
+          let container = cardLink.parentElement;
+          for (let i = 0; i < 5 && container; i++) {
+            const reviewLink = container.querySelector('a[href="' + href + '/reviews"]');
+            if (reviewLink) {
+              reviews = (reviewLink.textContent?.trim() || '').replace(/\\s*reviews?\\s*/i, '').trim();
+              break;
+            }
+            container = container.parentElement;
+          }
+
+          seen.add(href);
+          results.push({
+            name,
+            tagline: tagline.slice(0, 120),
+            reviews: reviews || '0',
+            url: 'https://www.producthunt.com' + href,
+          });
+        }
+
+        return results;
+      })()
+    `);
+        const items = Array.isArray(domItems) ? domItems : [];
+        if (items.length === 0) {
+            throw new CliError('NO_DATA', `No products found for category "${slug}"`, 'Check the category slug or try: ' + PRODUCTHUNT_CATEGORY_SLUGS.slice(0, 5).join(', '));
+        }
+        return items.slice(0, count).map((item, i) => ({
+            rank: i + 1,
+            name: item.name,
+            tagline: item.tagline,
+            reviews: item.reviews,
+            url: item.url,
+        }));
+    },
+});

package/vendor/opencli/dist/clis/producthunt/hot.d.ts

@@ -0,0 +1 @@
+export {};