@jackwener/opencli 1.7.8 → 1.7.10

package/clis/eastmoney/quote.js

@@ -57,7 +57,7 @@ cli({
     'turnoverRate', 'amplitude', 'peDynamic', 'priceBook',
     'marketCap', 'floatMarketCap',
   ],
-  func: async (_page, args) => {
+  func: async (args) => {
     const raw = splitSymbols(args.symbols);
     if (raw.length === 0) {
       throw new CliError('INVALID_ARGUMENT', 'At least one symbol is required');

package/clis/eastmoney/rank.js

@@ -43,7 +43,7 @@ cli({
     { name: 'limit',  type: 'int',    default: 20,       help: '返回数量 (max 100)' },
   ],
   columns: ['rank', 'code', 'name', 'price', 'changePercent', 'change', 'turnover', 'volume', 'turnoverRate', 'peDynamic', 'marketCap'],
-  func: async (_page, args) => {
+  func: async (args) => {
     const market = String(args.market ?? 'hs-a').toLowerCase();
     const sortKey = String(args.sort ?? 'change').toLowerCase();
     const limit = Math.max(1, Math.min(Number(args.limit) || 20, 100));

package/clis/eastmoney/sectors.js

@@ -33,7 +33,7 @@ cli({
     { name: 'limit', type: 'int',   default: 20,         help: '返回数量 (max 100)' },
   ],
   columns: ['rank', 'code', 'name', 'price', 'changePercent', 'mainNet', 'leadStock', 'leadChangePercent', 'upCount', 'downCount'],
-  func: async (_page, args) => {
+  func: async (args) => {
     const typeKey = String(args.type ?? 'industry').toLowerCase();
     const fs = SECTOR_TYPES[typeKey];
     if (!fs) throw new CliError('INVALID_ARGUMENT', `Unknown sector type "${typeKey}". Valid: ${Object.keys(SECTOR_TYPES).join(', ')}`);

package/clis/facebook/marketplace-inbox.js

@@ -0,0 +1,83 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function normalizeLimit(value) {
+  const limit = Number(value ?? 20);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new ArgumentError('facebook marketplace-inbox --limit must be a positive integer');
+  }
+  return Math.min(limit, 100);
+}
+
+cli({
+  site: 'facebook',
+  name: 'marketplace-inbox',
+  description: 'List recent Facebook Marketplace buyer/seller conversations',
+  domain: 'www.facebook.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of conversations to return' },
+  ],
+  columns: ['index', 'buyer', 'listing', 'snippet', 'time', 'unread'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for facebook marketplace-inbox');
+    const limit = normalizeLimit(args.limit);
+    await page.goto('https://www.facebook.com/marketplace/inbox/');
+    await page.wait(4);
+
+    const result = await page.evaluate(String.raw`(() => {
+      const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+      const timeRe = /^(?:\d{1,2}:\d{2}\s?(?:AM|PM|am|pm|上午|下午)?|Mon|Tue|Wed|Thu|Fri|Sat|Sun|Today|Yesterday|\d+[mhdw]|\d+\s*(?:min|h|d|w))$/;
+      const text = document.body?.innerText || '';
+      if (/log in|sign in/i.test(text) && !/Marketplace/i.test(text)) {
+        return { authRequired: true, rows: [] };
+      }
+
+      const lines = text.split(/\n+/).map(clean).filter(Boolean);
+      const out = [];
+      const seen = new Set();
+      const skipBuyer = /^(Marketplace|Browse all|Notifications|Inbox|Marketplace access|Buying|Selling|Create new listing|Create multiple listings|Location|Categories|Vehicles|Property Rentals|All|Pending payment|Paid|To be shipped|Shipped|Cash on delivery|Completed|Filter by label)$/i;
+      for (let i = 0; i < lines.length - 2; i += 1) {
+        const buyer = lines[i];
+        const meta = lines[i + 1];
+        if (skipBuyer.test(buyer) || !/^·\s+/.test(meta)) continue;
+        const listing = meta.replace(/^·\s*/, '');
+        if (!listing || /^Within\b/i.test(listing)) continue;
+        const snippet = lines[i + 2] || '';
+        const time = timeRe.test(lines[i + 3] || '') ? lines[i + 3] : '';
+        const key = buyer + '|' + listing;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const nearby = lines.slice(Math.max(0, i - 2), i + 5).join(' ');
+        out.push({
+          buyer,
+          listing,
+          snippet,
+          time,
+          unread: /Unread/i.test(nearby),
+        });
+      }
+      return { authRequired: false, rows: out };
+    })()`);
+
+    if (result?.authRequired) {
+      throw new AuthRequiredError('facebook.com', 'Facebook Marketplace inbox requires an active signed-in Facebook session.');
+    }
+    const items = Array.isArray(result?.rows) ? result.rows : [];
+    if (items.length === 0) {
+      throw new EmptyResultError('facebook marketplace-inbox', 'No Marketplace inbox conversations were visible. Check that Marketplace inbox is available for this account.');
+    }
+    return items.slice(0, limit).map((item, index) => ({
+      index: index + 1,
+      buyer: item.buyer || '',
+      listing: item.listing || '',
+      snippet: item.snippet || '',
+      time: item.time || '',
+      unread: Boolean(item.unread),
+    }));
+  },
+});
+
+export const __test__ = {
+  normalizeLimit,
+};

package/clis/facebook/marketplace-listings.js

@@ -0,0 +1,83 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function normalizeLimit(value) {
+  const limit = Number(value ?? 20);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new ArgumentError('facebook marketplace-listings --limit must be a positive integer');
+  }
+  return Math.min(limit, 100);
+}
+
+cli({
+  site: 'facebook',
+  name: 'marketplace-listings',
+  description: 'List your Facebook Marketplace seller listings',
+  domain: 'www.facebook.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of listings to return' },
+  ],
+  columns: ['index', 'title', 'price', 'status', 'listed', 'clicks', 'actions'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for facebook marketplace-listings');
+    const limit = normalizeLimit(args.limit);
+    await page.goto('https://www.facebook.com/marketplace/you/selling/');
+    await page.wait(4);
+
+    const result = await page.evaluate(String.raw`(() => {
+      const clean = (s) => String(s || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
+      const allText = document.body?.innerText || '';
+      if (/log in|sign in/i.test(allText) && !/Marketplace/i.test(allText)) {
+        return { authRequired: true, rows: [] };
+      }
+
+      const lines = allText.split(/\n+/).map(clean).filter(Boolean);
+      const seen = new Set();
+      const out = [];
+      for (let i = 1; i < lines.length; i += 1) {
+        if (!/^(?:CA\$|\$)\s*\d+/.test(lines[i])) continue;
+        const title = lines[i - 1];
+        if (!title || /^(Hide|All listings|Needs attention|Marketplace|Selling)$/i.test(title)) continue;
+        if (seen.has(title)) continue;
+        seen.add(title);
+        const windowLines = lines.slice(i, i + 12);
+        const status = windowLines.find((line) => /^(Active|Sold|Pending|Draft)$/i.test(line)) || '';
+        const listed = windowLines.find((line) => /Listed on\b/i.test(line))?.replace(/^·\s*/, '') || '';
+        const clickLine = windowLines.find((line) => /clicks? on listing/i.test(line)) || '';
+        const clickMatch = clickLine.match(/([\d,.]+)\s+clicks? on listing/i);
+        const actions = windowLines.filter((line) => /^(Mark as sold|Mark as available|Relist this item|Share|Boost listing)$/i.test(line));
+        out.push({
+          title,
+          price: lines[i],
+          status,
+          listed,
+          clicks: clickMatch ? clickMatch[1] : '',
+          actions,
+        });
+      }
+      return { authRequired: false, rows: out };
+    })()`);
+
+    if (result?.authRequired) {
+      throw new AuthRequiredError('facebook.com', 'Facebook Marketplace seller listings require an active signed-in Facebook session.');
+    }
+    const items = Array.isArray(result?.rows) ? result.rows : [];
+    if (items.length === 0) {
+      throw new EmptyResultError('facebook marketplace-listings', 'No seller listings were visible. Check that Marketplace selling is available for this account.');
+    }
+    return items.slice(0, limit).map((item, index) => ({
+      index: index + 1,
+      title: item.title || '',
+      price: item.price || '',
+      status: item.status || '',
+      listed: item.listed || '',
+      clicks: item.clicks || '',
+      actions: Array.isArray(item.actions) ? item.actions.join(', ') : String(item.actions || ''),
+    }));
+  },
+});
+
+export const __test__ = {
+  normalizeLimit,
+};

package/clis/facebook/marketplace.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
+import './marketplace-listings.js';
+import './marketplace-inbox.js';
+
+function makePage(overrides = {}) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue([]),
+    ...overrides,
+  };
+}
+
+describe('facebook marketplace read commands', () => {
+  it('marketplace-listings navigates to selling page and returns limited listing rows', async () => {
+    const command = getRegistry().get('facebook/marketplace-listings');
+    expect(command).toBeDefined();
+    const page = makePage({
+      evaluate: vi.fn().mockResolvedValue({
+        authRequired: false,
+        rows: [
+          { title: 'Black electric standing desk', price: 'CA$80', status: 'Active', listed: 'Listed on 4/26', clicks: '87', actions: ['Mark as sold', 'Share'] },
+          { title: 'Large gray corduroy beanbag chair', price: 'CA$30', status: 'Sold', listed: 'Listed on 4/26', clicks: '52', actions: ['Mark as available', 'Relist this item'] },
+        ],
+      }),
+    });
+
+    const rows = await command.func(page, { limit: 1 });
+
+    expect(page.goto).toHaveBeenCalledWith('https://www.facebook.com/marketplace/you/selling/');
+    expect(page.wait).toHaveBeenCalledWith(4);
+    expect(rows).toEqual([
+      {
+        index: 1,
+        title: 'Black electric standing desk',
+        price: 'CA$80',
+        status: 'Active',
+        listed: 'Listed on 4/26',
+        clicks: '87',
+        actions: 'Mark as sold, Share',
+      },
+    ]);
+  });
+
+  it('marketplace-inbox navigates to inbox and returns recent buyer conversations', async () => {
+    const command = getRegistry().get('facebook/marketplace-inbox');
+    expect(command).toBeDefined();
+    const page = makePage({
+      evaluate: vi.fn().mockResolvedValue({
+        authRequired: false,
+        rows: [
+          { buyer: 'Kulwant', listing: 'White 3-tier rolling utility cart', snippet: 'Can I pick up today?', time: '3:43 PM', unread: true },
+          { buyer: 'Gabriel', listing: 'Black electric standing desk', snippet: 'Yes, still available.', time: '12:17 PM', unread: false },
+        ],
+      }),
+    });
+
+    const rows = await command.func(page, { limit: 2 });
+
+    expect(page.goto).toHaveBeenCalledWith('https://www.facebook.com/marketplace/inbox/');
+    expect(page.wait).toHaveBeenCalledWith(4);
+    expect(rows).toEqual([
+      { index: 1, buyer: 'Kulwant', listing: 'White 3-tier rolling utility cart', snippet: 'Can I pick up today?', time: '3:43 PM', unread: true },
+      { index: 2, buyer: 'Gabriel', listing: 'Black electric standing desk', snippet: 'Yes, still available.', time: '12:17 PM', unread: false },
+    ]);
+  });
+
+  it('throws EmptyResultError when Marketplace returns no inbox rows', async () => {
+    const command = getRegistry().get('facebook/marketplace-inbox');
+    const page = makePage({ evaluate: vi.fn().mockResolvedValue({ authRequired: false, rows: [] }) });
+
+    await expect(command.func(page, { limit: 5 })).rejects.toThrow(EmptyResultError);
+  });
+
+  it('throws AuthRequiredError when Marketplace returns a login page', async () => {
+    const command = getRegistry().get('facebook/marketplace-listings');
+    const page = makePage({ evaluate: vi.fn().mockResolvedValue({ authRequired: true, rows: [] }) });
+
+    await expect(command.func(page, { limit: 5 })).rejects.toThrow(AuthRequiredError);
+  });
+
+  it('throws ArgumentError for invalid limits', async () => {
+    const command = getRegistry().get('facebook/marketplace-listings');
+    const page = makePage();
+
+    await expect(command.func(page, { limit: 0 })).rejects.toThrow(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+});

package/clis/google/news.js

@@ -18,7 +18,7 @@ cli({
         { name: 'region', default: 'US', help: 'Region code (e.g. US, CN)' },
     ],
     columns: ['title', 'source', 'date', 'url'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const limit = Math.max(1, Math.min(Number(args.limit), 100));
         const lang = encodeURIComponent(args.lang);
         const region = encodeURIComponent(args.region);

package/clis/google/suggest.js

@@ -15,7 +15,7 @@ cli({
         { name: 'lang', default: 'zh-CN', help: 'Language code' },
     ],
     columns: ['suggestion'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const keyword = encodeURIComponent(args.keyword);
         const lang = encodeURIComponent(args.lang);
         const url = `https://suggestqueries.google.com/complete/search?client=firefox&q=${keyword}&hl=${lang}`;

package/clis/google/trends.js

@@ -16,7 +16,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     ],
     columns: ['title', 'traffic', 'date'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const limit = Math.max(1, Math.min(Number(args.limit), 100));
         const region = encodeURIComponent(args.region);
         const url = `https://trends.google.com/trending/rss?geo=${region}`;

package/clis/google-scholar/cite.js

@@ -0,0 +1,74 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { requireNonEmptyQuery } from '../_shared/common.js';
+
+cli({
+    site: 'google-scholar',
+    name: 'cite',
+    description: 'Get citation for a Google Scholar paper',
+    domain: 'scholar.google.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Paper title to search for' },
+        { name: 'style', default: 'bibtex', choices: ['bibtex', 'endnote', 'refman', 'refworks'], help: 'Citation format' },
+        { name: 'index', type: 'int', default: 1, help: 'Which search result to cite (1-based)' },
+    ],
+    columns: ['title', 'format', 'citation'],
+    navigateBefore: false,
+    func: async (page, kwargs) => {
+        const query = requireNonEmptyQuery(kwargs.query);
+        const format = kwargs.style || 'bibtex';
+        const index = Math.max(1, kwargs.index || 1) - 1;
+
+        await page.goto(`https://scholar.google.com/scholar?q=${encodeURIComponent(query)}&hl=en`);
+        await page.wait(3);
+
+        const clicked = await page.evaluate(`(() => {
+            var cites = document.querySelectorAll('a.gs_or_cit');
+            if (cites.length <= ${index}) return { ok: false, reason: 'result not found at index ${index + 1}' };
+            var titleEl = document.querySelectorAll('.gs_r.gs_or.gs_scl')[${index}];
+            var title = '';
+            if (titleEl) {
+                var t = titleEl.querySelector('.gs_rt a, h3 a');
+                title = t ? t.textContent.trim() : '';
+            }
+            cites[${index}].click();
+            return { ok: true, title: title };
+        })()`);
+
+        if (!clicked?.ok) {
+            throw new CommandExecutionError(clicked?.reason || `Could not find search result at index ${index + 1}`);
+        }
+
+        await page.wait(2);
+
+        const formatMap = { bibtex: 'BibTeX', endnote: 'EndNote', refman: 'RefMan', refworks: 'RefWorks' };
+        const formatLabel = formatMap[format] || 'BibTeX';
+
+        const citeUrl = await page.evaluate(`(() => {
+            var links = document.querySelectorAll('#gs_cit a.gs_citi');
+            for (var i = 0; i < links.length; i++) {
+                if (links[i].textContent.trim() === '${formatLabel}') return links[i].href;
+            }
+            return null;
+        })()`);
+
+        if (!citeUrl) {
+            throw new CommandExecutionError(`Could not find ${formatLabel} citation link for result ${index + 1}`);
+        }
+
+        await page.goto(citeUrl);
+        await page.wait(2);
+
+        const citation = await page.evaluate(`(() => {
+            return (document.body.innerText || '').trim();
+        })()`);
+
+        if (!citation) {
+            throw new CommandExecutionError(`${formatLabel} citation page returned an empty response`);
+        }
+
+        return [{ title: clicked.title, format: format, citation }];
+    },
+});

package/clis/google-scholar/cite.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './cite.js';
+
+describe('google-scholar cite command', () => {
+    const command = getRegistry().get('google-scholar/cite');
+
+    it('registers as a public browser command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('google-scholar');
+        expect(command.strategy).toBe('public');
+        expect(command.browser).toBe(true);
+    });
+
+    it('rejects empty queries before browser navigation', async () => {
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
+            name: 'ArgumentError',
+            code: 'ARGUMENT',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('throws when the requested search result index does not exist', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: false, reason: 'result not found at index 2' }),
+        };
+        await expect(command.func(page, { query: 'test', index: 2 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('looks up the requested citation style instead of only locking BibTeX', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true, title: 'Paper Title' })
+                .mockResolvedValueOnce('https://example.com/refworks')
+                .mockResolvedValueOnce('RefWorks citation body'),
+        };
+        const result = await command.func(page, { query: 'test', style: 'refworks' });
+        expect(result).toEqual([{ title: 'Paper Title', format: 'refworks', citation: 'RefWorks citation body' }]);
+        expect(page.evaluate.mock.calls[1][0]).toContain('RefWorks');
+    });
+});

package/clis/google-scholar/profile.js

@@ -0,0 +1,92 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
+
+cli({
+    site: 'google-scholar',
+    name: 'profile',
+    description: 'View a Google Scholar author profile',
+    domain: 'scholar.google.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'author', positional: true, required: true, help: 'Author name or Scholar user ID (e.g. JicYPdAAAAAJ)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max papers to show (max 20)' },
+    ],
+    columns: ['rank', 'title', 'cited', 'year'],
+    navigateBefore: false,
+    func: async (page, kwargs) => {
+        const author = requireNonEmptyQuery(kwargs.author, 'author');
+        const limit = clampInt(kwargs.limit, 10, 1, 20);
+
+        const isUserId = /^[A-Za-z0-9_-]{12}$/.test(author);
+        if (isUserId) {
+            await page.goto(`https://scholar.google.com/citations?user=${author}&hl=en&sortby=citedby`);
+        } else {
+            await page.goto(`https://scholar.google.com/citations?view_op=search_authors&mauthors=${encodeURIComponent(author)}&hl=en`);
+            await page.wait(3);
+
+            const profileClicked = await page.evaluate(`(() => {
+                var link = document.querySelector('.gs_ai_pho, .gsc_oai_photo, a[href*="citations?user="]');
+                if (link) { link.click(); return true; }
+                return false;
+            })()`);
+
+            if (!profileClicked) {
+                throw new CommandExecutionError(`No profile found for: ${author}`);
+            }
+        }
+
+        await page.wait(3);
+
+        const data = await page.evaluate(`(() => {
+            var name = (document.querySelector('#gsc_prf_in') || {}).textContent || '';
+            var affiliation = (document.querySelector('.gsc_prf_il') || {}).textContent || '';
+
+            var stats = document.querySelectorAll('#gsc_rsb_st td.gsc_rsb_std');
+            var citations = stats[0] ? stats[0].textContent.trim() : '';
+            var hIndex = stats[2] ? stats[2].textContent.trim() : '';
+            var i10Index = stats[4] ? stats[4].textContent.trim() : '';
+
+            var papers = [];
+            var rows = document.querySelectorAll('#gsc_a_b .gsc_a_tr');
+            for (var i = 0; i < rows.length && i < ${limit}; i++) {
+                var titleEl = rows[i].querySelector('.gsc_a_at');
+                var citedEl = rows[i].querySelector('.gsc_a_ac');
+                var yearEl = rows[i].querySelector('.gsc_a_y span');
+                if (titleEl) papers.push({
+                    rank: i + 1,
+                    title: titleEl.textContent.trim(),
+                    cited: citedEl ? citedEl.textContent.trim() : '0',
+                    year: yearEl ? yearEl.textContent.trim() : '',
+                });
+            }
+
+            return {
+                name: name.trim(),
+                affiliation: affiliation.trim(),
+                citations: citations,
+                hIndex: hIndex,
+                i10Index: i10Index,
+                papers: papers,
+            };
+        })()`);
+
+        if (!data?.name) {
+            throw new CommandExecutionError(`Could not load Google Scholar profile for: ${author}`);
+        }
+
+        if (!data.papers || data.papers.length === 0) {
+            throw new CommandExecutionError(`No papers found for: ${data.name || author}`);
+        }
+
+        const summary = {
+            rank: 0,
+            title: data.name + (data.affiliation ? ' (' + data.affiliation + ')' : ''),
+            cited: 'h=' + data.hIndex + ' i10=' + data.i10Index + ' total=' + data.citations,
+            year: '-',
+        };
+
+        return [summary, ...data.papers];
+    },
+});

package/clis/google-scholar/profile.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './profile.js';
+
+describe('google-scholar profile command', () => {
+    const command = getRegistry().get('google-scholar/profile');
+
+    it('registers as a public browser command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('google-scholar');
+        expect(command.strategy).toBe('public');
+        expect(command.browser).toBe(true);
+    });
+
+    it('rejects empty author before browser navigation', async () => {
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, { author: '   ' })).rejects.toMatchObject({
+            name: 'ArgumentError',
+            code: 'ARGUMENT',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('throws when author search does not resolve to a profile', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce(false),
+        };
+        await expect(command.func(page, { author: 'missing author' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws when the loaded profile has no papers', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({
+                name: 'Author Name',
+                affiliation: 'Org',
+                citations: '0',
+                hIndex: '0',
+                i10Index: '0',
+                papers: [],
+            }),
+        };
+        await expect(command.func(page, { author: 'JicYPdAAAAAJ' })).rejects.toThrow(CommandExecutionError);
+    });
+});

package/clis/google-scholar/search.js

@@ -23,7 +23,7 @@ cli({
       (() => {
         const normalize = v => (v || '').replace(/\\s+/g, ' ').trim();
         const results = [];
-        for (const el of document.querySelectorAll('.gs_r.gs_or.gs_scl, .gs_ri')) {
+        for (const el of document.querySelectorAll('.gs_r.gs_or.gs_scl')) {
           const container = el.querySelector('.gs_ri') || el;
           const titleEl = container.querySelector('.gs_rt a, h3 a');
           const title = normalize(titleEl?.textContent);

package/clis/google-scholar/search.test.js

@@ -20,4 +20,19 @@ describe('google-scholar search command', () => {
         });
         expect(page.goto).not.toHaveBeenCalled();
     });
+
+    it('locks dedup to outer Scholar result cards while preserving inner content extraction', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue([]),
+        };
+
+        await command.func(page, { query: 'transformer' });
+
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain("document.querySelectorAll('.gs_r.gs_or.gs_scl')");
+        expect(script).not.toContain(".gs_r.gs_or.gs_scl, .gs_ri");
+        expect(script).toContain("const container = el.querySelector('.gs_ri') || el");
+    });
 });

package/clis/hf/top.js

@@ -50,7 +50,7 @@ cli({
             return getWeekRange();
         return kwargs.date ?? new Date().toISOString().slice(0, 10);
     },
-    func: async (_page, kwargs) => {
+    func: async (kwargs) => {
         const period = String(kwargs.period ?? 'daily');
         const all = Boolean(kwargs.all);
         const endpoint = process.env.HF_ENDPOINT?.replace(/\/+$/, '') || 'https://huggingface.co';