@jackwener/opencli 1.7.7 → 1.7.9

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';